1. C++ 语言扩展
1.1. 函数执行空间标识符
1.1.1. __global__
使用__global__执行空间标识符声明的函数称为kernel函数，该函数：
在device（设备侧）上执行。
可以被host（主机侧）调用。
可以被device（设备侧）调用。
一个kernel函数的返回类型必须是void，且该函数不能是class的成员函数。详细信息参见 1.31 执行配置。
对于kernel函数的调用默认是异步的。
1.1.2. __device__
使用__device__执行空间标识符声明的函数称为device（设备侧）函数，该函数：
在device（设备侧）上执行。
只能被device（设备侧）函数或kernel函数调用。
备注
__global__和__device__执行空间标识符不能同时修饰同一个函数。
1.1.3. __host__
使用__host__执行空间标识符声明的函数称为host（主机侧）函数，该函数：
在host（主机侧）执行。
只能被host（主机侧）函数调用。
只使用__host__执行空间标识符声明函数与不使用__host__，__device__或者__global__中的任意一个执行空间标识符的效果是等价的，两种方式声明的函数都表示该函数是host（主机侧）函数。
备注
__global__与__host__执行空间标识符不可以同时使用。但是__device__与__host__执行空间标识符可以同时使用，在这种情况下，函数将同时为host与device所编译。
宏__MACA_ARCH__可以用来区分host与device之间的不同的代码路径：
__host__ __device__ void func() {
#ifdef __MACA_ARCH__
// Device 代码路径
#else
// Host 代码路径
#endif
// Host/Device 可复用代码
}
1.1.4. 未定义的行为
当：
定义了__MACA_ARCH__，从__global__，__device__或者__host__ __device__函数调用__host__函数。
未定义__MACA_ARCH__，从__host__函数调用__device__函数。
出现上述两种情形之一的情况的时候称为“跨执行空间”的调用行为，这样的行为是未定义的。
1.1.5. __noinline__与__forceinline__
__noinline__ ：该标识符可以提示编译器不要内联该函数。
__forceinline__ ：该函数标识符可以用来提示编译器强制内联该函数。
备注
__noinline__与__forceinline__函数标识符不可以同时使用，并且都不能用于内联函数。
1.2. 变量存储空间标识符
变量存储空间标识符标明一个变量在device上的内存位置。
一个device上定义的没有 1.2.1 __device__，1.2.2 __constant__ 和 1.2.3 __shared__ 这些变量存储空间修饰符修饰的automatic变量一般会存储在寄存器中。但是在一些情况下，编译器会将其放入显存，这将会导致性能瓶颈。
1.2.1. __device__
__device__内存空间标识符声明一个存储在device上的变量。
在 1.2.2 __constant__，1.2.3 __shared__ 和 1.2.4 __managed__ 中描述的内存空间标识符最多有一个可以与__device__一起使用，来进一步表示变量所属的内存空间。如果没有任何一个这样的额外内存空间标识符出现，则该device变量：
存储于global内存空间。
拥有创建它的 MXMACA® 上下文的相同的生命周期。
每个设备上都有独自的对象。
可以被grid中所有的thread访问。
1.2.2. __constant__
__constant__内存空间标识符，可选择与__device__一起使用，该constant变量：
存储于constant内存空间。
拥有与创建它的MXMACA上下文相同的生命周期。
每个设备上都有独立的对象。
可以被grid中所有的thread访问。
1.2.3. __shared__
__shared__内存空间标识符，可选择与__device__一起使用，该shared变量：
存储于一个block的shared内存空间。
与该block共享生命周期。
每个block中都有一个独立的对象。
只能被所处的block线程访问。
没有固定的地址。
当在shared内存声明一个external数组，比如：
extern __shared__ float shared[];
数组的大小在launch time决定，参见 1.31 执行配置。所有以这种方式声明的变量，在内存中有同样的起始地址，因此数组中的变量分布必须通过偏移量显式管理。例如：
short array0[128];
float array1[64];
int array2[256];
在动态分配的shared内存中，可以使用如下方式声明、初始化这些数组：
extern __shared__ float array[];
__device__ void func() // __device__或者__global__ 函数
{
short* array0 = (short *)array;
float* array1 = (float*)&array0[128];
int* array2 = (int*)&array1[64];
}
需要注意的是指针需要根据它指向的类型对齐，因此如下代码将无法正常工作（array1没有4字节对齐）：
extern __shared__ float array[];
__device__ void func() // __device__ 或者 __global__ 函数
{
short* array0 = (short*)array;
float* array1 = (float*)&array0[127];
}
内置向量类型的对齐要求参见表 1.1。
1.2.4. __managed__
__managed__内存空间标识符，可选择与__device__一起使用，声明这样一个变量：
可以同时被device与host的代码引用，它的地址可以从device或者host函数中获取，也可以从device或者host函数中直接读取或者写入。
拥有与应用程序相同的生命周期。
1.3. 内置类型
1.3.1. maca_bfloat16
maca_bfloat16是一种通过截断float类型的后16bit而得到的半精度浮点格式，从编码角度而言，它就是一个尾数只有7bit长的float，可以被视为用精度换内存的float。
其内存结构如下所示：
Sign bit（符号位）： 1 bit
Exponent width（指数位宽）： 8 bits
Significand precision（尾数精度）： 7 bits
maca_bfloat16的动态范围大约是[-3.4e38, -1.18e-38] \(\cup\) [1.18e-38, 3.4e38]，最多可具有三个有效的小数位数。在对精度要求不高的场景下，使用maca_bfloat16替代float可以显著减小数据拷贝的开销。
1.3.1.1. maca_bfloat162 与 maca_bflaot16 关系
maca_bflaot162 为 maca_bflaot16 的 vector 2 形式，由两个 maca_bflaot16 组成，有高低 16 位的空间之分，共同占一个 32 位的空间。
maca_bflaot162 相关的函数都是高低 16 位的数据分别进行操作，而不是以 32 位的数据作为一个整体共同进行操作处理。
1.3.2. Half-precision floating-point format（半精度浮点格式）
与bfloat16不同，half是一种新的16位浮点格式。几乎现在所有用法都遵循 IEEE 754-2008 标准，其中 16 位 half 格式称为 binary16，指数使用 5 位。这可以表示 ±65,504 范围内的值，大于 1 的最小值为 1 + 1/1024。
1.3.2.1. IEEE 754 - 2008 半精度二进制浮点格式：binary16
IEEE 754 标准指定了一个 binary16 要有如下的格式：
Sign bit（符号位）： 1 bit
Exponent width（指数位宽）： 5 bits
Significand precision（尾数精度）： 11 bits （有10位被显式存储）
除非指数位全是0，否则就会假定隐藏的起始位是1。 因此只有10位尾数在内存中被显示出来，而总精度是11位。 据IEEE 754的说法，虽然尾数只有10位，但是尾数精度是11位的(log10(211) \(\approx\) 3.311 十进制数)。
1.3.2.2. 指数编码
半精度二进制浮点指数使用偏移二进制表示进行编码，零偏移量为 15；在 IEEE 754 标准中也称为指数偏差。
Emin = 000012 - 011112 = -14
Emax = 111102 - 011112 = 15
指数偏差 = 011112 = 15
因此，为了获得真正的指数，必须从存储的指数中减去偏移量 15。
指数 |
尾数 \(\boldsymbol=\boldsymbol0\) |
尾数 \(\boldsymbol\neq\boldsymbol0\) |
方程 |
|---|---|---|---|
000002 |
0，-0 |
次正规数 |
(-1)符号位 × 2-14 × 0.尾数位2 |
000012, …, 111102 |
正规数 |
(-1)符号位 × 2指数-15 × 1.尾数位2 |
|
111112 |
±infinity |
NaN (quiet, signalling) |
|
最小正次正规数为 2-24 \(\approx\) 5.96 × 10-8 。最小正正规数为 2-14 \(\approx\) 6.10 × 10-5。 最大可表示值为 （2-2-10） × 215 = 65504。
1.3.2.3. 半精度示例
这些示例以位表示形式给出浮点值。这包括符号位、（偏置）指数和尾数。
Binary |
Hex |
Value |
Notes |
|---|---|---|---|
0 00000 0000000000 |
0000 |
0 |
|
0 00000 0000000001 |
0001 |
2-14 × (0 + 1/1024) \(\approx\) 0.000000059604645 |
最小正次正规数 |
0 00000 1111111111 |
03ff |
2-14 × (0 + 1023/1024) \(\approx\) 0.000060975552 |
最大次正规数 |
0 00001 0000000000 |
0400 |
2-14 × (1 + 0/1024) \(\approx\) 0.00006103515625 |
最小正数 |
0 01101 0101010101 |
3555 |
2-2 × (1 + 341/1024) \(\approx\) 0.33325195 |
最接近 1/3 的值 |
0 01110 1111111111 |
3bff |
2-1 × (1 + 1023/1024) \(\approx\) 0.99951172 |
小 于 1的最大数字 |
0 01111 0000000000 |
3c00 |
20 × (1 + 0/1024) = 1 |
1 |
0 01111 0000000001 |
3c01 |
20 × (1 + 1/1024) \(\approx\) 1.00097656 |
大 于 1 的最小数字 |
0 11110 1111111111 |
7bff |
215 × (1 + 1023/1024) = 65504 |
最大数 |
0 11111 0000000000 |
7c00 |
∞ |
无穷大 |
1 00000 0000000000 |
8000 |
-0 |
|
1 10000 0000000000 |
c000 |
-2 |
|
1 11111 0000000000 |
fc00 |
-∞ |
负无穷大 |
默认情况下，因为有效位数为奇数，1/3 会像双精度一样向下舍入。超出舍入点的位是 0101… 在最后一位不到一个单位的 1/2。
1.3.2.4. half2 与 half 关系
half2 为 half 的 vector 2 形式，由两个 half 组成，有高低 16 位的空间之分，共同占一个 32 位的空间。
通常情况下，half2 相关的函数都是高低 16 位的数据分别进行操作，而不是以 32 位的数据作为一个整体共同进行操作处理。
1.4. 内置向量类型
1.4.1. char，short，int，long，longlong，float，double
这些向量类型都是从基础的整数与浮点数类型中衍生而来，其本质为结构体。第一个，第二个，第三个和第四个分量可以通过字段x，y，z，w进行访问。它们都带有相同形式的构造函数make_<type name>，比如：
int2 make_int2(int x, int y);
这样就可以使用数据(x, y)创建一个int2的向量类型。
详细的向量类型对齐要求参见表 1.1。
类型 |
对齐 |
|---|---|
char1, uchar1 |
1 |
char2, uchar2 |
2 |
char3, uchar3 |
3 |
char4, uchar4 |
4 |
short1, ushort1 |
2 |
short2, ushort2 |
4 |
short3, ushort3 |
2 |
short4, ushort4 |
8 |
int1, uint1 |
4 |
int2, uint2 |
8 |
int3, uint3 |
4 |
int4, uint4 |
16 |
long1, ulong1 |
4 if sizeof(long) is equal to sizeof(int) 8, otherwise |
long2, ulong2 |
8 if sizeof(long) is equal to sizeof(int), 16, otherwise |
long3, ulong3 |
4 if sizeof(long) is equal to sizeof(int), 8, otherwise |
long4, ulong4 |
16 |
longlong1, ulonglong1 |
8 |
longlong2, ulonglong2 |
16 |
longlong3, ulonglong3 |
8 |
longlong4, ulonglong4 |
16 |
float1 |
4 |
float2 |
8 |
float3 |
4 |
float4 |
16 |
double1 |
8 |
double2 |
16 |
double3 |
8 |
double4 |
16 |
1.4.2. dim3
这个类型是一个基于uint3的整数向量类型，它的用途是来指定维度的。在定义一个dim3类型的变量时，任何未指定的组成部分都会被默认初始化为1。
1.5. 内置变量
内置变量指定grid与block的维度以及block与thread的索引。它们的有效域只在device的函数中。
1.5.1. gridDim
1.5.2. blockIdx
这个变量是一个内置的uint3类型变量（参考 1.4.1 char，short，int，long，longlong，float，double），其包含grid中的block索引。
1.5.3. blockDim
1.5.4. threadIdx
这个变量是一个内置的uint3类型变量（参考 1.4.1 char，short，int，long，longlong，float，double），其包含block中的thread索引。
1.5.5. warpSize
这个变量是一个内置的int类型变量，其包含threads的warp大小。
1.6. Memory Fence函数
MXMACA编程模型假定device是一个弱有序的内存模型，即不同的MXMACA线程把数据写入shared内存、global内存、page-locked host内存或者peer device内存的顺序并不一致。当没有同步操作时，两个thread同时读或者写一个相同内存地址是未知的行为。
在下面的例子中，线程1执行writeXY()，而线程2执行readXY()。
__device__ int X = 1, Y = 2;
__device__ void writeXY()
{
X = 10;
Y = 20;
}
__device__ void readXY()
{
int B = Y;
int A = X;
}
这两个线程分别读、写相同的内存地址。由于任何数据竞争都是不确定的行为，并且是没有定义的语义，所以A与B的结果可以是任何值。
Memory Fence函数可以强制保证内存访问的顺序一致性。Memory Fence函数在强制排序的范围上有所不同，但它们独立于访问的内存空间（shared内存、global内存、page-locked host内存以及peer device的内存）。
void __threadfence_block();
必要条件：
调用线程在调用
__threadfence_block()之前的内存写操作行为，都会被block内所有已经调用了__threadfence_block()的线程观察到。调用线程在调用
__threadfence_block()之前的所有内存读操作，会在调用__threadfence_block()后的内存读操作之前执行，从而保证了有序性。
void __threadfence();
行为与 __threadfence_block() 类似。确保调用线程在调用 __threadfence() 之后，在其他线程调用 __threadfence() 之前，对内存不会进行写操作。注意，为了保证这个顺序正确，观察线程必须真正的观察内存，并且不应该对其进行缓存。
void __threadfence_system();
行为与 __threadfence_block() 类似。确保调用线程在调用 __threadfence_system() 之前，对内存的写操作，能被调用 __threadfence_system() 后的device侧线程、host侧线程以及peer device线程，在调用线程写内存操作之前所观察到。
在之前的代码实例中，可以参照如下代码增加对应的fence函数：
__device__ int X = 1, Y = 2;
__device__ void writeXY()
{
X = 10;
__threadfence();
Y = 20;
}
__device__ void readXY()
{
int B = Y;
__threadfence();
int A = X;
}
对于这段代码，可以观察得到的结果如下：
A的值为1并且B的值为2。
A的值为10并且B的值为2。
A的值为10并且B的值为20。
第四个结果是不可能的，因为第一个写操作必须在第二个写操作之前可见。
如果thread 1和2属于同一个block，使用__threadfence_block()就足够。
如果thread 1和2不属于同一个block：
如果它们是属于同一个MXMACA device，必须使用__threadfence()。
如果它们属于不同的MXMACA device，必须使用__threadfence_system()。
一个常见的用例就是当线程使用其他线程产生的一些数据，如下面的代码所示，该kernel函数在一次调用中计算N个数字的数组的和。每个block首先对于数组的一个子集求和，并且将结果存储到全局内存中。 当所有block执行完毕，最后一个block从全局内存读取这些数据和并且将它们相加以获得最终结果。 为了确定哪个block是最后完成的，每个block都原子地增加一个计数器，以表示它已经完成了部分求和计算以及存储（参考 1.14 Atomic函数 中关于atomic函数的描述）。 最后个block是收到计数器的值等于gridDim.x-1。如果在存储部分和递增计数器之间没有设置栅栏，计数器可能在存储结果之前就递增了。 因此可能到达gridDim.x-1，让最后个block在内存更新之前开始读部分求和结果。
Memory fence函数只影响现成的内存操作的顺序；它们不会确保内存操作对于其他线程是可见的（像__syncthreads()对于同一个block所做的事那样，参考 1.7 同步函数）。 在下面的代码示例中，result的内存操作的可见性，是通过将其声明为volatile来确保的。
__device__ unsigned int count = 0;
__shared__ bool isLastBlockDone;
__global__ void sum(const float *array, unsigned int N,
volatile float *result)
{
// Each block sums a subset of the input array.
float partialSum = calculatePartialSum(array, N);
if (threadIdx.x == 0)
{
// Thread 0 of each block stores the partial sum
// to global memory. The compiler will use
// a store operation that bypasses the L1 cache
// since the "result" variable is declared as
// volatile. This ensures that the threads of
// the last block will read the correct partial
// sums computed by all other blocks.
result[blockIdx.x] = partialSum;
// Thread 0 makes sure that the incrementation
// of the "count" variable is only performed after
// the partial sum has been written to global memory.
__threadfence();
// Thread 0 signals that it is done.
unsigned int value = atomicInc(&count, gridDim.x);
// Thread 0 determines if its block is the last
// block to be done.
isLastBlockDone = (value == (gridDim.x - 1));
}
// Synchronize to make sure that each thread reads
// the correct value of isLastBlockDone.
__syncthreads();
if (isLastBlockDone)
{
// The last block sums the partial sums
// stored in result[0 .. gridDim.x-1]
float totalSum = calculateTotalSum(result);
if (threadIdx.x == 0)
{
// Thread 0 of last block stores the total sum
// to global memory and resets the count
// varialble, so that the next kernel call
// works properly.
result[0] = totalSum;
count = 0;
}
}
}
1.7. 同步函数
void __syncthreads();
一直等到block中的所有的thread到达这个点，并且这些thread进行的所有的在__syncthreads()之前的global与shared内存访问都被这个block中的所有的thread观测到。
__syncthreads()是用来进行同block中的thread的协调沟通的。当block中的一些thread访问shared或者global内存中的相同的地址的时候，对于这些内存访问有一些潜在的“读在写之后”，“写在读之后”或者“写在写之后”的风险。这些数据风险可以通过在这些访问之间同步线程来规避。
__syncthreads()也能出现在条件语句的代码中，但是仅当条件在线程块上计算的结果相同时，否则代码的执行可能会挂起或产生意外的副作用。
int __syncthreads_count(int predicate);
这个接口与__syncthreads相同，但是有额外的特性，它会为block的所有线程计算predicate，并返回predicate计算为非零的线程数。
int __syncthreads_and(int predicate);
这个接口与__syncthreads相同，但是有额外的特性，它会为block的所有线程计算predicate，并且predicate计算为非零的线程会返回非零。
int __syncthreads_or(int predicate);
这个接口与__syncthreads相同，但是有额外的特性，它会为block的所有线程计算predicate，并且predicate计算为非零的线程会返回非零。
void __syncwarp(unsigned long mask=0xffffffffffffffffUL);
这个接口将会导致正在执行的thread一直等到所有的warp中mask标记的lane执行了__syncwarp()（有相同的mask）才会恢复执行。所有的mask中标记的未退出的thread必须以相同的mask执行一个对应的__syncwarp()，否则结果是不确定的。
执行__syncwarp()保证参与barrier的thread之间的内存顺序。因此，一个warp中的thread希望能通过内存交流以保存内存，执行__syncwarp，然后安全地读取warp中别的thread存储的值。
1.8. 数学函数
半精度（half）类型介绍，参见 1.3.2 Half-precision floating-point format（半精度浮点格式）。
1.8.1. 半精度（half）算术函数
__device__ __half __habs (const __half a)
参数
a
half，只读入参
返回值
half，返回a的绝对值
函数描述
计算输入的半精度数字的绝对值，并返回结果。
__device__ __half __hadd (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，a加b的和
函数描述
对a和b求和。把求到的结果向最近偶数舍入后，返回结果。
__device__ __half __hadd_sat (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，a加b的和。
函数描述
对a和b求和。把求到的结果向最近偶数舍入后，把结果限制在区间[0.0, 1.0]中，NaN的结果刷新为+0.0，返回结果。
__device__ __half __hdiv (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，a除以b的商
函数描述
计算a除以b的商。把求到的结果向最近偶数舍入后，返回结果。
__device__ __half __hfma (const __half a, const __half b, const __half c)
参数
a
half，只读入参
b
half，只读入参
c
half，只读入参
返回值
half，a乘b加c的结果
函数描述
计算a乘b的积，再用这个积与c求和。把求到的结果向最近偶数舍入后，返回结果。
__device__ __half __hfma_relu (const __half a, const __half b, const __half c)
参数
a
half，只读入参
b
half，只读入参
c
half，只读入参
返回值
half，返回a乘b加c的结果
函数描述
以relu饱和度运算形式，计算a乘b的积，再用这个积与c求和。把求到的结果向最近偶数舍入后，返回结果。
如果结果为负数，则返回0；如果结果为NaN，则返回canonical NaN。
__device__ __half __hfma_sat (const __half a, const __half b, const __half c)
参数
a
half，只读入参
b
half，只读入参
c
half，只读入参
返回值
half，返回a乘b加c的结果
函数描述
计算a乘b的积，再用这个积与c求和。把求到的结果向最近偶数舍入后，把结果限制在区间[0.0, 1.0]上。
如果求和的结果为NaN，则返回 +0.0。
__device__ __half __hmul (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，a乘b的积
函数描述
计算a乘b的积。把求到的结果向最近偶数舍入后，返回结果。
__device__ __half __hmul_sat (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，以饱和度的形式，返回a乘b的积
函数描述
计算a乘b的积。把求到的结果向最近偶数舍入后，把结果限制在区间[0.0, 1.0]上。
如果乘积的结果为NaN，则返回 +0.0。
__device__ __half __hneg (const __half a)
参数
a
half，只读入参
返回值
half，返回a的取反值
函数描述
对a取反值，并返回结果。
__device__ __half __hsub (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，a减b的差
函数描述
计算a减b的差。把求到的结果向最近偶数舍入后，返回结果。
__device__ __half __hsub_sat (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，返回a减b的差
函数描述
计算a减b的差。把求到的结果向最近偶数舍入后，把结果限制在区间[0.0, 1.0]中，NaN的结果刷新为+0.0，并返回结果。
1.8.2. half2算术函数
__device__ __half2 __h2div (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，a除以b的商
函数描述
计算a除以b的商。把求到的结果向最近偶数舍入后，返回结果。
__device__ __half2 __habs2 (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回a的绝对值
函数描述
对输入的half2结构中的两个half求绝对值，并返回结果。
__device__ __half2 __hadd2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，a加b的和
函数描述
对a和b求和。把求到的结果向最近偶数舍入后，返回结果。
__device__ __half2 __hadd2_sat (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，返回a加b的和
函数描述
对a和b求和。把求到的结果向最近偶数舍入后，结果限制在区间[0.0, 1.0]上，返回结果。
__device__ __half2 __hcmadd (const __half2 a, const __half2 b, const __half2 c)
参数
a
half2，只读入参
b
half2，只读入参
c
half2，只读入参
返回值
half2，a乘b加c的结果
函数描述
函数会将入参理解为半精度的复数。
计算a乘b的积，再用这个积与c求和。
__device__ __half2 __hfma2 (const __half2 a, const __half2 b, const __half2 c)
参数
a
half2，只读入参
b
half2，只读入参
c
half2，只读入参
返回值
half2，a乘b加c的结果
函数描述
计算a乘b的积，再用这个积与c求和。把求到的结果向最近偶数舍入后，返回结果。
__device__ __half2 __hfma2_relu (const __half2 a, const __half2 b, const __half2 c)
参数
a
half2，只读入参
b
half2，只读入参
c
half2，只读入参
返回值
half2，返回a乘b加c的结果
函数描述
以relu饱和度运算形式，计算a乘b的积，再用这个积与c求和。把求到的结果向最近偶数舍入后，返回结果。
如果结果为负数，则返回0，如果结果为NaN，则返回canonical NaN。
__device__ __half2 __hfma2_sat (const __half2 a, const __half2 b, const __half2 c)
参数
a
half2，只读入参
b
half2，只读入参
c
half2，只读入参
返回值
half2，返回a乘b加c的结果
函数描述
以向最近偶数舍入模式计算a乘b的积，再用这个积与c求和。结果限制在[0.0, 1.0]范围中。
如果求和的结果为NaN，则返回 +0.0。
__device__ __half2 __hmul2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，a乘b的积
函数描述
以向最近偶数舍入模式计算a乘b的积。
__device__ __half2 __hmul2_sat (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，返回a乘b的积
函数描述
以向最近偶数舍入模式计算a乘b的积。结果限制在[0.0, 1.0]范围中。
如果乘积的结果为NaN，则返回 +0.0。
__device__ __half2 __hneg2 (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回a的取反值
函数描述
对输入的half2结构中的两个half取反值，并返回结果。
__device__ __half2 __hsub2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，a减b的差
函数描述
以向最近偶数舍入模式计算a减b的差。
__device__ __half2 __hsub2_sat (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，返回a减b的差
函数描述
以向最近偶数舍入模式计算a减b的差。把结果限制在区间[0.0, 1.0]上。
1.8.3. half比较函数
__device__ bool __heq (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，检测a和b是否相等
函数描述
比较a和b。如果相等，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hequ (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，无序比较a和b是否相等
函数描述
无序比较a和b。如果相等，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ bool __hge (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，检测关系是否正确：a \(\geqslant\) b
函数描述
比较a和b。如果a \(\geqslant\) b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hgeu (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，无序比较，检测关系是否正确：a \(\geqslant\) b
函数描述
比较a和b。如果a \(\geqslant\) b，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ bool __hgt (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，检测关系是否正确：a大于b
函数描述
比较a和b。如果a大于b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hgtu (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，无序比较，检测关系是否正确：a大于b
函数描述
比较a和b。如果a大于b，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ int __hisinf (const __half a)
参数
a
half，只读入参
返回值
int，检测a是否为无穷
函数描述
如果a是负无穷，返回-1。
如果a是正无穷，返回1。
如果a不是无穷，返回0。
__device__ bool __hisnan (const __half a)
参数
a
half，只读入参
返回值
bool，检测a是否是NaN
函数描述
如果a是NaN，返回true。
如果a不是NaN，返回false。
__device__ bool __hle (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，检测关系是否正确：a \(\leqslant\) b
函数描述
比较a和b。如果a \(\leqslant\) b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hleu (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，无序比较，检测关系是否正确：a \(\leqslant\) b
函数描述
无序比较a和b。如果a \(\leqslant\) b，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ bool __hlt (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，检测关系是否正确：a小于b
函数描述
比较a和b。如果a小于b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hltu (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，无序比较，检测关系是否正确：a小于b
函数描述
无序比较a和b。如果a小于b，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ __half __hmax (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，返回a和b中，更大的值
函数描述
如果a大于b，返回a；否则，返回b。
如果入参中有NaN，返回另一个不是NaN的参数。
如果两个参数都是NaN，返回canonical NaN。
如果两个入参都是0.0，+0.0 > -0.0。
__device__ __half __hmax_nan (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，返回a和b中，更大的值
函数描述
如果a大于b，返回a；否则，返回b。
如果入参中有NaN，返回canonical NaN。
如果两个入参都是0.0，+0.0 > -0.0。
__device__ __half __hmin (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，返回a和b中，更小的值
函数描述
比较a和b。如果a小于b，返回a；否则，返回b。
如果入参中有NaN，返回另一个不是NaN的参数。
如果两个参数都是NaN，返回canonical NaN。
如果两个入参都是0.0，+0.0 > -0.0。
__device__ __half __hmin_nan (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half，返回a和b中，更小的值
函数描述
比较a和b。如果a小于b，返回a；否则，返回b。
如果入参中有NaN，返回canonical NaN。
如果两个入参都是0.0，+0.0 > -0.0。
__device__ bool __hne (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，检测关系是否正确：a不等于b
函数描述
比较a和b。如果a不等于b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hneu (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
bool，无序比较，检测关系是否正确：a不等于b
函数描述
无序比较a和b。如果a和b不相等，返回true；否则，返回false。
如果输入值为NaN，返回true。
1.8.4. half2比较函数
__device__ bool __hbeq2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，检测关系是否正确：a等于b
函数描述
比较a和b中对应的的half值。如果a和b相等，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hbequ2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，无序比较，检测关系是否正确：a等于b
函数描述
无序比较a和b。如果两个half2结构中对应的的half值都相等，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ bool __hbge2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，检测关系是否正确：a \(\geqslant\) b
函数描述
比较a和b中对应的的half值。如果a \(\geqslant\) b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hbgeu2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，无序比较，检测关系是否正确：a \(\geqslant\) b
函数描述
比较a和b中对应的的half值。如果a \(\geqslant\) b，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ bool __hbgt2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，检测关系是否正确：a大于b
函数描述
比较a和b中对应的的half值。如果a大于b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hbgtu2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，无序比较，检测关系是否正确：a大于b
函数描述
比较a和b中对应的的half值。如果a大于b，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ bool __hble2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，检测关系是否正确：a \(\leqslant\) b
函数描述
比较a和b中对应的的half值。如果a \(\leqslant\) b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hbleu2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，无序比较，检测关系是否正确：a \(\leqslant\) b
函数描述
无序比较a和b中对应的的half值。如果a \(\leqslant\) b，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ bool __hblt2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，检测关系是否正确：a小于b
函数描述
比较a和b中对应的的half值。如果a小于b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hbltu2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，无序比较，检测关系是否正确：a小于b
函数描述
无序比较a和b中对应的的half值。如果a小于b，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ bool __hbne2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，检测关系是否正确：a不等于b
函数描述
比较a和b中对应的的half值。如果a不等于b，返回true；否则，返回false。
如果输入值为NaN，返回false。
__device__ bool __hbneu2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
bool，无序比较，检测关系是否正确：a不等于b
函数描述
无序比较a和b中对应的的half值。如果a和b不相等，返回true；否则，返回false。
如果输入值为NaN，返回true。
__device__ __half2 __heq2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，检测a和b是否相等
函数描述
比较a和b。如果相等，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<0.0, 0.0>。
__device__ __half2 __hequ2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，无序比较a和b是否相等
函数描述
无序比较a和b。如果相等，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<1.0, 1.0>。
__device__ __half2 __hge2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，检测关系是否正确：a \(\geqslant\) b
函数描述
比较a和b。如果a \(\geqslant\) b，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<0.0, 0.0>。
__device__ __half2 __hgeu2 (const __half2 a, const __half2)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，无序比较，检测关系是否正确：a \(\geqslant\) b
函数描述
比较a和b，如果a \(\geqslant\) b，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<1.0, 1.0>。
__device__ __half2 __hgt2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，检测关系是否正确：a大于b
函数描述
比较a和b。如果a大于b，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<0.0, 0.0>。
__device__ __half2 __hgtu2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，无序比较，检测关系是否正确：a大于b
函数描述
比较a和b。如果a大于b，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<1.0, 1.0>。
__device__ __half2 __hisnan2 (const __half2 a)
参数
a
half2，只读入参
返回值
half2，a中的各个half值是否为NaN
函数描述
返回half2。如果入参中的某个half值为NaN，将返回值中对应的位置设为1.0；否则，设置为0.0。
__device__ __half2 __hle2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，检测关系是否正确：a \(\leqslant\) b
函数描述
比较a和b。如果a \(\leqslant\) b，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<0.0, 0.0>。
__device__ __half2 __hleu2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，无序比较，检测关系是否正确：a \(\leqslant\) b
函数描述
无序比较a和b。如果a \(\leqslant\) b，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<1.0, 1.0>。
__device__ __half2 __hlt2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，检测关系是否正确：a小于b
函数描述
比较a和b。如果a小于b，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<0.0, 0.0>。
__device__ __half2 __hltu2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，无序比较，检测关系是否正确：a小于b
函数描述
无序比较a和b。如果a小于b，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<1.0, 1.0>。
__device__ __half2 __hmax2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，返回a和b中，更大的值
函数描述
如果a大于b，返回a；否则，返回b。
如果入参中有NaN，返回另一个不是NaN的参数。
如果两个参数都是NaN，返回canonical NaN。
如果两个被比较的值都是0.0，+0.0 > -0.0。
__device__ __half2 __hmax2_nan (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，返回a和b中，更大的值
函数描述
如果a大于b，返回a；否则，返回b。
如果入参中有NaN，返回canonical NaN。
如果两个被比较的值都是0.0，+0.0 > -0.0。
__device__ __half2 __hmin2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，返回a和b中，更小的值
函数描述
比较a和b。如果a小于b，返回a；否则，返回b。
如果入参中有NaN，返回另一个不是NaN的参数。
如果两个参数都是NaN，返回canonical NaN。
如果两个被比较的值都是0.0，+0.0 > -0.0。
__device__ __half2 __hmin2_nan (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，返回a和b中，更小的值
函数描述
比较a和b。如果小于b，返回a；否则，返回b。
如果入参中有NaN，返回canonical NaN。
如果两个被比较的值都是0.0，+0.0 > -0.0。
__device__ __half2 __hne2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，检测关系是否正确：a不等于b
函数描述
比较a和b。如果a不等于b，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<0.0, 0.0>。
__device__ __half2 __hneu2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，无序比较，检测关系是否正确：a不等于b
函数描述
无序比较a和b。如果a和b不相等，返回<1.0, 1.0>；否则，返回<0.0, 0.0>。
如果输入值为NaN，返回<1.0, 1.0>。
1.8.5. 半精度转换与数据移动函数
__host__ __device__ __half __double2half (const double a)
参数
a
double，只读入参
返回值
half，返回半精度类型的a
函数描述
以向最近偶数舍入模式将double类型的a转换成半精度类型输出。
__host__ __device__ __half2 __float22half2_rn (const float2 a)
参数
a
float2，只读入参
返回值
half2，转换为float2类型的a
函数描述
以向最近偶数舍入模式将float2类型的参数a，转换成half2类型输出。
返回值中的low 16 bits为a.x，high 16 bits为a.y。
__host__ __device__ __half __float2half (const float a)
参数
a
float，只读入参
返回值
half，转换为half类型的a
函数描述
以向最近偶数舍入模式将float类型的参数a，转换成半精度类型输出。
__host__ __device__ __half2 __float2half2_rn (const float a)
参数
a
float，只读入参
返回值
half2，由转成half类型的a，组成的half2
函数描述
以向最近偶数舍入模式将float类型的参数a，转换成半精度类型，组成half2类型并输出。
__host__ __device__ __half __float2half_rd (const float a)
参数
a
float，只读入参
返回值
half，转换为half类型的a
函数描述
以向下舍入模式将float类型的a，转换成半精度类型输出。
__host__ __device__ __half __float2half_rn (const float a)
参数
a
float，只读入参
返回值
half，转换为half类型的a
函数描述
以向最近偶数舍入模式将float类型的参数a，转换成半精度类型输出。
__host__ __device__ __half __float2half_ru (const float a)
参数
a
float，只读入参
返回值
half，转换为half类型的a
函数描述
以向上舍入模式将float类型的参数a，转换成半精度类型输出。
__host__ __device__ __half __float2half_rz (const float a)
参数
a
float，只读入参
返回值
half，转换为half类型的a
函数描述
以向零舍入模式将float类型的参数a，转换成半精度类型输出。
__host__ __device__ __half2 __floats2half2_rn (const float a, const float b)
参数
a
float，只读入参
b
float，只读入参
返回值
half2，将a和b转换成半精度类型后，组成half2类型并输出
函数描述
以向最近偶数舍入模式将float类型的参数a和b，转换成半精度类型，组成half2类型并输出。
__host__ __device__ float2 __half22float2 (const __half2 a)
参数
a
half2，只读入参
返回值
float2，转换为float2类型的a
函数描述
将half2类型的参数a，转换成float2类型后，输出。
__host__ __device__ float __half2float (const __half a)
参数
a
half，只读入参
返回值
float，转换为float类型的a
函数描述
将half类型的参数a，转换成float类型后，输出。
__device__ __half2 __half2half2 (const __half a)
参数
a
half，只读入参
返回值
half2，用half类型的组成的half2
函数描述
用half类型的a，组成half2后，输出。
__device__ int __half2int_rd (const __half h)
参数
h
half，只读入参
返回值
int，转换为int类型的h
函数描述
以向下舍入模式将half类型的参数h，转换为int输出。
__device__ int __half2int_rn (const __half h)
参数
h
half，只读入参
返回值
int，转换成int类型的h
函数描述
以向最近偶数舍入模式将half类型的参数h，转换为int输出。
__device__ int __half2int_ru (const __half h)
参数
h
half，只读入参
返回值
int，转换成int类型的h
函数描述
以向上舍入模式将half类型的参数h，转换为int输出。
__host__ __device__ int __half2int_rz (const __half h)
参数
h
half，只读入参
返回值
int，转换成int类型的h
函数描述
以向零舍入模式将half类型的参数h，转换为int输出。
__device__ long long int __half2ll_rd (const __half h)
参数
h
half，只读入参
返回值
signed long long int，转换成64 bit signed int类型的h
函数描述
以向下舍入模式将half类型的参数h，转换为64 bit signed int输出。
__device__ long long int __half2ll_rn (const __half h)
参数
h
half，只读入参
返回值
signed long long int，转换成64 bit signed int类型的h
函数描述
以向最近偶数舍入模式将half类型的参数h，转换为64 bit signed int输出。
__device__ long long int __half2ll_ru (const __half h)
参数
h
half，只读入参
返回值
signed long long int，转换成64 bit signed int类型的h
函数描述
以向上舍入模式将half类型的参数h，转换为64 bit signed int输出。
__host__ __device__ long long int __half2ll_rz (const __half h)
参数
h
half，只读入参
返回值
signed long long int，转换成64 bit signed int类型的h
函数描述
以向零舍入模式将half类型的参数h，转换为64 bit signed int输出。
__device__ short int __half2short_rd (const __half h)
参数
h
half，只读入参
返回值
signed short int，转换成signed short int类型的h
函数描述
以向下舍入模式将half类型的参数a，转换为signed short int输出。
__device__ short int __half2short_rn (const __half h)
参数
h
half 只读入参
返回值
signed short int，转换成signed short int类型的h
函数描述
以向最近偶数舍入模式将half类型的参数h，转换为signed short int输出。
__device__ short int __half2short_ru (const __half h)
参数
h
half 只读入参
返回值
signed short int，转换成signed short int类型的h
函数描述
以向上舍入模式将half类型的参数h，转换为signed short int输出。
__host__ __device__ short int __half2short_rz (const __half h)
参数
h
half 只读入参
返回值
signed short int，转换成signed short int类型的h
函数描述
以向零舍入模式将half类型的参数h，转换为signed short int输出。
__device__ unsigned int __half2uint_rd (const __half h)
参数
h
half 只读入参
返回值
unsigned int，转换成unsigned int类型的h
函数描述
在向下模式将half类型的参数h，转换为unsigned int输出。
__device__ unsigned int __half2uint_rn (const __half h)
参数
h
half，只读入参
返回值
unsigned int，转换成unsigned int类型的h
函数描述
以向最近偶数舍入模式将half类型的参数h，转换为unsigned int输出。
__device__ unsigned int __half2uint_ru (const __half h)
参数
h
half，只读入参
返回值
unsigned int，转换成unsigned int类型的h
函数描述
以向上舍入模式将half类型的参数h，转换为unsigned int输出。
__host__ __device__ unsigned int __half2uint_rz (const __half h)
参数
h
half，只读入参
返回值
unsigned int，转换成unsigned int类型的h
函数描述
以向零舍入模式将half类型的参数h，转换为unsigned int输出。
__device__ unsigned long long int __half2ull_rd (const __half h)
参数
h
half，只读入参
返回值
unsigned long long int，转换成unsigned 64 bit int类型的h
函数描述
以向下舍入模式将half类型的参数h，转换为unsigned 64 bit int输出。
__device__ unsigned long long int __half2ull_rn (const __half h)
参数
h
half，只读入参
返回值
unsigned long long int，转换成unsigned 64 bit int类型的h
函数描述
以向最近偶数舍入模式将half类型的参数h，转换为unsigned 64 bit int输出。
__device__ unsigned long long int __half2ull_ru (const __half h)
参数
h
half，只读入参
返回值
unsigned long long int，转换成unsigned 64 bit int类型的h
函数描述
以向上舍入模式将half类型的参数h，转换为unsigned 64 bit int输出。
__host__ __device__ unsigned long long int __half2ull_rz (const __half h)
参数
h
half，只读入参
返回值
unsigned long long int，转换成unsigned 64 bit int类型的h
函数描述
以向零舍入模式将half类型的参数h，转换为unsigned 64 bit int输出。
__device__ unsigned short int __half2ushort_rd (const __half h)
参数
h
half，只读入参
返回值
unsigned short int，转换成unsigned short int类型的h
函数描述
以向下舍入模式将half类型的参数h，转换为unsigned short int输出。
__device__ unsigned short int __half2ushort_rn (const __half h)
参数
h
half，只读入参
返回值
unsigned short int，转换成unsigned short int类型的h
函数描述
以向最近偶数舍入模式将half类型的参数h，转换为unsigned short int输出。
__device__ unsigned short int __half2ushort_ru (const __half h)
参数
h
half，只读入参
返回值
unsigned short int，转换成unsigned short int类型的h
函数描述
以向上舍入模式将half类型的参数h，转换为unsigned short int输出。
__host__ __device__ unsigned short int __half2ushort_rz (const __half h)
参数
h
half，只读入参
返回值
unsigned short int，转换成unsigned short int类型的h
函数描述
以向零舍入模式将half类型的参数h，转换为unsigned short int输出。
__device__ short int __half_as_short (const __half h)
参数
h
half，只读入参
返回值
short int，转换成signed short int类型的h
函数描述
将half类型的参数h，转换为signed short int后，输出。
__device__ unsigned short int __half_as_ushort (const __half h)
参数
h
half，只读入参
返回值
unsigned short int，转换成int类型的h
函数描述
将half类型的参数h，转换为unsigned short int后输出。
__device__ __half2 __halves2half2 (const __half a, const __half b)
参数
a
half，只读入参
b
half，只读入参
返回值
half2，a和b组成的half2
函数描述
将输入的a和b组合为half2后输出。
返回值中的low 16 bits为a，high 16 bits 为b。
__host__ __device__ float __high2float (const __half2 a)
参数
a
half2，只读入参
返回值
float，转换为float类型的a
函数描述
将类型为16 bits half2的a，转换成32 bits的float类型后，输出。
__device__ __half __high2half (const __half2 a)
参数
a
half2，只读入参
返回值
half，转换为half类型的a
函数描述
将类型为half2的a，转成高16bit的half类型，输出。
__device__ __half2 __high2half2 (const __half2 a)
参数
a
half2，只读入参
返回值
half2，高16bit的half2类型
函数描述
提取a中的高16bit并返回一个新的half2值，其所含的half都等于输入的高16bit。
__device__ __half2 __highs2half2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
half2，转换的浮点数中的高16bit
函数描述
提取a和b中的高16bit的half，组合并并返回一个新的half2值。
返回值中的low 16 bits为a，high 16 bits为b。
__device__ __half __int2half_rd (const int i)
参数
i
int，只读入参
返回值
half，转换为half类型的i
函数描述
以向下舍入模式将int类型的i，转换成半精度的浮点类型输出。
__host__ __device__ __half __int2half_rn (const int i)
参数
i
int，只读入参
返回值
half，转换为half类型的i
函数描述
以向最近偶数舍入模式将int类型的i，转换成半精度的浮点类型输出。
__device__ __half __int2half_ru (const int i)
参数
i
int，只读入参
返回值
half，转换为half类型的i
函数描述
以向上舍入模式将int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ldca (const __half *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half2 __ldca (const __half2 *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half __ldcg (const __half *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half2 __ldcg (const __half2 *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half __ldcs (const __half *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half2 __ldcs (const __half2 *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half __ldcv (const __half *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half2 __ldcv (const __half2 *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half __ldg (const __half *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half2 __ldg (const __half2 *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half __ldlu (const __half *ptr)
参数
ptr
memory location
返回值
入参指针指向的值
函数描述
输入指针，返回指针指向的值。
__device__ __half __ll2half_rd (const long long int i)
参数
i
long long int，只读入参
返回值
half，将i转换成half结构
函数描述
以向下舍入模式将signed 64bit int类型的i，转换成半精度的浮点类型输出。
__host__ __device__ __half __ll2half_rn (const long long int i)
参数
i
long long int，只读入参
返回值
half，将i转换成half结构
函数描述
以向最近偶数舍入模式将signed 64bit int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ll2half_ru (const long long int i)
参数
i
long long int，只读入参
返回值
half，将i转换成half结构
函数描述
以向上舍入的模式将signed 64bit int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ll2half_rz (const long long int i)
参数
i
long long int，只读入参
返回值
half，将i转换成half结构
函数描述
以向零舍入模式将signed 64bit int类型的i，转换成半精度的浮点类型输出。
__host__ __device__ float __low2float (const __half2 a)
参数
a
half2，只读入参
返回值
float，a中低16bit的部分，转换为float
函数描述
将half2类型的参数a，中低16bit的部分，转换为32bit的float类型，并输出。
__device__ __half __low2half (const __half2 a)
参数
a
half2，只读入参
返回值
half，输出a中低16bit的half值
函数描述
输出half2类型中，低16bit的half值。
__device__ __half2 __low2half2 (const __half2 a)
参数
a
half2，只读入参
返回值
half2，a中低16bit的值，组合为half2类型后输出
函数描述
讲half2类型a中，低16bit的值，组合为half2类型后输出。
__device__ __half2 __lowhigh2highlow (const __half2 a)
参数
a
half2，只读入参
返回值
half2，交换half值的a
函数描述
讲half2类型的a的half值交换，并输出。
__device__ __half2 __lows2half2 (const __half2 a, const __half2 b)
参数
a
half2，只读入参
b
half2，只读入参
返回值
a和b中低16bit的half的组合
函数描述
提取half2类型的a和b中，低16bit的half值，组合为half2类型后输出。
__device__ __half __shfl_down_sync (const unsigned mask, const __half var,
const unsigned int delta, const int width)
参数
mask
unsigned int，只读入参
var
half，只读入参
delta
unsigned int，只读入参
width
int，只读入参
返回值
从source thread ID返回一个引用了var的2字节的word作为一个half。 如果source thread ID超过了source的范围或者source thread已经退出，则返calling thread自己的var。
函数描述
通过求caller’s thread ID和delta的和计算source thread ID的值。返回了resulting thread ID保存的var的值：这具有将var向下移动delta threads的效果。如果width小于warpSize则warp的每个子部分都表现为 starting logical thread ID 为0的单独实体。至于__shfl_up_sync()，source thread的ID number不会环绕width的值，因此upper delta threads将保持不变。
__device__ __half2 __shfl_down_sync (const unsigned mask, const __half2 var,
const unsigned int delta, const int width)
参数
mask
unsigned int，只读入参
var
half2，只读入参
delta
unsigned int，只读入参
width
int，只读入参
返回值
从source thread ID返回一个引用了var的4字节的word作为一个half2。 如果source thread ID超过了source的范围或者source thread已经退出，则返calling thread自己的var。
函数描述
通过求caller’s thread ID和delta的和计算source thread ID的值。返回了resulting thread ID保存的var的值：这具有将var向下移动delta threads的效果。如果width小于warpSize则warp的每个子部分都表现为 starting logical thread ID 为0的单独实体。至于__shfl_up_sync()，source thread的ID number不会环绕width的值，因此upper delta threads将保持不变。
__device__ __half __shfl_sync (const unsigned mask, const __half var, const int delta, const int width)
参数
mask
unsigned int，只读入参
var
half，只读入参
delta
int，只读入参
width
int，只读入参
返回值
从source thread ID返回一个引用了var的2字节的word作为一个half。 如果source thread ID超过了source的范围或者source thread已经退出，则返calling thread自己的var。
函数描述
返回一个ID由delta给出的线程所持有的var的值。如果width小于warpSize则warp的每个子部分都表现为starting logical thread ID 为0的单独实体。如果delta超过了[0:width-1]的范围， 则返回的值应和delta module width所持有的值对应（即在同一子节内）。width的值必须是一个2的幂。如果width不是2的幂或者一个大于warpSize的值，则results应为undefined。
__device__ __half __shfl_up_sync (const unsigned mask, const __half var,
const unsigned int delta, const int width)
参数
mask
unsigned int，只读入参
var
half2，只读入参
delta
int，只读入参
width
int，只读入参
返回值
从source thread ID返回一个引用了var的2字节的word作为一个half。 如果source thread ID超过了source的范围或者source thread已经退出，则返calling thread自己的var。
函数描述
通过将caller’s lane ID减去delta得到source thread ID。返回resulting lane ID所持有的var的值：var 被delta thread向上移动。如果width小于warpSize则warp的每个子部分都表现为starting logical thread ID 为0的单独实体。 source thread ID不会环绕width值，所以较低的delta threads不会被改变。width的值必须是一个2的幂。如果width不是2的幂或者一个大于warpSize的值，则results应为undefined。
__device__ __half2 __shfl_up_sync (const unsigned mask, const __half2 var,
const unsigned int delta, const int width)
参数
mask
unsigned int，只读入参
var
half2，只读入参
delta
int，只读入参
width
int，只读入参
返回值
从source thread ID返回一个引用了var的4字节的word作为一个half2。 如果source thread ID超过了source的范围或者source thread已经退出，则返calling thread自己的var。
函数描述
通过将caller’s lane ID减去delta得到source thread ID。返回resulting lane ID所持有的var的值：var 被delta thread向上移动。如果width小于warpSize则warp的每个子部分都表现为starting logical thread ID 为0的单独实体。 source thread ID不会环绕width值，所以较低的delta threads不会被改变。width的值必须是一个2的幂。如果width不是2的幂或者一个大于warpSize的值，则results应为undefined。
__device__ __half __shfl_xor_sync (const unsigned mask, const __half var,
const int delta, const int width)
参数
mask
unsigned int，只读入参
var
half，只读入参
delta
int，只读入参
width
int，只读入参
返回值
从source thread ID返回一个引用了var的2字节的word作为一个half。 如果source thread ID超过了source的范围或者source thread已经退出，则返calling thread自己的var。
函数描述
通过对caller’s thread ID和mask进行按位异或计算来得到source thread ID：返回由resulting thread ID所持有的var的值。如果width小于warpSize则每组width consecutive thread都能够访问earlier groups中d 线程的元素，然而如果他们尝试访问later groups的线程，则会返回他们自己的var。这种模式实现了一种蝶式寻址模式，例如用于tree reduction和broadcast。
__device__ __half2 __shfl_xor_sync (const unsigned mask, const __half2 var,
const int delta, const int width)
参数
mask
unsigned int，只读入参
var
half2，只读入参
delta
int，只读入参
width
int，只读入参
返回值
从source thread ID返回一个引用了var的4字节的word作为一个half2。 如果source thread ID超过了source的范围或者source thread已经退出，则返calling thread自己的var。
函数描述
通过对caller’s thread ID和mask进行按位异或计算来得到source thread ID：返回由resulting thread ID所持有的var的值。如果width小于warpSize则每组width consecutive thread都能够访问earlier groups中d 线程的元素，然而如果他们尝试访问later groups的线程，则会返回他们自己的var。这种模式实现了一种蝶式寻址模式，例如用于tree reduction和broadcast。
__device__ __half __short2half_rd (const short int i)
参数
i
short int，只读入参
返回值
half，转换成半精度类型的i
函数描述
以向下舍入模式将int类型的i，转换成半精度浮点类型输出。
__host__ __device__ __half __short2half_rn (const short int i)
参数
i
short int，只读入参
返回值
half，转换成半精度类型的i
函数描述
以向最近偶数舍入模式将int类型的i，转换成半精度浮点类型输出。
__device__ __half __short2half_ru (const short int i)
参数
i
short int，只读入参
返回值
half，转换成半精度类型的i
函数描述
以向上舍入模式将int类型的i，转换成半精度浮点类型输出。
__device__ __half __short2half_rz (const short int i)
参数
i
short int，只读入参
返回值
half，转换成半精度类型的i
函数描述
以向零舍入模式将int类型的i，转换成半精度浮点类型输出。
__device__ __half __short_as_half (const short int i)
参数
i
shor int，只读入参
half
reinterpreted值
函数描述
将入参i，reinterpret成半精度浮点类型后，输出。
__device__ void __stcg (const __half *ptr, const __half value)
参数
ptr
内存位置
value
要被存储的值
__device__ void __stcg (const __half2 *ptr，const __half2 value)
参数
ptr
内存位置
value
要被存储的值
__device__ void __stcs (const __half *ptr, const __half value)
参数
ptr
内存位置
value
要被存储的值
__device__ void __stcs (const __half2 *ptr, const __half2 value)
参数
ptr
内存位置
value
要被存储的值
__device__ void __stwb (const __half *ptr, const __half value)
参数
ptr
内存位置
value
要被存储的值
__device__ void __stwb (const __half2 *ptr, const __half2 value)
参数
ptr
内存位置
value
要被存储的值
__device__ void __stwt (const __half *ptr, const __half value)
参数
ptr
内存位置
value
要被存储的值
__device__ void __stwt (const __half2 *ptr, const __half2 value)
参数
ptr
内存位置
value
要被存储的值
__device__ __half __uint2half_rd (const unsigned int i)
参数
i
unsigned int，只读入参
返回值
half，转换为half类型的i
函数描述
将unsigned int类型的i，转换成半精度的浮点类型，round-down后，输出。
__host__ __device__ __half __uint2half_rn (const unsigned int i)
参数
i
unsigned int，只读入参
返回值
half，转换为half类型的i
函数描述
以向最近偶数舍入模式将unsigned int类型的i，转换成半精度的浮点类型输出。
__device__ __half __uint2half_ru (const unsigned int i)
参数
i
unsigned int，只读入参
返回值
half，转换为half类型的i
函数描述
以向上舍入模式将unsigned int类型的i，转换成半精度的浮点类型输出。
__device__ __half __uint2half_rz (const unsigned int i)
参数
i
unsigned int，只读入参
返回值
half，转换为half类型的i
函数描述
以向零舍入模式将unsigned int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ull2half_rd (const unsigned long long int i)
参数
i
unsigned long long int，只读入参
返回值
half，转换为half类型的i
函数描述
以向下舍入模式将unsigned 64bit int类型的i，转换成半精度的浮点类型输出。
__host__ __device__ __half __ull2half_rn (const unsigned long long int i)
参数
i
unsigned long long int，只读入参
返回值
half，转换为half类型的i
函数描述
以向最近偶数舍入模式将unsigned 64bit int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ull2half_ru (const unsigned long long int i)
参数
i
unsigned long long int，只读入参
返回值
half，转换为half类型的i
函数描述
以向上舍入模式将unsigned 64bit int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ull2half_rz (const unsigned long long int i)
参数
i
unsigned long long int，只读入参
返回值
half，转换为half类型的i
函数描述
以向零舍入模式将unsigned 64bit int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ushort2half_rd (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
half，转换为half类型的i
函数描述
以向下舍入模式将unsigned short int类型的i，转换成半精度的浮点类型输出。
__host__ __device__ __half __ushort2half_rn (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
half，转换为half类型的i
函数描述
以向最近偶数舍入模式将unsigned short int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ushort2half_ru (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
half，转换为half类型的i
函数描述
以向上舍入模式将unsigned short int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ushort2half_rz (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
half，转换为half类型的i
函数描述
以向零舍入模式将unsigned short int类型的i，转换成半精度的浮点类型输出。
__device__ __half __ushort_as_half (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
half，reinterpreted值
函数描述
将入参i，reinterpret成半精度浮点类型后，输出。
1.8.6. half数学函数
__device__ __half hceil (const __half h)
参数
h
half，只读入参
返回值
half，返回不小于h的最小的integer值
函数描述
计算不小于 h 的最小interger值。
__device__ __half hcos (const __half a)
参数
a
half，只读入参
返回值
half，返回a的cosine值
函数描述
以向最近偶数舍入模式计算输入a的half cosine值。
__device__ __half hexp (const __half a)
参数
a
half，只读入参
返回值
half，返回a的自然指数函数
函数描述
以向最近偶数舍入模式计算输入a的half 自然指数函数。
__device__ __half hexp10 (const __half a)
参数
a
half，只读入参
返回值
half，返回a的十进制自然指数函数
函数描述
以向最近偶数舍入模式计算输入a的half十进制自然指数函数。
__device__ __half hexp2 (const __half a)
参数
a
half，只读入参
返回值
half，返回a的二进制自然指数函数
函数描述
以向最近偶数舍入模式计算输入a的half二进制自然指数函数。
__device__ __half hfloor (const __half h)
参数
h
half，只读入参
返回值
half，返回小于或等于 h 的最大integer值。
函数描述
计算小于或等于 h 的最大integer值。
__device__ __half hlog (const __half a)
参数
a
half，只读入参
返回值
half，返回a的自然对数
函数描述
以向最近偶数舍入模式计算输入a的half自然对数。
__device__ __half hlog10 (const __half a)
参数
a
half，只读入参
返回值
half，返回a的十进制对数
函数描述
以向最近偶数舍入模式计算输入a的half十进制对数。
__device__ __half hlog2 (const __half a)
参数
h
half，只读入参
返回值
half，返回最近h的integer
函数描述
以向最近偶数舍入模式计算输入a的half的二进制对数。
__device__ __half hrcp (const __half a)
参数
a
half，只读入参
返回值
half，返回a的倒数
函数描述
以向最近偶数舍入模式计算输入a的half的倒数。
__device__ __half hrint (const __half h)
参数
h
half，只读入参
返回值
half，返回最接近h的整数值。
函数描述
用半精度的格式把h舍入到最接近的整数值，对于正好一半的情况下舍入到最接近的偶数值。
__device__ __half hrsqrt (const __half a)
参数
a
half，只读入参
返回值
half，返回a的平方根倒数
函数描述
以向最近偶数舍入模式计算输入a的half的平方根倒数。
__device__ __half hsin (const __half a)
参数
a
half，只读入参
返回值
half，a的正弦值
函数描述
以向最近偶数舍入模式计算输入的a的正弦值。
__device__ __half hsqrt (const __half a)
参数
a
half，只读入参
返回值
half，a的平方根。
函数描述
以向最近偶数舍入模式计算输入的a的平方根。
__device__ __half htrunc (const __half h)
参数
h
half，只读入参
返回值
half，返回截断integer
函数描述
将 h 舍入为最接近的integer，其幅度不超过 h。
1.8.7. half2数学函数
__device__ __half2 h2ceil (const __half2 h)
参数
h
half2，只读入参
返回值
half2，返回不小于h的最小integer向量
函数描述
对于向量h的每个分量，计算不小于 h 的最小interger值。
__device__ __half2 h2cos (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回向量a的元素cosine值
函数描述
以向最近偶数舍入模式计算输入向量a的half2的cosine值。
__device__ __half2 h2exp (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回向量a的元素自然指数函数
函数描述
以向最近偶数舍入模式计算输入向量a的half2的自然指数函数。
__device__ __half2 h2exp10 (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回向量a的元素十进制自然指数函数
函数描述
以向最近偶数舍入模式计算输入向量a的half2的十进制自然指数函数。
__device__ __half2 h2exp2 (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回向量a的元素二进制自然指数函数
函数描述
以向最近偶数舍入模式计算输入向量a的half2的二进制自然指数函数。
__device__ __half2 h2floor (const __half2 h)
参数
h
half2，只读入参
返回值
half2，返回小于或等于 h 的最大integer向量。
函数描述
对于向量h的每个分量，计算小于或等于 h 的最大integer值。
__device__ __half2 h2log (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回向量a的元素自然对数
函数描述
以向最近偶数舍入模式计算输入向量a的half2自然对数。
__device__ __half2 h2log10 (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回向量a的元素十进制自然对数
函数描述
以向最近偶数舍入模式计算输入向量a的half2十进制自然对数。
__device__ __half2 h2log2 (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回a的二进制对数。
函数描述
以向最近偶数舍入模式计算输入向量a的half2二进制对数。
__device__ __half2 h2rcp (const __half2 a)
参数
h
half2，只读入参
返回值
half2，返回四舍五入integer的向量
函数描述
以向最近偶数舍入模式计算输入向量a的half2倒数。
__device__ __half2 h2rint (const __half2 h)
参数
h
half2，只读入参
返回值
half2，返回四舍五入integer的向量
函数描述
以向最近偶数舍入模式将向量a中每个half值转换为半精度浮点型后，输出转换后的half2。
__device__ __half2 h2rsqrt (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回向量a的元素倒数平方根
函数描述
以向最近偶数舍入模式计算输入向量a的half2的倒数平方根。
__device__ __half2 h2sin (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回向量a的元素sine值。
函数描述
以向最近偶数舍入模式计算输入向量a的half2的sine值。
__device__ __half2 h2sqrt (const __half2 a)
参数
a
half2，只读入参
返回值
half2，返回向量a的元素平方根
函数描述
以向最近偶数舍入模式计算输入向量a的half2的平方根。
__device__ __half2 h2trunc (const __half2 h)
参数
h
half2，只读入参
返回值
half2，返回截断
函数描述
将向量 h 的每个分量四舍五入为幅度不超过 h 的最接近的整数。
bfloat16类型介绍，参见 1.3.1 maca_bfloat16。
1.8.8. Bfloat16算术函数
__device__ maca_bfloat16 __habs (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16，a的绝对值
函数描述
计算maca_bfloat16的绝对值。
__device__ maca_bfloat16 __hadd (const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat16，a与b的和
函数描述
以向最近偶数舍入模式执行maca_bfloat16的加法。
__device__ maca_bfloat16 __hadd_sat (const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat16，a与b的和
函数描述
以向最近偶数舍入模式执行maca_bfloat16的加法，并且结果被限制在[0.0, 1.0]之间。
若结果大于1.0则视为1.0，小于0.0则视为0.0。NaN被视为+0.0。
__device__ maca_bfloat16 __hdiv (const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat16，a除以b的商
函数描述
以向最近偶数舍入模式执行maca_bfloat16的除法。
__device__ maca_bfloat16 __hfma (const maca_bfloat16 a, const maca_bfloat16 b, const maca_bfloat16 c)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
C
maca_bfloat16，只读入参
返回值
maca_bfloat16，a乘b加c的结果
函数描述
以向最近偶数舍入模式执行maca_bfloat16的融合乘加运算。
__device__ maca_bfloat16 __hfma_relu (const maca_bfloat16 a, const maca_bfloat16 b,
const maca_bfloat16 c)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
c
maca_bfloat16，只读入参
返回值
maca_bfloat16，a乘b加c的结果
函数描述
以向最近偶数舍入模式执行maca_bfloat16的融合乘加运算，并将运算结果进行relu变换。
若结果小于0.0则视为0.0。NaN被视为标准NaN。
__device__ maca_bfloat16 __hfma_sat (const maca_bfloat16 a, const maca_bfloat16 b,
const maca_bfloat16 c)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
c
maca_bfloat16，只读入参
返回值
maca_bfloat16，a乘b加c的结果
函数描述
以向最近偶数舍入模式执行maca_bfloat16的融合乘加运算，并且结果被限制在[0.0, 1.0]之间。
若结果大于1.0则视为1.0，小于0.0则视为0.0。NaN被视为+0.0。
__device__ maca_bfloat16 __hmul (const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat16，a乘b的积
函数描述
以向最近偶数舍入模式执行maca_bfloat16的乘法。
__device__ maca_bfloat16 __hmul_sat (const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat16，a乘b的积
函数描述
以向最近偶数舍入模式执行maca_bfloat16的乘法，并且结果被限制在[0.0, 1.0]之间。
若结果大于1.0则视为1.0，小于0.0则视为0.0。NaN被视为+0.0。
__device__ maca_bfloat16 __hneg (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16，a的相反数
函数描述
计算maca_bfloat16的相反数。
__device__ maca_bfloat16 __hsub (const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat16，a减b的差
函数描述
以向最近偶数舍入模式执行maca_bfloat16的减法。
__device__ maca_bfloat16 __hsub_sat (const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat16，a减b的差
函数描述
以向最近偶数舍入模式执行maca_bfloat16的减法，并且结果被限制在[0.0, 1.0]之间。
若结果大于1.0则视为1.0，小于0.0则视为0.0。NaN被视为+0.0。
1.8.9. Bfloat162算术函数
__device__ maca_bfloat162 __habs2 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162，对向量a的两个分量取绝对值后的向量
函数描述
计算maca_bfloat162中的两个maca_bfloat16分量的绝对值。
__device__ maca_bfloat162 __hadd2 (const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a与b的和
函数描述
以向最近偶数舍入模式执行maca_bfloat162向量加法。
__device__ maca_bfloat162 __hadd2_sat (const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a与b的和
函数描述
以向最近偶数舍入模式执行maca_bfloat162的向量加法，并且每个分量的结果被限制在[0.0, 1.0]之间。
若分量的结果大于1.0则视为1.0，小于0.0则视为0.0。NaN被视为+0.0。
__device__ maca_bfloat162 __h2div (const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a除以b的商
函数描述
以向最近偶数舍入模式执行maca_bfloat162向量除法。
__device__ maca_bfloat162 __hcmadd (const maca_bfloat162 a, const maca_bfloat162 b,
const maca_bfloat162 c)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
c
maca_bfloat162，只读入参
返回值
maca_bfloat162，复数a乘b加c的结果
函数描述
将输入向量视为复数，并执行融合乘加运算。
__device__ maca_bfloat162 __hfma2 (const maca_bfloat162 a, const maca_bfloat162 b,
const maca_bfloat162 c)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
C
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a乘b加c的结果
函数描述
以向最近偶数舍入模式执行maca_bfloat162的向量融合乘加运算。
__device__ maca_bfloat162 __hfma2_relu (const maca_bfloat162 a,
const maca_bfloat162 b, const maca_bfloat162 c)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
c
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a乘b加c的结果
函数描述
以向最近偶数舍入模式执行maca_bfloat162的向量融合乘加运算，并将运算结果进行relu变换。
若分量的结果小于0.0则视为0.0。NaN被视为标准NaN。
__device__ maca_bfloat162 __hfma2_sat (const maca_bfloat162 a, const maca_bfloat162 b,
const maca_bfloat162 c)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
c
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a乘b加c的结果
函数描述
以向最近偶数舍入模式执行maca_bfloat162的向量融合乘加运算，并且结果被限制在[0.0, 1.0]之间。
若分量的结果大于1.0则视为1.0，小于0.0则视为0.0。NaN被视为+0.0。
__device__ maca_bfloat162 __hmul2 (const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a乘b的积
函数描述
以向最近偶数舍入模式执行maca_bfloat162的向量乘法。
__device__ maca_bfloat162 __hmul2_sat (const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a乘b的积
函数描述
以向最近偶数舍入模式执行maca_bfloat162的向量乘法，并且结果被限制在[0.0, 1.0]之间。
若分量的结果大于1.0则视为1.0，小于0.0则视为0.0。NaN被视为+0.0。
__device__ maca_bfloat162 __hneg2 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162，对向量a的两个分量取相反数后的向量
函数描述
计算maca_bfloat162中的两个maca_bfloat16分量的相反数。
__device__ maca_bfloat162 __hsub2 (const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a减b的差
函数描述
以向最近偶数舍入模式执行maca_bfloat162的向量减法。
__device__ maca_bfloat162 __hsub2_sat (const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，向量a减b的差
函数描述
以向最近偶数舍入模式执行maca_bfloat162的向量减法，并且结果被限制在[0.0, 1.0]之间。
若分量的结果大于1.0则视为1.0，小于0.0则视为0.0。NaN被视为+0.0。
1.8.10. Bfloat16比较函数
__device__ bool __heq(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a等于b” 的判定结果
函数描述
判定两个maca_bfloat16是否相等。
如果任一输入为NaN，则判定结果为false。
__device__ bool __hequ(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a等于b” 的判定结果
函数描述
判定两个maca_bfloat16是否相等。
如果任一输入为NaN，则判定结果为true。
__device__ bool __hge(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a大于或等于b” 的判定结果
函数描述
判定第一个参数maca_bfloat16是否大于或等于第二个参数maca_bfloat16。
如果任一输入为NaN，则判定结果为false。
__device__ bool __hgeu(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a大于或等于b” 的判定结果
函数描述
判定第一个参数maca_bfloat16是否大于或等于第二个参数maca_bfloat16。
如果任一输入为NaN，则判定结果为true。
__device__ bool __hgt(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a大于b” 的判定结果
函数描述
判定第一个参数maca_bfloat16是否大于第二个参数maca_bfloat16。
如果任一输入为NaN，则判定结果为false。
__device__ bool __hgtu(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a大于b” 的判定结果
函数描述
判定第一个参数maca_bfloat16是否大于第二个参数maca_bfloat16。
如果任一输入为NaN，则判定结果为true。
__device__ int __hisinf(const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
int， “a为无穷大” 的判定结果
函数描述
判定maca_bfloat16的值是否为无穷大。
正无穷的判定结果为1，负无穷为-1，不是无穷大则为0。
__device__ bool __hisnan(const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
bool， “a为NaN” 的判定结果
函数描述
判定maca_bfloat16的值是否为NaN。
__device__ bool __hle(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a小于或等于b” 的判定结果
函数描述
判定第一个参数maca_bfloat16是否小于或等于第二个参数maca_bfloat16。
如果任一输入为NaN，则判定结果为false。
__device__ bool __hleu(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a小于或等于b” 的判定结果
函数描述
判定第一个参数maca_bfloat16是否小于或等于第二个参数maca_bfloat16。
如果任一输入为NaN，则判定结果为true。
__device__ bool __hlt(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a小于b” 的判定结果
函数描述
判定第一个参数maca_bfloat16是否小于第二个参数maca_bfloat16。
如果任一输入为NaN，则判定结果为false。
__device__ bool __hltu(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a小于b” 的判定结果
函数描述
判定第一个参数maca_bfloat16是否小于第二个参数maca_bfloat16。
如果任一输入为NaN，则判定结果为true。
__device__ maca_bfloat16 __hmax(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat16，值等于a和b中更大的那一个
函数描述
获取两个maca_bfloat16中值更大的那一个。
NaN视为小于任何数。
对于0的判定，+0.0 > -0.0。
__device__ maca_bfloat16 __hmax_nan(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat16，值等于a和b中更大的那一个
函数描述
获取两个maca_bfloat16中值更大的那一个。
NaN视为大于任何数。
对于0的判定，+0.0 > -0.0。
__device__ maca_bfloat16 __hmin(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool，值等于a和b中更小的那一个
函数描述
获取两个maca_bfloat16中值更小的那一个。
NaN视为大于任何数。
对于0的判定，+0.0 > -0.0。
__device__ maca_bfloat16 __hmin_nan(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool，值等于a和b中更小的那一个
函数描述
获取两个maca_bfloat16中值更小的那一个。
NaN视为小于任何数。
对于0的判定，+0.0 > -0.0。
__device__ bool __hne(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a不等于b” 的判定结果
函数描述
判定两个maca_bfloat16是否不相等。
如果任一输入为NaN，则判定结果为false。
__device__ bool __hneu(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
bool， “a不等于b” 的判定结果
函数描述
判定两个maca_bfloat16是否不相等。
如果任一输入为NaN，则判定结果为true。
1.8.11. Bfloat162比较函数
__device__ bool __hbeq2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都等于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都等于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为false。
__device__ bool __hbequ2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都等于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都等于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为true。
__device__ bool __hbge2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都大于或等于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都大于或等于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为false。
__device__ bool __hbgeu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都大于或等于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都大于或等于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为true。
__device__ bool __hbgt2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都大于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都大于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为false。
__device__ bool __hbgtu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都大于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都大于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为true。
__device__ bool __hble2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都小于或等于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都小于或等于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为false。
__device__ bool __hbleu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都小于或等于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都小于或等于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为true。
__device__ bool __hblt2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都小于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都小于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为false。
__device__ bool __hbltu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都小于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都小于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为true。
__device__ bool __hbne2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都不等于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都不等于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为false。
__device__ bool __hbneu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
bool， “a的分量都不等于b的分量” 的判定结果
函数描述
判定第一个maca_bfloat162向量的两个分量是否都不等于第二个maca_bfloat162的分量。
如果参数中存在NaN，则判定结果为true。
__device__ maca_bfloat162 __heq2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对两个向量的分量进行相等判定。
对应分量的值相等时判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予0.0。
__device__ maca_bfloat162 __hequ2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对向量的两个分量进行相等判定。
相等时判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予1.0。
__device__ maca_bfloat162 __hge2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对向量的两个分量进行大于或等于判定。
第一个maca_bfloat162向量的分量大于或等于第二个的向量的对应分量时，判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予0.0。
__device__ maca_bfloat162 __hgeu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对向量的两个分量进行大于或等于判定。
第一个maca_bfloat162向量的分量大于或等于第二个的向量的对应分量时，判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予1.0。
__device__ maca_bfloat162 __hgt2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对向量的两个分量进行大于判定。
第一个maca_bfloat162向量的分量大于第二个的向量的对应分量时，判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予0.0。
__device__ maca_bfloat162 __hgtu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对向量的两个分量进行大于判定。
第一个maca_bfloat162向量的分量大于第二个的向量的对应分量时，判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予1.0。
__device__ maca_bfloat162 __hisnan2(const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量是否为NaN的结果
函数描述
分别判定输入向量的两个分量的值是否为NaN，如果是NaN，结果中相应的分量会被赋予1.0的值；否则，赋予0.0的值。
__device__ maca_bfloat162 __hle2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对向量的两个分量进行小于或等于判定。
第一个maca_bfloat162向量的分量小于或等于第二个的向量的对应分量时，判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予0.0。
__device__ maca_bfloat162 __hleu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对向量的两个分量进行小于或等于判定。
第一个maca_bfloat162向量的分量小于或等于第二个的向量的对应分量时，判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予1.0。
__device__ maca_bfloat162 __hlt2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对向量的两个分量进行小于判定。
第一个maca_bfloat162向量的分量小于第二个的向量的对应分量时，判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予0.0。
__device__ maca_bfloat162 __hltu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对向量的两个分量进行小于判定。
第一个maca_bfloat162向量的分量小于第二个的向量的对应分量时，判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予1.0。
__device__ maca_bfloat162 __hmax2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，分别对两个向量的分量提取更大的值的结果
函数描述
分别对两个输入向量的对应的分量进行大小比较，将值更大的分量作为结果以构建新的向量。
NaN视为小于任何数。
对于0的判定，+0.0 > -0.0。
__device__ maca_bfloat16 __hmax2_nan(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，分别对两个向量的分量提取更大的值的结果
函数描述
分别对两个输入向量的对应的分量进行大小比较，将值更大的分量作为结果以构建新的向量。
NaN视为大于任何数。
对于0的判定，+0.0 > -0.0。
__device__ maca_bfloat162 __hmin2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，分别对两个向量的分量提取更小的值的结果
函数描述
分别对两个输入向量的对应的分量进行大小比较，将值更小的分量作为结果以构建新的向量。
NaN视为大于任何数。
对于0的判定，+0.0 > -0.0。
__device__ maca_bfloat16 __hmin2_nan(const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，分别对两个向量的分量提取更小的值的结果
函数描述
分别对两个输入向量的对应的分量进行大小比较，将值更小的分量作为结果以构建新的向量。
NaN视为小于任何数。
对于0的判定，+0.0 > -0.0。
__device__ maca_bfloat162 __hne2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对两个向量的分量进行不相等判定。
对应分量的值不相等时判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予0.0。
__device__ maca_bfloat162 __hneu2(const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用于指示两个分量的比较结果
函数描述
分别对两个向量的分量进行不相等判定。
对应分量的值不相等时判定结果的对应分量会被赋予1.0的值；否则，赋予0.0。
若分量的值为NaN会使得判定结果被赋予1.0。
1.8.12. Bfloat16精度转换与数据移动函数
__host__ __device__ float2 __bfloat1622float2 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
float2，由a转换的向量
函数描述
将maca_bfloat162向量转换为float2向量。
__device__ maca_bfloat162 __bfloat162bfloat162 (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat162，用a同时作为两个分量而构建的向量
函数描述
使用一个maca_bfloat16参数来构建maca_bfloat162向量，向量中的两个分量的值均与参数相等。
__host__ __device__ float __bfloat162float (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
float，值由a转换得到
函数描述
将maca_bfloat16转换32位浮点数。
__device__ int __bfloat162int_rd (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
int，值由h转换得到
函数描述
以向下舍入模式将maca_bfloat16类型转换为带符号的32位整数。
__device__ int __bfloat162int_rn (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
int，值由h转换得到
函数描述
以向最近偶数舍入模式将maca_bfloat16类型转换为带符号的32位整数。
__device__ int __bfloat162int_ru (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
int，值由h转换得到
函数描述
用向上舍入的模式，将maca_bfloat16类型的浮点数h转换成signed integer类型。
__host__ __device__ int __bfloat162int_rz (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
int，值由h转换得到
函数描述
以向零舍入模式将maca_bfloat16类型转换为带符号的32位整数。
__device__ long long int __bfloat162ll_rd (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
long long int，值由h转换得到
函数描述
以向下舍入模式将maca_bfloat16类型转换为带符号的64位整数。
__device__ long long int __bfloat162ll_rn (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
long long int，值由h转换得到
函数描述
以向最近偶数舍入模式将maca_bfloat16类型转换为带符号的64位整数。
__device__ long long int __bfloat162ll_ru (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
long long int，值由h转换得到
函数描述
用向上舍入的模式，将maca_bfloat16类型的浮点数h转换成64位signed integer类型。
__host__ __device__ long long int __bfloat162ll_rz (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
long long int，值由h转换得到
函数描述
以向零舍入模式将maca_bfloat16类型转换为带符号的64位整数。
__device__ short int __bfloat162short_rd (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
short int，值由h转换得到
函数描述
以向下舍入模式将maca_bfloat16类型转换为带符号的16位整数。
__device__ short int __bfloat162short_rn (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
short int，值由h转换得到
函数描述
以向最近偶数舍入模式将maca_bfloat16类型转换为带符号的16位整数。
__device__ short int __bfloat162short_ru (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
short int，值由h转换得到
函数描述
用向上舍入的模式，将maca_bfloat16类型的浮点数h转换成signed short integer类型。
__host__ __device__ short int __bfloat162short_rz (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
short int，值由h转换得到
函数描述
以向零舍入模式将maca_bfloat16类型转换为带符号的16位整数。
__device__ unsigned int __bfloat162uint_rd (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned int，值由h转换得到
函数描述
以向下舍入模式将maca_bfloat16类型转换为无符号的32位整数。
__device__ unsigned int __bfloat162uint _rn (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned int，值由h转换得到
函数描述
以向最近偶数舍入模式将maca_bfloat16类型转换为无符号的32位整数。
__device__ unsigned int __bfloat162uint_ru (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned int，值由h转换得到
函数描述
用向上舍入的模式，将maca_bfloat16类型的浮点数h转换成unsigned ineger类型。
__host__ __device__ unsigned int __bfloat162uint_rz (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned int，值由h转换得到
函数描述
以向零舍入模式将maca_bfloat16类型转换为无符号的32位整数。
__device__ unsigned long long int __bfloat162ull_rd (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned long long int，值由h转换得到
函数描述
以向下舍入模式将maca_bfloat16类型转换为无符号的64位整数。
__device__ unsigned long long int __bfloat162ull _rn (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned long long int，值由h转换得到
函数描述
以向最近偶数舍入模式将maca_bfloat16类型转换为无符号的64位整数。
__device__ unsigned long long int __bfloat162ull_ru (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned long long int，值由h转换得到
函数描述
以向上舍入模式将maca_bfloat16类型转换为无符号的64位整数。
__host__ __device__ unsigned long long int __bfloat162ull_rz (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned long long int，值由h转换得到
函数描述
以向零舍入模式将maca_bfloat16类型转换为无符号的64位整数。
__device__ unsigned short int __bfloat162ushort_rd (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned short int，值由h转换得到
函数描述
以向下舍入模式将maca_bfloat16类型转换为无符号的16位整数。
__device__ unsigned short int __bfloat162ushort _rn (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned short int，值由h转换得到
函数描述
以向最近偶数舍入模式将maca_bfloat16类型转换为无符号的16位整数。
__device__ unsigned short int __bfloat162ushort_ru (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned short int，值由h转换得到
函数描述
以向上舍入模式将maca_bfloat16类型转换为无符号的16位整数。
__host__ __device__ unsigned short int __bfloat162ushort_rz (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
unsigned short int，值由h转换得到
函数描述
以向零舍入模式将maca_bfloat16类型转换为无符号的16位整数。
__device__ short int __bfloat16_as_short (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
short int，值由h重新解释得到
函数描述
按位将maca_bfloat16重新解释为带符号的16位整数。
__device__ unsigned short int __bfloat16_as_ushort (const maca_bfloat16 h)
参数
h * maca_bfloat16，只读入参
返回值
unsigned short int，值由h重新解释得到
函数描述
按位将maca_bfloat16重新解释为无符号的16位整数。
__host__ __device__ maca_bfloat16 __double2bfloat16 (const double a)
参数
a
double，只读入参
返回值
maca_bfloat16，值由a转换得到
函数描述
以向最近偶数舍入模式将64位浮点数类型转换为maca_bfloat16。
__host__ __device__ maca_bfloat162 __float22bfloat162_rn (const float2 a)
参数
a
float2，只读入参
返回值
maca_bfloat162，由a转换的向量
函数描述
以向最近偶数舍入模式将32位浮点数向量转换为maca_bfloat162向量。
__host__ __device__ maca_bfloat16 __float2bfloat16 (const float a)
参数
a
float，只读入参
返回值
maca_bfloat16，值由a转换得到
函数描述
以向最近偶数舍入模式将32位浮点数类型转换为maca_bfloat16。
__host__ __device__ maca_bfloat162 __float2bfloat162_rn (const float a)
参数
a
float，只读入参
返回值
maca_bfloat162，由a转换的向量
函数描述
以向最近偶数舍入模式将32位浮点数类型转换为maca_bfloat16，并用这个maca_bfloat16构建一个maca_bfloat162向量。
__host__ __device__ maca_bfloat16 __float2bfloat16_rd (const float a)
参数
a
float，只读入参
返回值
maca_bfloat16，值由a转换得到
函数描述
以向下舍入模式将32位浮点数类型转换为maca_bfloat16。
__host__ __device__ maca_bfloat16 __float2bfloat16_rn (const float a)
参数
a
float，只读入参
返回值
maca_bfloat16，值由a转换得到
函数描述
以向最近偶数舍入模式将32位浮点数类型转换为maca_bfloat16。
__host__ __device__ maca_bfloat16 __float2bfloat16_ru (const float a)
参数
a
float，只读入参
返回值
maca_bfloat16，值由a转换得到
函数描述
以向上舍入模式将32位浮点数类型转换为maca_bfloat16。
__host__ __device__ maca_bfloat16 __float2bfloat16_rz (const float a)
参数
a
float，只读入参
返回值
maca_bfloat16，值由a转换得到
函数描述
以向零舍入模式将32位浮点数类型转换为maca_bfloat16。
__host__ __device__ maca_bfloat162 __floats2bfloat162_rn (const float a, const float b)
参数
a
float，只读入参
b
float，只读入参
返回值
maca_bfloat162，由a和b构建得到的向量
函数描述
以向最近偶数舍入模式将两个32位浮点数类型转换为两个maca_bfloat16，并用这两个maca_bfloat16构建一个maca_bfloat162向量。
__device__ maca_bfloat162 __halves2bfloat162 (const maca_bfloat16 a, const maca_bfloat16 b)
参数
a
maca_bfloat16，只读入参
b
maca_bfloat16，只读入参
返回值
maca_bfloat162，由a和b构建得到的向量
函数描述
用两个maca_bfloat16参数构建一个maca_bfloat162向量，第一个参数被赋予到向量的低16位，第二个参数被赋予到向量的高16位。
__device__ maca_bfloat16 __high2bfloat16 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat16，a向量的高16位分量
函数描述
提取maca_bfloat162向量的高16位分量。
__device__ maca_bfloat162 __high2bfloat162 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162，用a向量的高16位分量构建出的向量
函数描述
提取maca_bfloat162向量的高16位分量，以此构建出两个分量的值都等于提取值的maca_bfloat162向量。
__host__ __device__ float __high2float (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
float，值由a向量的高16位分量转换得到
函数描述
提取maca_bfloat162向量的高16位分量，并将该分量转换为32为浮点数。
__device__ maca_bfloat162 __highs2bfloat162 (const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用a和b向量的高16位分量构建出的向量
函数描述
分别提取两个maca_bfloat162向量的高16位分量，构建出一个新的maca_bfloat162向量。
__device__ maca_bfloat16 __int2bfloat16_rd (const int i)
参数
i
int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向下舍入模式将带符号的32位整数转换为maca_bfloat16。
__host__ __device__ maca_bfloat16 __int2bfloat16_rn (const int i)
参数
i
int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向最近偶数舍入模式将带符号的32位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __int2bfloat16_ru (const int i)
参数
i
int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向上舍入模式将带符号的32位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __int2bfloat16_rz (const int i)
参数
i
int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向零舍入模式将带符号的32位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ldca (const maca_bfloat16 *ptr)
参数
ptr
maca_bfloat16*，指针
返回值
maca_bfloat16，ptr指针指向的值
__device__ maca_bfloat162 __ldca (const maca_bfloat162 *ptr)
参数
ptr
maca_bfloat162*，指针
返回值
maca_bfloat162，ptr指针指向的值
__device__ maca_bfloat16 __ldcg (const maca_bfloat16 *ptr)
参数
ptr
maca_bfloat16*，指针
返回值
maca_bfloat16，ptr指针指向的值
__device__ maca_bfloat162 __ldcg (const maca_bfloat162 *ptr)
参数
ptr
maca_bfloat162*，指针
返回值
maca_bfloat162，ptr指针指向的值
__device__ maca_bfloat16 __ldcs (const maca_bfloat16 *ptr)
参数
ptr
maca_bfloat16*，指针
返回值
maca_bfloat16，ptr指针指向的值
__device__ maca_bfloat162 __ldcs (const maca_bfloat162 *ptr)
参数
ptr
maca_bfloat162*，指针
返回值
maca_bfloat162，ptr指针指向的值
__device__ maca_bfloat16 __ldcv (const maca_bfloat16 *ptr)
参数
ptr
maca_bfloat16*，指针
返回值
maca_bfloat16，ptr指针指向的值
__device__ maca_bfloat162 __ldcv (const maca_bfloat162 *ptr)
参数
ptr
maca_bfloat126*，指针
返回值
maca_bfloat162，ptr指针指向的值
__device__ maca_bfloat16 __ldg (const maca_bfloat16 *ptr)
参数
ptr
maca_bfloat16*，指针
返回值
maca_bfloat16，ptr指针指向的值
__device__ maca_bfloat162 __ldg (const maca_bfloat162 *ptr)
参数
ptr
maca_bfloat162*，指针
返回值
maca_bfloat162，ptr指针指向的值
__device__ maca_bfloat16 __ldlu (const maca_bfloat16 *ptr)
参数
ptr
maca_bfloat16*，指针
返回值
maca_bfloat16，ptr指针指向的值
__device__ maca_bfloat162 __ldlu (const maca_bfloat162 *ptr)
参数
ptr
maca_bfloat162*，指针
返回值
maca_bfloat162，ptr指针指向的值
__device__ maca_bfloat16 __ll2bfloat16_rd (const long long int i)
参数
i
long long int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向下舍入模式将带符号的64位整数转换为maca_bfloat16。
__host__ __device__ maca_bfloat16 __ll2bfloat16_rn (const long long int i)
参数
i
long long int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向最近偶数舍入模式将带符号的64位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ll2bfloat16_ru (const long long int i)
参数
i
long long int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向上舍入模式将带符号的64位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ll2bfloat16_rz (const long long int i)
参数
i
long long int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向零舍入模式将带符号的64位整数转换为maca_bfloat16。
__device__ maca_bfloat162 __low2bfloat162 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat16，用a向量的低16位分量构建出的向量
函数描述
提取maca_bfloat162向量的低16位分量，以此构建出两个分量的值都等于提取值的maca_bfloat162向量。
__host__ __device__ float __low2float (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
float，值由a向量的高16位分量转换得到
函数描述
提取maca_bfloat162向量的低16位分量，并将该分量转换为32为浮点数。
__device__ maca_bfloat162 __lowhigh2highlow (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162，将a向量的两个分量的值互换后得到
函数描述
将maca_bfloat162向量的高低分量的值互换。
__device__ maca_bfloat162 __lows2bfloat162 (const maca_bfloat162 a, const maca_bfloat162 b)
参数
a
maca_bfloat162，只读入参
b
maca_bfloat162，只读入参
返回值
maca_bfloat162，用a和b向量的低16位分量构建出的向量
函数描述
分别提取两个maca_bfloat162向量的低16位分量，构建出一个新的maca_bfloat162向量。
__device__ maca_bfloat16 __shfl_down_sync (const unsigned mask, const maca_bfloat16 var,
const unsigned int delta, const int width)
参数
mask
unsigned int，只读入参
var
maca_bfloat16，只读入参
delta
int，只读入参
width
int，只读入参
返回值
maca_bfloat16，线程间交换数据得到的值
函数描述
指定一组线程互相交换数据。
以width将同一个wave中的线程分组，同一组的线程从零开始计算序号，被mask指定的线程会返回向后序号偏移量等于delta的线程中的变量var的值。
若偏移后的线程超出了width指定的组大小，或该线程没有被mask指定，则直接返回入参var。
mask中的每一个位都对应着一个线程，将位的值设置为1即代表指定了该线程进行数据交换。
__device__ maca_bfloat162 __shfl_down_sync (const unsigned mask, const maca_bfloat162 var,
const unsigned int delta, const int width)
参数
mask
unsigned int，只读入参
var
maca_bfloat162，只读入参
delta
int，只读入参
width
int，只读入参
返回值
maca_bfloat162，线程间交换数据得到的值
函数描述
指定一组线程互相交换数据。
以width将同一个wave中的线程分组，同一组的线程从零开始计算序号，被mask指定的线程会返回向后序号偏移量等于delta的线程中的变量var的值。
若偏移后的线程超出了组大小，或该线程没有被mask指定，则直接返回入参var。
mask中的每一个位都对应着一个线程，将位的值设置为1即代表指定了该线程进行数据交换。
__device__ maca_bfloat16 __shfl_sync (const unsigned mask, const maca_bfloat16 var,
const int delta, const int width)
参数
mask
unsigned int，只读入参
var
maca_bfloat16，只读入参
delta
int，只读入参
width
int，只读入参
返回值
maca_bfloat16，线程间交换数据得到的值
函数描述
指定一组线程互相交换数据。
以width将同一个wave中的线程分组，同一组的线程从零开始计算序号，被mask指定的线程会返回序号等于delta的线程中的变量var的值。
若序号超过了组大小，或该线程没有被mask指定，则直接返回入参var。
mask中的每一个位都对应着一个线程，将位的值设置为1即代表指定了该线程进行数据交换。
__device__ maca_bfloat162 __shfl_sync (const unsigned mask, const maca_bfloat162 var,
const int delta, const int width)
参数
mask
unsigned int，只读入参
var
maca_bfloat162，只读入参
delta
int，只读入参
width
int，只读入参
返回值
maca_bfloat162，线程间交换数据得到的值
函数描述
指定一组线程互相交换数据。
以width将同一个wave中的线程分组，同一组的线程从零开始计算序号，被mask指定的线程会返回序号等于delta的线程中的变量var的值。
若序号超过了组大小，或该线程没有被mask指定，则直接返回入参var。
mask中的每一个位都对应着一个线程，将位的值设置为1即代表指定了该线程进行数据交换。
__device__ maca_bfloat16 __shfl_up_sync (const unsigned mask, const maca_bfloat16 var,
const unsigned int delta, const int width)
参数
mask
unsigned int，只读入参
var
maca_bfloat16，只读入参
delta
int，只读入参
width
int，只读入参
返回值
maca_bfloat16，线程间交换数据得到的值
函数描述
指定一组线程互相交换数据。
以width将同一个wave中的线程分组，同一组的线程从零开始计算序号，被mask指定的线程会返回向前序号偏移量等于delta的线程中的变量var的值。
若偏移后的线程超出了组大小，或该线程没有被mask指定，则直接返回入参var。
mask中的每一个位都对应着一个线程，将位的值设置为1即代表指定了该线程进行数据交换。
__device__ maca_bfloat162 __shfl_up_sync (const unsigned mask, const maca_bfloat162 var,
const unsigned int delta, const int width)
参数
mask
unsigned int，只读入参
var
maca_bfloat162，只读入参
delta
int，只读入参
width
int，只读入参
返回值
maca_bfloat162，线程间交换数据得到的值
函数描述
指定一组线程互相交换数据。
以width将同一个wave中的线程分组，同一组的线程从零开始计算序号，被mask指定的线程会返回向前序号偏移量等于delta的线程中的变量var的值。
若偏移后的线程超出了组大小，或该线程没有被mask指定，则直接返回入参var。
mask中的每一个位都对应着一个线程，将位的值设置为1即代表指定了该线程进行数据交换。
__device__ maca_bfloat16 __shfl_xor_sync (const unsigned mask, const maca_bfloat16 var,
const int delta, const int width)
参数
mask
unsigned int，只读入参
var
maca_bfloat16，只读入参
delta
int，只读入参
width
int，只读入参
返回值
maca_bfloat16，线程间交换数据得到的值
函数描述
指定一组线程互相交换数据。
以width将同一个wave中的线程分组，同一组的线程从零开始计算序号，被mask指定的线程会将其自身的序号与delta进行一次异或操作，将操作得到的结果作为线程序号，从序号代表的线程中取得var值。
若序号超出了组大小，或该线程没有被mask指定，则直接返回入参var。
mask中的每一个位都对应着一个线程，将位的值设置为1即代表指定了该线程进行数据交换。
__device__ maca_bfloat162 __shfl_xor_sync (const unsigned mask, const maca_bfloat162 var,
const int delta, const int width)
参数
mask
unsigned int，只读入参
var
maca_bfloat16，只读入参
delta
int，只读入参
width
int，只读入参
返回值
maca_bfloat162，线程间交换数据得到的值
函数描述
指定一组线程互相交换数据。
以width将同一个wave中的线程分组，同一组的线程从零开始计算序号，被mask指定的线程会将其自身的序号与delta进行一次异或操作，将操作得到的结果作为线程序号，从序号代表的线程中取得var值。
若序号超出了组大小，或该线程没有被mask指定，则直接返回入参var。
mask中的每一个位都对应着一个线程，将位的值设置为1即代表指定了该线程进行数据交换。
__device__ maca_bfloat16 __short2bfloat16_rd (const short int i)
参数
i
short int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向下舍入模式将带符号的16位整数转换为maca_bfloat16。
__host__ __device__ maca_bfloat16 __short2bfloat16_rn (const short int i)
参数
i
short int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向最近偶数舍入模式将带符号的16位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __short2bfloat16_ru (const short int i)
参数
i
short int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向上舍入模式将带符号的16位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __short2bfloat16_rz (const short int i)
参数
i
short int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向零舍入模式将带符号的16位整数转换为maca_bfloat16。
__device__ void __stcg (const maca_bfloat16 *ptr, const maca_bfloat16 value)
参数
ptr
maca_bfloat16*，指针
value
maca_bfloat16，要存储到ptr指向的内存中的值
__device__ void __stcg (const maca_bfloat162 *ptr, const maca_bfloat162 value)
参数
ptr
maca_bfloat162*，指针
value
maca_bfloat162，要存储到ptr指向的内存中的值
__device__ void __stcs (const maca_bfloat16 *ptr, const maca_bfloat16 value)
参数
ptr
maca_bfloat16*，指针
value
maca_bfloat16，要存储到ptr指向的内存中的值
__device__ void __stcs (const maca_bfloat162 *ptr, const maca_bfloat162 value)
参数
ptr
maca_bfloat162*，指针
value
maca_bfloat162，要存储到ptr指向的内存中的值
__device__ void __stwb (const maca_bfloat16 *ptr, const maca_bfloat16 value)
参数
ptr
maca_bfloat16*，指针
value
maca_bfloat16，要存储到ptr指向的内存中的值
__device__ void __stwb (const maca_bfloat162 *ptr, const maca_bfloat162 value)
参数
ptr
maca_bfloat162*，指针
value
maca_bfloat162，要存储到ptr指向的内存中的值
__device__ void __stwt (const maca_bfloat16 *ptr, const maca_bfloat16 value)
参数
ptr
maca_bfloat16*，指针
value
maca_bfloat16，要存储到ptr指向的内存中的值
__device__ void __stwt (const maca_bfloat162 *ptr, const maca_bfloat162 value)
参数
ptr
maca_bfloat162*，指针
value
maca_bfloat162，要存储到ptr指向的内存中的值
__device__ maca_bfloat16 __uint2bfloat16_rd (const unsigned int i)
参数
i
unsigned int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向下舍入模式将无符号的32位整数转换为maca_bfloat16。
__host__ __device__ maca_bfloat16 __uint2bfloat16_rn (const unsigned int i)
参数
i
unsigned int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向最近偶数舍入模式将无符号的32位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __uint2bfloat16_ru (const unsigned int i)
参数
i
unsigned int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向上舍入模式将无符号的32位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __uint2bfloat16_rz (const unsigned int i)
参数
i
unsigned int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向零舍入模式将无符号的32位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ull2bfloat16_rd (const unsigned long long int i)
参数
i
unsigned long long int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向下舍入模式将无符号的64位整数转换为maca_bfloat16。
__host__ __device__ maca_bfloat16 __ull2bfloat16_rn (const unsigned long long int i)
参数
i
unsigned long long int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向最近偶数舍入模式将无符号的64位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ull2bfloat16_ru (const unsigned long long int i)
参数
i
unsigned long long int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向上舍入模式将无符号的64位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ull2bfloat16_rz (const unsigned long long int i)
参数
i
unsigned long long int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向零舍入模式将无符号的64位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ushort2bfloat16_rd (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向下舍入模式将无符号的16位整数转换为maca_bfloat16。
__host__ __device__ maca_bfloat16 __ushort2bfloat16_rn (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向最近偶数舍入模式将无符号的16位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ushort2bfloat16_ru (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向上舍入模式将无符号的16位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ushort2bfloat16_rz (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
maca_bfloat16，值由i转换得到
函数描述
以向零舍入模式将无符号的16位整数转换为maca_bfloat16。
__device__ maca_bfloat16 __ushort_as_bfloat16 (const unsigned short int i)
参数
i
unsigned short int，只读入参
返回值
maca_bfloat16，值由i重新解释得到
函数描述
按位将无符号的16位整数重新解释为maca_bfloat16。
1.8.13. Bfloat16数学函数
__device__ maca_bfloat16 hceil (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
计算大于输入的最小整数。
__device__ maca_bfloat16 hcos (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的余弦值。
__device__ maca_bfloat16 hexp (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的自然指数函数。
__device__ maca_bfloat16 hexp10 (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的10进制指数函数。
__device__ maca_bfloat16 hexp2 (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的2进制指数函数。
__device__ maca_bfloat16 hfloor (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
maca_bfloat16,
函数描述
计算小于输入的最大整数。
__device__ maca_bfloat16 hlog (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的自然对数
__device__ maca_bfloat16 hlog10 (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的10进制对数
__device__ maca_bfloat16 hlog2 (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的2进制对数
__device__ maca_bfloat16 hrcp (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的倒数。
__device__ maca_bfloat16 hrint (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式将maca_bfloat16转换为最接近的整数。
__device__ maca_bfloat16 hrsqrt (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的倒数平方根。
__device__ maca_bfloat16 hsin (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的正弦值。
__device__ maca_bfloat16 hsqrt (const maca_bfloat16 a)
参数
a
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
以向最近偶数舍入模式计算maca_bfloat16的平方根。
__device__ maca_bfloat16 htrunc (const maca_bfloat16 h)
参数
h
maca_bfloat16，只读入参
返回值
maca_bfloat16
函数描述
将入参截断，只保留整数部分。
1.8.14. Bfloat162数学函数
__device__ maca_bfloat162 h2ceil (const maca_bfloat162 h)
参数
h
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
对于输入向量的两个分量，分别计算大于分量的最小整数。
__device__ maca_bfloat162 h2cos (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的maca_bfloat16的余弦值。
__device__ maca_bfloat162 h2exp (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的自然指数函数。
__device__ maca_bfloat162 h2exp10 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的10进制自然指数函数。
__device__ maca_bfloat162 h2exp2 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的2进制自然指数函数。
__device__ maca_bfloat162 hfloor (const maca_bfloat162 h)
参数
h
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
对于输入向量的两个分量，分别计算小于分量的最大整数。
__device__ maca_bfloat16 h2log (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的自然对数。
__device__ maca_bfloat16 h2log10 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的10进制自然对数。
__device__ maca_bfloat16 h2log2 (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的2进制自然对数。
__device__ maca_bfloat162 hrcp (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的倒数。
__device__ maca_bfloat162 hrint (const maca_bfloat162 h)
参数
h
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别将输入向量的两个分量转换为最接近的整数。
__device__ maca_bfloat16 h2rsqrt (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的倒数平方根。
__device__ maca_bfloat162 h2sin (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的正弦值。
__device__ maca_bfloat16 h2sqrt (const maca_bfloat162 a)
参数
a
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
以向最近偶数舍入模式，分别计算输入向量的两个分量的平方根。
__device__ maca_bfloat162 htrunc (const maca_bfloat162 h)
参数
h
maca_bfloat162，只读入参
返回值
maca_bfloat162
函数描述
分别将输入向量的两个分量截断，只保留整数部分。
1.8.15. 单精度数学函数
__device__ float acosf (float x)
计算输入参数的反余弦函数值。
返回值
当输入参数x取值范围为
[-1, 1]时，结果取值范围为[0, pi]，以弧度为单位。acosf(1)返回 +0。
当x不在
[-1, 1]之间时，acosf(x)返回 NaN。
函数描述
计算输入参数x的反余弦函数值。
__device__ float acoshf (float x)
计算输入参数的反双曲余弦函数值。
返回值
返回值在区间
[0, +∞]之间。acoshf(1)返回0。
当x在
[-∞, 1]之间时，acoshf(x)返回 NaN。
函数描述
计算输入参数x的反双曲余弦函数值。
__device__ float asinf (float x)
计算输入参数的反正弦函数值。
返回值
当输入参数x取值范围为
[-1, 1]时，结果取值范围为[-pi / 2, +pi / 2]，以弧度为单位。asinf(1)返回 +0。
当x不在
[-1, 1]之间时，asinf(x)返回 NaN。
函数描述
计算输入参数x的反正弦函数值。
__device__ float asinhf (float x)
计算输入参数的反双曲正弦函数值。
返回值
asinhf(0)返回1。
函数描述
计算输入参数x的反双曲正弦函数值。
__device__ float atan2f (float y, float x)
计算第一个和第二个输入参数之比的反正切。
返回值
结果以弧度为单位，在区间
[-Π, +Π]atan2f(0, 1)返回 +0
函数描述
计算y / x的反正切函数值。结果的象限决定于x、y的符号。
__device__ float atanf (float x)
计算输入参数的反正切函数值。
返回值
结果以弧度为单位，在区间
[-pi / 2, +pi / 2]atanf(0)返回 +0
函数描述
计算输入参数x的反正切函数值。
__device__ float atanhf (float x)
计算输入参数的双曲反正切函数值。
返回值
atanhf(±0)返回 ±0。
atanhf(±1)返回 ±∞
当x不在区间
[-1, 1]时，atanhf(x)返回 NaN。
函数描述
计算输入参数x的双曲反正切函数值。
__device__ float cbrtf (float x)
计算输入参数的立方根。
返回值
返回x1/3。
cbrtf(±0)返回 ±0。
cbrtf(±∞)返回 ±∞
函数描述
计算输入参数x的立方根，x1/3。
__device__ float ceilf (float x)
计算输入参数的向上取整值。
返回值
ceilf(±0)返回 ±0。
ceilf(±∞)返回 ±∞
函数描述
计算不小于输入参数x的最小整数。
__device__ float copysignf (float x, float y)
以第二个参数的符号，创建具有第一个参数大小的值。
返回值
返回一个值，它有x的大小与y的符号。
函数描述
计算具有x的大小与y的符号的值。
__device__ float cosf (float x)
计算输入参数的余弦函数值
返回值
cosf(±0)返回1。
cosf(±∞)返回 NaN。
函数描述
计算输入参数x（以弧度为单位）的余弦值。
__device__ float coshf (float x)
计算输入参数的双曲余弦函数值。
返回值
coshf(±0)返回1。
coshf(±∞)返回 +∞。
函数描述
计算输入参数x的双曲余弦函数值。
__device__ float cospif (float x)
计算输入参数 x × Π 的余弦函数值。
返回值
cospif(±0)返回1。
cospif(±∞)返回 NaN。
函数描述
计算
x × Π的余弦函数值，x是输入参数。
__device__ float cyl_bessel_i0f (float x)
计算输入参数的0阶正则修正圆柱贝塞尔函数的值。
返回值
返回输入参数的0阶正则修正圆柱贝塞尔函数的值。
函数描述
计算输入参数的0阶正则修正圆柱贝塞尔函数的值， I0(x)。
__device__ float cyl_bessel_i1f (float x)
计算输入参数的1阶正则修正圆柱贝塞尔函数的值。
返回值
返回输入参数的1阶正则修正圆柱贝塞尔函数的值。
函数描述
计算输入参数的1阶正则修正圆柱贝塞尔函数的值， I1(x)。
__device__ float erfcf (float x)
计算输入参数的互补误差函数。
返回值
erfcf(-∞)返回2。
erfcf(+∞)返回 +0。
函数描述
计算输入参数x的互补误差函数，1 - erf(x)。
__device__ float erfcinvf (float y)
计算输入参数的逆互补误差函数。
返回值
erfcinvf(0)返回 +∞。
erfcinvf(2)返回 -∞。
函数描述
对于y在区间[0, 2]内，计算输入参数y的逆互补误差函数。逆互补误差函数寻找符合下面条件的x的值：y = erfc(x)，0 \(\leqslant\) y \(\leqslant\) 2，并且-∞ \(\leqslant\) x \(\leqslant\) ∞。
__device__ float erfcxf (float x)
计算输入参数的缩放互补误差函数。
返回值
erfcxf(-∞)返回 +∞。
erfcxf(+∞)返回 +0。
如果正确计算的值的范围超出了单精度浮点数的表示范围，erfcxf(x)返回 +∞。
函数描述
计算输入参数x的缩放互补误差函数 \(e^{x^2} erf(x)\)。
__device__ float erff (float x)
计算输入参数的错误函数。
返回值
erff(±0)返回 ±0。
erff(±∞)返回±1。
函数描述
计算输入参数x的错误函数。
__device__ float erfinvf (float y)
计算输入参数的逆误差函数。
返回值
erfinvf(1)返回 +∞。
erfinvf(-1)返回 -∞。
函数描述
对于y在区间[-1, 1]内，计算输入参数y的逆误差函数。逆误差函数寻找符合下面条件的x的值：y = erf(x)，0 \(\leqslant\) y \(\leqslant\) 2，并且-∞ \(\leqslant\) x \(\leqslant\) ∞。
__device__ float exp10f (float x)
计算输入参数的基数10指数。
返回值
返回10x。
函数描述
计算输入参数x的基数10指数，10x。
__device__ float exp2f (float x)
计算输入参数的基数2指数。
返回值
返回2x。
函数描述
计算输入参数x的基数10指数，2x。
__device__ float expf (float x)
计算输入参数的基数e指数。
返回值
返回ex。
函数描述
计算输入参数x的基数10指数，ex。
__device__ float expm1f (float x)
计算输入参数的基数e指数减去1。
返回值
返回ex - 1。
函数描述
计算输入参数x的基数10指数减去1，ex - 1。
__device__ float fabsf (float x)
计算输入参数的基数e指数减去1。
返回值
fabsf(±∞)返回 +∞。
fabsf(±0)返回0。
函数描述
计算输入参数x的绝对值。
__device__ float fdimf (float x, float y)
计算x与y之间的正数差。
返回值
返回x与y之间的正数差。
如果x > y，fdimf(x, y)返回 x - y。
如果x \(\leqslant\) y，fdimf(x, y)返回 +0。
函数描述
计算x与y之间的正数差。当x > y时，结果为x - y；否则，是+0。
__device__ float fdividef (float x, float y)
两个浮点数做除法。
返回值
x / y。
函数描述
计算x / y。
__device__ float floorf (float x)
计算不大于x的最大整数。
返回值
返回值以浮点数返回。
floorf(±∞) 返回 ±∞
floorf(±0) 返回 ±0。
函数描述
计算不大于x的最大整数。
__device__ float fmaf (float x, float y, float z)
以一个操作计算单精度 x * y + z 。
返回值
返回舍入的单精度 x * y + z 的结果
fmaf(±∞, ±0, z)返回 NaN。fmaf(±0, ±∞, z)返回 NaN。如果x * y是确切的+∞，
fmaf(x, y, -∞)返回 NaN。如果x * y是确切的-∞，
fmaf(x, y, +∞)返回 NaN。
函数描述
以一个三元操作计算单精度
x * y + z。在计算之后，值需要舍入一次。
__device__ float fmaxf (float x, float y)
计算入参的最大值。
返回值
返回入参的最大值。
如果两个参数都是NaN，返回 NaN。
如果一个参数是NaN，返回另一个不是NaN的参数。
函数描述
计算入参x，y的最大值。将NaN参数视作无效数据。如果一个参数是NaN，另一个参数是合法数字值，数字值要被返回。
__device__ float fminf (float x, float y)
计算入参的最小值。
返回值
返回入参的最小值。
如果两个参数都是NaN，返回 NaN。
如果一个参数是NaN，返回另一个不是NaN的参数。
函数描述
计算入参x，y的最小值。将NaN参数视作无效数据。如果一个参数是NaN，另一个参数是合法数字值，数字值要被返回。
__device__ float fmodf (float x, float y)
计算x/y的浮点余数。
返回值
返回x/y的浮点余数。
如果y不是0，fmodf(±0, y)返回 ±0。
如果x是有限值，fmodf(x, ±∞)返回x。
如果x是±∞或者y是0，fmodf(x, y)返回 NaN。
如果某一个参数是NaN，返回 NaN。
函数描述
计算x/y的浮点余数。这个函数计算的浮点余数具体的是x - n * y，这里的n是x / y，其分数部分被截断。计算出的结果会有x相同的符号，并且它的值大小比y的值大小小。
__device__ float frexpf (float x, int *nptr)
提取浮点值的尾数和指数。
返回值
返回分数分量m。
frexp(0, nptr)对于分数分量返回0，对于整数分量返回0。
frexp(±0, nptr)返回 ±0并且nptr指向的内存赋值0。
frexp(±∞, nptr)返回 ±∞，并且在nptr指向的内存赋值一个不确定的值。
frexp(NaN, y)返回 NaN，并且在nptr指向的内存赋值一个不确定的值。
函数描述
将浮点值x分解为归一化分数元素的分量m和指数的另一项n。m的绝对值将大于或等于0.5且小于1.0或等于0；x = m * 2n。整数指数n将存储在nptr指向的位置。
__device__ float hypotf (float x, float y)
计算x与y的平方和的平方根。
返回值
斜边的长度sqrt(x2 + y2)。如果正确计算的值溢出，返回+无穷。如果正确计算结果向下溢出，返回0。
函数描述
计算直角三角形斜边的长度，该直角三角形的两侧具有长度x和y，且没有过度溢出或下溢。
__device__ float ilogbf (float x)
计算参数的无偏整数指数。
返回值
如果成功，返回参数的无偏指数。
ilogbf(0)返回INT_MIN。
ilogbf(NaN)返回INT_MIN。
如果x是∞或者确切值比INT_MAX大，ilogbf(x)返回INT_MAX。
如果确切值比INT_MIN小，ilogbf(x)返回INT_MIN。
注意，上面的操作不涉及FP_ILOGB0、FP_ILOGBNAN。
函数描述
计算参数x的无偏整数指数。
__device__ bool isfinite (float a)
确认参数是否是有穷的。
返回值
当且仅当a是一个有穷值的时候返回true。
函数描述
确认参数a是否是有穷的。
__device__ bool isinf (float a)
确认参数是否是无穷的。
返回值
当且仅当a是一个无穷值的时候返回true。
函数描述
确认参数a是否是无穷的。
__device__ bool isnan (float a)
确认参数是否是NaN。
返回值
当且仅当a是一个NaN的时候返回true。
函数描述
确认参数a是否是NaN。
__device__ float j0f (float x)
计算输入参数的第一类0阶贝塞尔函数的值。
返回值
输入参数的第一类0阶贝塞尔函数的值。
j0f(±∞)返回 +0。
j0f(NaN)返回 NaN。
函数描述
计算输入参数x的第一类0阶贝塞尔函数的值，J0(x)。
__device__ float j1f (float x)
计算输入参数的第一类1阶贝塞尔函数的值。
返回值
输入参数的第一类1阶贝塞尔函数的值。
j1f(±0)返回 ±0。
j1f(±∞)返回 ±0。
j1f(NaN)返回 NaN。
函数描述
计算输入参数x的第一类1阶贝塞尔函数的值，J1(x)。
__device__ float jnf (int n, float x)
计算输入参数的第一类n阶贝塞尔函数的值。
返回值
输入参数的第一类n阶贝塞尔函数的值
jnf(NaN)返回 NaN。
jnf(n, x)在n < 0时返回 ±0。
jnf(n, +∞)返回 +0。
函数描述
计算输入参数x的第一类n阶贝塞尔函数的值，J1(x)。
__device__ float ldexpf (float x, int exp)
计算x * 2exp的值。
返回值
如果正确计算的值超出单精度范围，ldexpf(x)返回 ±∞。
函数描述
计算入参x、exp下面的数学公式：x * 2exp的值。
__device__ float lgammaf (float x)
计算输入参数gamma函数绝对值的自然对数。
返回值
lgammaf(1)返回 +0。
lgammaf(2)返回 +0。
如果正确计算的值超出单精度表示范围，lgammaf(x)返回 ±∞。
如果x \(\leqslant\) 0且是个整数，lgammaf(x)返回 +∞。
lgammaf(-∞)返回 -∞。
lgammaf(+∞)返回 +∞。
函数描述
计算输入参数x的gamma函数绝对值的自然对数。
__device__ long long int llrintf (float x)
将输入四舍五入到最接近的整数值。
返回值
返回舍入后的整数值。
函数描述
将x四舍五入到最接近的整数值，一半的情况下四舍五入到最接近的偶数整数值。如果结果超出返回类型的范围，则结果未定义。
__device__ long long int llroundf (float x)
将输入四舍五入到最接近的整数值。
返回值
返回舍入后的整数值。
函数描述
将x四舍五入到最接近的整数值，一半的情况下从零四舍五入。如果结果超出返回类型的范围，则结果未定义。
__device__ float log10f (float x)
计算输入参数以10为底的对数。
返回值
log10f(±0)返回 -∞。
log10f(1)返回 +0。
当x < 0时，log10f(x)返回 NaN。
log10f(+∞)返回 +∞。
函数描述
计算输入参数x以10为底的对数。
__device__ float log1pf (float x)
计算loge(1+x)的值。
返回值
log1pf(±0)返回 ±0。
log1pf(-1)返回 -∞。
当x < -1时，log1pf(x)返回 NaN。
log1pf(+∞)返回 +∞。
函数描述
计算loge(1+x)的值。
__device__ float log2f (float x)
计算输入参数以2为底的对数。
返回值
log2f(±0)返回 -∞。
log2f(1)返回 +0。
当x < 0时，log2f(x)返回 NaN。
log2f(+∞)返回 +∞。
函数描述
计算输入参数x以2为底的对数。
__device__ float logbf (float x)
计算输入参数x的指数的浮点表示形式。
返回值
logbf(±0)返回 -∞。
logbf(+∞)返回 +∞。
函数描述
计算输入参数x的指数的浮点表示形式。
__device__ float logf (float x)
计算输入参数的自然对数。
返回值
logf(±0)返回 -∞。
logf(1)返回 +0。
当x < 0时，logf(x)返回 NaN。
logf(+∞)返回 +∞。
函数描述
计算输入参数的自然对数。
__device__ long int lrintf (float x)
将输入四舍五入到最接近的整数值。
返回值
返回舍入后的值。
函数描述
将x四舍五入到最接近的整数值，一半的情况下四舍五入到最接近的偶数整数值。如果结果超出返回类型的范围，则结果未定义。
__device__ long int lrintf (float x)
将输入四舍五入到最接近的整数值。
返回值
返回舍入后的值。
函数描述
将x四舍五入到最接近的整数值，一半的情况下从零四舍五入。如果结果超出返回类型的范围，则结果未定义。
__device__ float max (const float a, const float b)
计算输入的浮点数的最大值。
函数描述
计算输入参数a和b的最大值，行为与函数fmaxf()一致。
备注
这个函数与std::里面的函数不同。
__device__ float min (const float a, const float b)
计算输入的浮点数的最小值。
函数描述
计算输入参数a和b的最小值，行为与函数fminf()一致。
备注
这个函数与std::里面的函数不同。
__device__ float modff (float x, float *iptr)
将输入参数分解为分数和整数部分。
返回值
modff(±x, iptr)返回一个与x具有相同的符号的结果。
modff(±∞, iptr)返回 ±0并且在iptr指向的内存中存入±∞。
modff(NaN, iptr)返货NaN并且在iptr指向的内存中存入NaN。
函数描述
将参数x分解为分数和整数部分。分数部分存储在参数iptr中。分数和整数部分的符号与参数x相同。
__device__ float nanf (const char *tagp)
返回“Not a Number” 值。
返回值
nanf(tagp)返回 NaN。
函数描述
返回安静NaN的表示。参数tagp选择一种可能的表示形式。
__device__ float nearbyintf (float x)
将输入参数四舍五入到最接近的整数。
返回值
nearbyintf(±0)返回 ±0。
nearbyintf(±∞)返回 ±∞。
函数描述
将参数x舍入为单精度浮点格式的整数值。
__device__ float nextafterf (float x, float y)
返回y方向上参数x之后的下一个可表示的单精度浮点值。
返回值
nextafterf(x, y) = y如果x == y。
nextafterf(x, y) = NaN如果x或y是NaN。
函数描述
计算沿y方向x之后的下一个可表示的单精度浮点值。例如，如果y大于x，则nextafterf()返回大于x的最小可表示数字。
__device__ float norm3df (float a, float b, float c)
计算参数的三个坐标的平方和的平方根。
返回值
返回三维向量长度sqrt(a2 + b2 + c2)。如果计算结果溢出，则返回 +∞，如果计算结果向下溢出，则返回0。
函数描述
计算欧几里德空间中三维向量的长度，无过度溢出或下溢。
__device__ float norm4df (float a, float b, float c, float d)
计算参数的四个坐标的平方和的平方根。
返回值
返回四维向量长度sqrt(a2 + b2 + c2 + d2)。如果计算结果溢出，则返回 +∞，如果计算结果向下溢出，则返回0。
函数描述
计算欧几里德空间中四维向量的长度，无过度溢出或下溢。
__device__ float normcdff (float y)
计算标准正态累积分布函数。
返回值
normcdff(+∞)返回1。
normcdff(-∞)返回 +0。
函数描述
计算输入y的标准正态分布函数的值。
__device__ float normcdfinvf (float y)
计算标准正态累积分布函数。
返回值
normcdfinvf(0)返回 -∞。
normcdfinvf(1)返回 +∞。
如果x不在区间[0, 1]，normcdfinvf(x)返回 NaN。
函数描述
计算输入参数y的标准正态累积分布函数的逆。这个函数的输入值的取值范围在区间(0,1)。
__device__ float normf (int dim, const float *p)
计算任意数量坐标的平方和的平方根。
返回值
返回dim维向量长度sqrt(p02 + p12 + … + pdim-12)。如果计算结果溢出，则返回 +∞，如果计算结果向下溢出，则返回0。
函数描述
计算向量p的长度，向量p的维数作为参数传递，不会出现过度溢出或下溢。
__device__ float powf (float x, float y)
计算第一个参数的值与第二个参数的幂。
返回值
powf(±0, y)对于y小于0的整数，返回 ±∞。
powf(±0, y)对于y一个大于0的整数奇数返回 ±0。
powf(±0, y)对于y > 0且不是一个奇数整数返回 +0。
powf(-1, ±∞)返回1。
powf(+1, y)对于任何y甚至NaN，返回1。
powf(x, ±0)对于任何x甚至NaN，返回1。
powf(x, y)对于有穷x < 0且有穷非整数y返回 NaN。
powf(x, -∞)对于|x| < 1返回 +∞。
powf(x, -∞)对于|x| > 1返回 +0。
powf(x, +∞)对于|x| < 1返回 +0。
powf(x, +∞)对于|x| > 1返回 +∞。
powf(-∞, y)对于y是一个小于0的奇数返回-0。
powf(-∞, y)对于y < 0且不是奇数返回 +0。
powf(-∞, y)对于y是一个大于0的奇数返回 -∞。
powf(-∞, y)对于y > 0且不是奇数返回 +∞。
powf(+∞, y)对于y < 0返回 +0。
powf(+∞, y)对于y > 0返回 +∞。
函数描述
计算x的值为y的幂。
__device__ float rcbrtf (float x)
计算倒数立方根函数。
返回值
rcbrt(±0) 返回 ±∞
rcbrt(±∞) 返回 ±0
函数描述
计算x的倒数立方根函数。
__device__ float remainderf (float x, float y)
计算单精度浮点余数。
返回值
remainderf(x, 0)返回 NaN。
remainderf(±∞, y) 返回 NaN。
remainderf(x, ±∞) 对于有穷x返回x。
函数描述
计算非零y的x除以y的单精度浮点余数r，因此r = x - ny。n的值是最接近x / y的整数。
__device__ float remquof (float x, float y, int *quo)
计算单精度浮点余数和部分商。
返回值
返回余数。
remquof(x, 0, quo)返回 NaN。
remquof(±∞, y, quo) 返回 NaN。
remquof(x, ±∞, quo) 返回x。
函数描述
以与remainderf()函数相同的方式计算双精度浮点余数。参数quo在x除以y后返回部分商。值quo与x/y有相同的符号，可能不是精确商，但与低阶3位中的精确商一致。
__device__ float rhypotf (float x, float y)
计算两个参数平方和的平方根。
返回值
返回斜边长度倒数值1 / sqrt(x2 + y2)。如果平方根溢出，返回0。如果平方根向下溢出，返回 +∞。
函数描述
计算直角三角形斜边长度倒数，该直角三角形的两侧具有长度x和y，没有过度溢出或下溢。
__device__ float rintf (float x)
将输入四舍五入为最接近的浮点类型的整数值。
返回值
返回舍入后的值。
函数描述
以浮点格式将x四舍五入为最接近的整数值，将一半大小写四舍五入为最接近的偶数整数值。
__device__ float rnorm3df (float a, float b, float c)
计算参数三个坐标的平方和的平方根的倒数。
返回值
返回三维向量长度的倒数1 / sqrt(a2 + b2 + c2)。如果平方根溢出返回0，如果平方根向下溢出，返回 +∞。
函数描述
计算欧几里德空间中三维向量长度倒数，无过度溢出或下溢。
__device__ float rnorm4df (float a, float b, float c, float d)
计算参数四个坐标的平方和的平方根的倒数。
返回值
返回四维向量长度的倒数1 / sqrt(a2 + b2 + c2 + d2)。如果平方根溢出返回0，如果平方根向下溢出，返回 +∞。
函数描述
计算欧几里德空间中四维向量长度倒数，无过度溢出或下溢。
__device__ float rnormf (int dim, const float *p)
计算任意数量坐标的平方和的平方根的倒数。
返回值
返回dim维向量长度的倒数1 / sqrt(p02 + p12 + … + pdim-12)。如果平方根溢出返回0，如果平方根向下溢出，返回 +∞。
函数描述
计算欧几里德空间中dim维向量p长度倒数，无过度溢出或下溢。
__device__ float roundf (float x)
四舍五入到最接近的浮点整数值。
返回值
返回舍入后的值。
函数描述
以浮点格式将x四舍五入到最接近的整数值，中间的大小写从零四舍五入。
__device__ float rsqrtf (float x)
计算输入值平方根的倒数。
返回值
返回 1 / sqrt(x)。
rsqrtf(+∞) 返回 +0
rsqrtf(±0) 返回 ±∞
rsqrtf(x) 如果x < 0返回 NaN。
函数描述
计算输入参数x的平方根的倒数。
__device__ float scalblnf (float x, long int n)
按2的整数幂缩放浮点输入。
返回值
返回 x * 2n。
scalblnf(±0, n) 返回 ±0。
scalblnf(x, 0) 返回x。
scalblnf(±∞, n) 返回 ±∞。
函数描述
按2n缩放浮点输入x。
__device__ bool signbit (float a)
返回输入的符号位。
返回值
当且仅当a是负数返回true。
函数描述
确认浮点数是不是负数。
__device__ void sincosf (float x, float *sptr, float *cptr)
计算第一个输入参数的正弦和余弦。
返回值
无。
函数描述
计算第一个输入参数x（以弧度为单位）的正弦和余弦。正弦和余弦的结果分别写入第二个参数sptr和第三个参数cptr。
__device__ void sincospif (float x, float *sptr, float *cptr)
计算第一个输入参数 * Π 的正弦和余弦。
返回值
无。
函数描述
计算第一个输入参数x（以弧度为单位） * Π 的正弦和余弦。正弦和余弦的结果分别写入第二个参数sptr和第三个参数cptr。
__device__ float sinf (float x)
计算输入参数的正弦。
返回值
sinf(±0)返回 ±0。
sinf(±∞)返回 NaN。
函数描述
计算输入参数x的正弦。
__device__ float sinhf (float x)
计算输入参数的双曲正弦。
返回值
sinhf(±0)返回 ±0。
sinhf(±∞)返回 ±∞。
函数描述
计算输入参数x的双曲正弦。
__device__ float sinpif (float x)
计算输入参数 * Π 的正弦。
返回值
sinf(±0)返回 ±0。
sinf(±∞)返回 NaN。
函数描述
计算输入参数x * Π 的正弦。
__device__ float sqrtf (float x)
计算输入参数的平方根。
返回值
sqrtf(±0)返回 ±0。
sqrtf(+∞)返回 +∞。
如果x < 0，sqrtf(x)返回x。
函数描述
计算输入参数x的平方根。
__device__ float tanf (float x)
计算输入参数的正切。
返回值
tanf(±0)返回 ±0。
tanf(±∞)返回 NaN。
函数描述
计算输入参数x的正切。
__device__ float tanhf (float x)
计算输入参数的双曲正切。
返回值
tanhf(±0)返回 ±0。
函数描述
计算输入参数x的双曲正切。
__device__ float tgammaf (float x)
计算输入参数的gamma函数。
返回值
tgammaf(±0)返回 ±∞。
tgammaf(2)返回+1。
如果计算值超出单精度表示范围，tgammaf(x)返回 ±∞。
如果x < 0且是个整数，tgammaf(x)返回 NaN。
tgammaf(-∞)返回 NaN。
tgammaf(+∞)返回 +∞。
函数描述
计算输入参数x的gamma函数。
__device__ float truncf (float x)
将输入参数截断为整数部分。
返回值
返回截断的整数部分。
函数描述
将x四舍五入到最接近的整数值，该整数值的大小不超过x。
__device__ float y0f (float x)
为输入参数计算第二类0阶贝塞尔函数的值。
返回值
返回计算的第二类0阶贝塞尔函数的值。
y0f(0)返回 -∞。
y0f(x)对于x < 0返回 NaN。
y0f(+∞)返回 +0。
y0f(NaN)返回 NaN。
函数描述
计算输入参数x的第二类0阶贝塞尔函数的值，Y0(x)。
__device__ float y1f (float x)
为输入参数计算第二类1阶贝塞尔函数的值。
返回值
返回计算的第二类1阶贝塞尔函数的值。
y1f(0)返回 -∞。
y1f(x)对于x < 0返回 NaN。
y1f(+∞)返回 +0。
y1f(NaN)返回 NaN。
函数描述
计算输入参数x的第二类1阶贝塞尔函数的值，Y1(x)。
__device__ float ynf (int n, float x)
为输入参数计算第二类n阶贝塞尔函数的值。
返回值
返回计算的第二类n阶贝塞尔函数的值。
ynf(0)返回 -∞。
ynf(x)对于x < 0返回 NaN。
ynf(+∞)返回 +0。
ynf(NaN)返回 NaN。
函数描述
计算输入参数x的第二类n阶贝塞尔函数的值，Yn(x)。
1.8.16. 双精度数学函数
__device__ double acos (double x)
计算输入参数的反余弦函数值。
返回值
结果以弧度位单位，在范围
[0, Π]之间，x取值范围在[-1, 1]之间。acos(1)返回 +0。
当x不在
[-1, 1]之间时，acos(x)返回 NaN。
函数描述
计算输入参数x的反余弦函数值。
__device__ double acosh (double x)
计算输入参数的反双曲余弦函数值。
返回值
返回值在区间
[0, +∞]之间。acosh(1)返回0。
当x在
[-∞, 1]之间时，acosh(x)返回 NaN。
函数描述
计算输入参数x的反双曲余弦函数值。
__device__ double asin (double x)
计算输入参数的反正弦函数值。
返回值
结果以弧度位单位，在范围
[-Π / 2, + Π / 2]之间，x取值范围在[-1, 1]之间。asin(1)返回 +0。
当x不在
[-1, 1]之间时，asin(x)返回 NaN。
函数描述
计算输入参数x的反正弦函数值。
__device__ double asinh (double x)
计算输入参数的反双曲正弦函数值。
返回值
asinh(0)返回1。
函数描述
计算输入参数x的反双曲正弦函数值。
__device__ double atan (double x)
计算输入参数的反正切函数值。
返回值
结果以弧度位单位，在区间
[-Π / 2, +Π / 2]。atan(0)返回 +0。
函数描述
计算输入参数x的反正切函数值。
__device__ double atan2 (double y, double x)
计算第一个和第二个输入参数之比的反正切。
返回值
结果以弧度位单位，在区间
[-Π, +Π]。atan2(0, 1)返回 +0。
函数描述
计算y / x的反正切函数值。结果的象限决定于x、y的符号。
__device__ double atanh (double x)
计算输入参数的双曲反正切函数值。
返回值
atanh(±0)返回 ±0。
atanh(±1)返回 ±∞
当x不在区间
[-1, 1]时，atanh(x)返回 NaN。
函数描述
计算输入参数x的双曲反正切函数值。
计算输入参数的立方根。
返回值
返回x1/3。
cbrt(±0)返回 ±0。
cbrt(±∞)返回 ±∞
函数描述
计算输入参数x的立方根，x1/3。
__device__ double ceil (double x)
计算输入参数的向上取整值。
返回值
ceil(±0)返回 ±0。
ceil(±∞)返回 ±∞
函数描述
计算不小于输入参数x的最小整数。
__device__ double copysign (double x, double y)
创造具有给定大小的值，复制第二个值的符号。
返回值
返回具有x的大小与y的符号的值。
函数描述
计算具有x的大小与y的符号的值。
__device__ double cos (double x)
计算输入参数的余弦函数值。
返回值
cos(0)返回1。
cos(±∞)返回 NaN。
函数描述
计算输入参数x（弧度位单位）的余弦值。
__device__ double cosh (double x)
计算输入参数的双曲余弦函数值。
返回值
cosh(0)返回1。
cosh(±∞)返回 +∞。
函数描述
计算输入参数x的双曲余弦函数值。
__device__ double cospi (double x)
计算输入参数 × Π 的余弦函数值。
返回值
cospi(0)返回1。
cospi(±∞)返回 NaN。
函数描述
计算
x × Π的余弦函数值，x是输入参数。
__device__ double cyl_bessel_i0 (double x)
计算输入参数的0阶正则修改圆柱贝塞尔函数的值。
返回值
返回输入参数的0阶正则修改圆柱贝塞尔函数的值。
函数描述
计算输入参数的0阶正则修改圆柱贝塞尔函数的值， I0(x)。
__device__ double cyl_bessel_i1 (double x)
计算输入参数的1阶正则修改圆柱贝塞尔函数的值。
返回值
返回输入参数的1阶正则修改圆柱贝塞尔函数的值。
函数描述
计算输入参数的1阶正则修改圆柱贝塞尔函数的值， I1(x)。
计算输入参数x的缩放互补误差函数。
__device__ double erf (double x)
计算输入参数的错误函数。
返回值
erf(±0)返回 ±0。
erf(±∞)返回±1。
函数描述
计算输入参数x的错误函数。
__device__ double erfc (double x)
计算输入参数的互补误差函数。
返回值
erfc(-∞)返回2。
erfc(+∞)返回 +0。
函数描述
计算输入参数x的互补误差函数，1 - erf(x)。
__device__ double erfcinv (double y)
计算输入参数的逆互补误差函数。
返回值
erfcinv(0)返回 +∞。
erfcinv(2)返回 -∞。
函数描述
计算输入参数y的逆互补误差函数，对于y在区间[0, 2]上。逆互补误差函数寻找符合下面条件的x的值：y = erfc(x)，0 \(\leqslant\) y \(\leqslant\) 2，并且-∞ \(\leqslant\) x \(\leqslant\) ∞。
__device__ double erfcx (double x)
计算输入参数的缩放互补误差函数。
返回值
erfcx(-∞)返回 +∞。
erfcx(+∞)返回 +0。
如果正确计算的值的范围超出了单精度浮点数的表示范围，erfcx(x)返回 +∞。
函数描述
__device__ double erfinv (double y)
计算输入参数的逆误差函数。
返回值
erfinv(1)返回 +∞。
erfinv(-1)返回 -∞。
函数描述
计算输入参数y的逆误差函数，y在区间[-1, 1]上。逆误差函数寻找符合下面条件的x的值：y = erf(x)，0 \(\leqslant\) y \(\leqslant\) 2，并且-∞ \(\leqslant\) x \(\leqslant\) ∞。
__device__ double exp (double x)
计算输入参数的基数e指数。
返回值
返回ex。
函数描述
计算输入参数x的基数10指数，ex。
__device__ double exp10 (double x)
计算输入参数的基数10指数。
返回值
返回10x。
函数描述
计算输入参数x的基数10指数，10x。
__device__ double exp2 (double x)
计算输入参数的基数2指数。
返回值
返回2x。
函数描述
计算输入参数x的基数10指数，2x。
__device__ double expm1 (double x)
计算输入参数的基数e指数减去1。
返回值
返回ex - 1。
函数描述
计算输入参数x的基数10指数减去1，ex - 1。
__device__ double fabs (double x)
计算输入参数的基数e指数减去1。
返回值
fabs(±∞)返回 +∞。
fabs(±0)返回0。
函数描述
计算输入参数x的绝对值。
__device__ double fdim (double x, double y)
计算x与y之间的正数差。
返回值
返回x与y之间的正数差。
如果x > y，fdim(x, y)返回 x - y。
如果x \(\leqslant\) y，fdim(x, y)返回 +0。
函数描述
计算x与y之间的正数差。当x > y时结果为x - y；否则，为+0。
__device__ double floor (double x)
计算不大于x的最大整数。
返回值
返回值以浮点数返回。
floor(±∞) 返回 ±∞
floor(±0) 返回 ±0。
函数描述
计算不大于x的最大整数。
__device__ double fma (double x, double y, double z)
以一个操作计算单精度 x * y + z 。
返回值
返回舍入的单精度 x * y + z 的结果：
fma(±∞, ±0, z)返回 NaN。fma(±0, ±∞, z)返回 NaN。如果x * y是确切的+∞，
fma(x, y, -∞)返回 NaN。如果x * y是确切的-∞，
fma(x, y, +∞)返回 NaN。
函数描述
以一个三元操作计算单精度
x * y + z。在计算之后，值需要舍入一次。
__device__ double fmax (double, double)
计算入参的最大值。
返回值
返回入参的最大值。
如果两个参数都是NaN，返回 NaN。
如果一个参数是NaN，返回另一个不是NaN的参数。
函数描述
计算入参x，y的最大值。将NaN参数视作无效数据。如果一个参数是NaN，另一个参数是合法数字值，数字值要被返回。
__device__ double fmin (double x, double y)
计算入参的最小值。
返回值
返回入参的最小值。
如果两个参数都是NaN，返回 NaN。
如果一个参数是NaN，返回另一个不是NaN的参数。
函数描述
计算入参x，y的最小值。将NaN参数视作无效数据。如果一个参数是NaN，另一个参数是合法数字值，数字值要被返回。
__device__ double fmod (double x, double y)
计算x/y的浮点余数。
返回值
返回x/y的浮点余数。
如果y不是0，fmod(±0, y)返回 ±0。
如果x是有限值，fmod(x, ±∞)返回x。
如果x是±∞或者y是0，fmod(x, y)返回 NaN。
如果某一个参数是NaN，返回 NaN。
函数描述
计算x/y的浮点余数。这个函数计算的浮点余数具体的是x - n * y，这里的n是x / y，其分数部分被截断。计算出的结果会有x相同的符号，并且它的值大小比y的值大小小。
__device__ double frexp (double x, int *nptr)
提取浮点值的尾数和指数。
返回值
返回分数分量m。
frexp(0, nptr)对于分数分量返回0，对于整数分量返回0。
frexp(±0, nptr)返回 ±0并且nptr指向的内存赋值0。
frexp(±∞, nptr)返回 ±∞，并且在nptr指向的内存赋值一个不确定的值。
frexp(NaN, y)返回 NaN，并且在nptr指向的内存赋值一个不确定的值。
函数描述
将浮点值x分解为归一化分数元素的分量m和指数的另一项n。m的绝对值将大于或等于0.5且小于1.0或等于0；x = m * 2n。整数指数n将存储在nptr指向的位置。
__device__ double hypot (double x, double y)
计算x与y的平方和的平方根。
返回值
斜边的长度sqrt(x2 + y2)。如果正确计算的值溢出，返回+无穷。如果正确计算结果向下溢出，返回0。
函数描述
计算直角三角形斜边的长度，该直角三角形的两侧具有长度x和y，且没有过度溢出或下溢。
__device__ int ilogb (double x)
计算参数的无偏整数指数。
返回值
如果成功，返回参数的无偏指数。
ilogb(0)返回INT_MIN。
ilogb(NaN)返回INT_MIN。
如果x是∞或者确切值比INT_MAX大，ilogb(x)返回INT_MAX。
如果确切值比INT_MIN小，ilogb(x)返回INT_MIN
注意，上面的操作不涉及FP_ILOGB0、FP_ILOGBNAN。
函数描述
计算参数x的无偏整数指数。
__device__ bool isfinite (double a)
确认参数是否是有穷的。
返回值
当且仅当a是一个有穷值的时候返回true。
函数描述
确认参数a是否是有穷的。
__device__ bool isinf (double a)
确认参数是否是无穷的。
返回值
当且仅当a是一个无穷值的时候返回true。
函数描述
确认参数a是否是无穷的。
__device__ bool isnan (double a)
确认参数是否是NaN。
返回值
当且仅当a是一个NaN的时候返回true。
函数描述
确认参数a是否是NaN。
__device__ double j0 (double x)
计算输入参数的第一类0阶贝塞尔函数的值。
返回值
输入参数的第一类0阶贝塞尔函数的值。
j0(±∞)返回 +0。
j0(NaN)返回 NaN。
函数描述
计算输入参数x的第一类0阶贝塞尔函数的值，J0(x)。
__device__ double j1 (double x)
计算输入参数的第一类1阶贝塞尔函数的值。
返回值
输入参数的第一类1阶贝塞尔函数的值。
j1(±0)返回 ±0。
j1(±∞)返回 ±0。
j1(NaN)返回 NaN。
函数描述
计算输入参数x的第一类1阶贝塞尔函数的值，J1(x)。
__device__ double jn (int n, double x)
计算输入参数的第一类n阶贝塞尔函数的值。
返回值
输入参数的第一类n阶贝塞尔函数的值。
jn(NaN)返回 NaN。
jn(n, x)在n < 0时返回 ±0。
jn(n, +∞)返回 +0。
函数描述
计算输入参数x的第一类n阶贝塞尔函数的值，Jn(x)。
__device__ double ldexp (double x, int exp)
计算x * 2exp的值。
返回值
如果正确计算的值超出单精度范围，ldexp(x)返回 ±∞。
函数描述
计算入参x、exp下面的数学公式：x * 2exp的值。
__device__ double lgamma (double x)
计算输入参数gamma函数绝对值的自然对数。
返回值
lgamma(1)返回 +0。
lgamma(2)返回 +0。
如果正确计算的值超出单精度表示范围，lgamma(x)返回 ±∞。
如果x \(\leqslant\) 0且是个整数，lgamma(x)返回 +∞。
lgamma(-∞)返回 -∞。
lgamma(+∞)返回 +∞。
函数描述
计算输入参数x的gamma函数绝对值的自然对数。
__device__ long long int llrint (double x)
将输入四舍五入到最接近的整数值。
返回值
返回舍入后的整数值。
函数描述
将x四舍五入到最接近的整数值，一半的情况下四舍五入到最接近的偶数整数值。如果结果超出返回类型的范围，则结果未定义。
__device__ long long int llround (double x)
将输入四舍五入到最接近的整数值。
返回值
返回舍入后的整数值。
函数描述
将x四舍五入到最接近的整数值，一半的情况下从零四舍五入。如果结果超出返回类型的范围，则结果未定义。
__device__ double log (double x)
计算输入参数的自然对数。
返回值
log(±0)返回 -∞。
log(1)返回 +0。
当x < 0，log(x)时返回 NaN。
log(+∞)返回 +∞。
函数描述
计算输入参数的自然对数。
__device__ double log10 (double x)
计算输入参数以10为底的对数。
返回值
log10(±0)返回 -∞。
log10(1)返回 +0。
当x < 0时，log10(x)返回 NaN。
log10(+∞)返回 +∞。
函数描述
计算输入参数x以10为底的对数。
__device__ double log1p (double x)
计算loge(1+x)的值。
返回值
log1p(±0)返回 ±0。
log1p(-1)返回 -∞。
当x < -1时，log1p(x)返回 NaN。
log1p(+∞)返回 +∞。
函数描述
计算loge(1+x)的值。
__device__ double log2 (double x)
计算输入参数以2为底的对数。
返回值
log2(±0)返回 -∞。
log2(1)返回 +0。
当x < 0时，log2(x)返回 NaN。
log2(+∞)返回 +∞。
函数描述
计算输入参数x以2为底的对数。
__device__ double logb (double x)
计算输入参数x的指数的浮点表示形式。
返回值
logb(±0)返回 -∞。
logb(+∞)返回 +∞。
函数描述
计算输入参数x的指数的浮点表示形式。
__device__ long int lrint (double x)
将输入四舍五入到最接近的整数值。
返回值
返回舍入后的值。
函数描述
将x四舍五入到最接近的整数值，一半的情况下四舍五入到最接近的偶数整数值。如果结果超出返回类型的范围，则结果未定义。
__device__ long int lround (double x)
将输入四舍五入到最接近的整数值。
返回值
返回舍入后的值。
函数描述
将x四舍五入到最接近的整数值，一半的情况下从零四舍五入。如果结果超出返回类型的范围，则结果未定义。
__device__ double max (const double a, const float b)
计算输入的浮点数的最大值。
函数描述
把float参数转为double，计算输入参数a和b的最大值，行为与函数fmaxf()一致。
备注
这个函数与std::里面的函数不同。
__device__ double max (const float a, const double b)
计算输入的浮点数的最大值。
函数描述
把float参数转为double，计算输入参数a和b的最大值，行为与函数fmaxf()一致。
备注
这个函数与std::里面的函数不同。
__device__ double max (const double a, const double b)
计算输入的浮点数的最大值。
函数描述
计算输入参数a和b的最大值，行为与函数fmaxf()一致。
备注
这个函数与std::里面的函数不同。
__device__ double min (const double a, const float b)
计算输入的浮点数的最小值。
函数描述
把float参数转为double，计算输入参数a和b的最小值，行为与函数fminf()一致。
备注
这个函数与std::里面的函数不同。
__device__ double min (const float a, const double b)
计算输入的浮点数的最小值。
函数描述
把float参数转为double，计算输入参数a和b的最小值，行为与函数fminf()一致。
备注
这个函数与std::里面的函数不同。
__device__ double min (const double a, const double b)
计算输入的浮点数的最小值。
函数描述
计算输入参数a和b的最小值，行为与函数fminf()一致。
备注
这个函数与std::里面的函数不同。
__device__ double modf (double x, double *iptr)
将输入参数分解为分数和整数部分。
返回值
modf(±x, iptr)返回一个与x具有相同的符号的结果。
modf(±∞, iptr)返回 ±0并且在iptr指向的内存中存入±∞。
modf(NaN, iptr)返货NaN并且在iptr指向的内存中存入NaN。
函数描述
将参数x分解为分数和整数部分。分数部分存储在参数iptr中。分数和整数部分的符号与参数x相同。
__device__ double nan (const char *tagp)
返回“Not a Number” 值。
返回值
nan(tagp)返回 NaN。
函数描述
返回安静NaN的表示。参数tagp选择一种可能的表示形式。
__device__ double nearbyint (double x)
将输入参数四舍五入到最接近的整数。
返回值
nearbyint(±0)返回 ±0。
nearbyint(±∞)返回 ±∞。
函数描述
将参数x舍入为单精度浮点格式的整数值。
__device__ double nextafter (double x, double y)
返回y方向上参数x之后的下一个可表示的单精度浮点值。
返回值
如果x == y，nextafter(x, y) = y。
如果x或y是NaN，nextafter(x, y) = NaN。
函数描述
计算沿y方向x之后的下一个可表示的单精度浮点值。例如，如果y大于x，则nextafterf()返回大于x的最小可表示数字。
__device__ double norm (int dim, const double *p)
计算任意数量坐标的平方和的平方根。
返回值
返回dim维向量长度sqrt(p02 + p12 + … + pdim-12)。如果计算结果溢出，则返回 +∞，如果计算结果向下溢出，则返回0。
__device__ double norm3d (double a, double b, double c)
计算参数的三个坐标的平方和的平方根。
返回值
返回三维向量长度sqrt(a2 + b2 + c2)。如果计算结果溢出，则返回 +∞，如果计算结果向下溢出，则返回0。
函数描述
计算欧几里德空间中三维向量的长度，无过度溢出或下溢。
__device__ double norm4d (double a, double b, double c, double d)
计算参数的四个坐标的平方和的平方根。
返回值
返回四维向量长度sqrt(a2 + b2 + c2 + d2)。如果计算结果溢出，则返回 +∞，如果计算结果向下溢出，则返回0。
函数描述
计算欧几里德空间中四维向量的长度，无过度溢出或下溢。
__device__ double normcdf (double y)
计算标准正态累积分布函数。
返回值
normcdf(+∞)返回1。
normcdf(-∞)返回 +0。
函数描述
计算输入y的标准正态分布函数的值。
__device__ double normcdfinv (double y)
计算标准正态累积分布函数。
返回值
normcdfinv(0)返回 -∞。
normcdfinv(1)返回 +∞。
如果x不在区间[0, 1]，normcdfinv(x)返回 NaN。
函数描述
计算输入参数y的标准正态累积分布函数的逆。这个函数的输入值的取值范围在区间(0,1)。
计算向量p的长度，向量p的维数作为参数传递，不会出现过度溢出或下溢。
__device__ double pow (double x, double y)
计算第一个参数的值与第二个参数的幂。
返回值
pow(±0, y)对于y小于0的整数，返回 ±∞。
pow(±0, y)对于y一个大于0的整数奇数返回 ±0。
pow(±0, y)对于y > 0且不是一个奇数整数返回 +0。
pow(-1, ±∞)返回1。
pow(+1, y)对于任何y甚至NaN，返回1。
pow(x, ±0)对于任何x甚至NaN，返回1。
pow(x, y)对于有穷x < 0且有穷非整数y返回 NaN。
pow(x, -∞)对于|x| < 1返回 +∞。
pow(x, -∞)对于|x| > 1返回 +0。
pow(x, +∞)对于|x| < 1返回 +0。
pow(x, +∞)对于|x| > 1返回 +∞。
pow(-∞, y)对于y是一个小于0的奇数返回-0。
pow(-∞, y)对于y < 0且不是奇数返回 +0。
pow(-∞, y)对于y是一个大于0的奇数返回 -∞。
pow(-∞, y)对于y > 0且不是奇数返回 +∞。
pow(+∞, y)对于y < 0返回 +0。
pow(+∞, y)对于y > 0返回 +∞。
函数描述
计算x的值为y的幂。
__device__ double rcbrt (double x)
计算倒数立方根函数。
返回值
rcbrt(±0) 返回 ±∞。
rcbrt(±∞) 返回 ±0。
函数描述
计算x的倒数立方根函数。
__device__ double remainder (double x, double y)
计算单精度浮点余数。
返回值
remainderf(x, 0)返回 NaN。
remainderf(±∞, y) 返回 NaN。
remainderf(x, ±∞) 对于有穷x返回x。
函数描述
计算非零y的x除以y的单精度浮点余数r，因此r = x - ny。n的值是最接近x / y的整数。
__device__ double remquo (double x, double y, int *quo)
计算单精度浮点余数和部分商。
返回值
返回余数。
remquo(x, 0, quo)返回 NaN。
remquo(±∞, y, quo) 返回 NaN。
remquo(x, ±∞, quo) 返回x。
函数描述
以与remainder()函数相同的方式计算双精度浮点余数。参数quo在x除以y后返回部分商。值quo与x/y有相同的符号，可能不是精确商，但与低阶3位中的精确商一致。
__device__ double rhypot (double x, double y)
计算两个参数平方和的平方根。
返回值
返回斜边长度倒数值1 / sqrt(x2 + y2)。如果平方根溢出，返回0。如果平方根向下溢出，返回 +∞。
函数描述
计算直角三角形斜边长度倒数，该直角三角形的两侧具有长度x和y，没有过度溢出或下溢。
__device__ double rint (double x)
将输入四舍五入为最接近的浮点整数值。
返回值
返回舍入后的值。
函数描述
以浮点格式将x四舍五入为最接近的整数值，将一半大小写四舍五入为最接近的偶数整数值。
__device__ double rnorm (int dim, const double *p)
计算任意数量坐标的平方和的平方根的倒数。
返回值
返回dim维向量长度的倒数1 / sqrt(p02 + p12 + … + pdim-1 2)。如果平方根溢出返回0，如果平方根向下溢出，返回 +∞。
函数描述
计算欧几里德空间中dim维向量p长度倒数，无过度溢出或下溢。
__device__ double rnorm3d (double a, double b, double c)
计算参数三个坐标的平方和的平方根的倒数。
返回值
返回三维向量长度的倒数1 / sqrt(a2 + b2 + c2)。如果平方根溢出返回0，如果平方根向下溢出，返回 +∞。
函数描述
计算欧几里德空间中三维向量长度倒数，无过度溢出或下溢。
__device__ double rnorm4d (double a, double b, double c, double d)
计算参数四个坐标的平方和的平方根的倒数。
返回值
返回四维向量长度的倒数1 / sqrt(a2 + b2 + c2 + d2)。如果平方根溢出返回0，如果平方根向下溢出，返回 +∞。
函数描述
计算欧几里德空间中四维向量长度倒数，无过度溢出或下溢。
__device__ double round (double x)
四舍五入到最接近的浮点整数值。
返回值
返回舍入后的值。
函数描述
以浮点格式将x四舍五入到最接近的整数值，中间的大小写从零四舍五入。
__device__ double rsqrt (double x)
计算输入值平方根的倒数。
返回值
返回 1 / sqrt(x)。
rsqrt(+∞) 返回 +0
rsqrt(±0) 返回 ±∞
如果x < 0，rsqrt(x) 返回 NaN。
函数描述
计算输入参数x的平方根的倒数。
__device__ double scalbln (double x, long int n)
按2的整数幂缩放浮点输入。
返回值
返回 x * 2n。
scalblnf(±0, n) 返回 ±0。
scalblnf(x, 0) 返回x。
scalblnf(±∞, n) 返回 ±∞。
函数描述
按2n缩放浮点输入x。
__device__ double scalbln (double x, int n)
按2的整数幂缩放浮点输入。
返回值
返回 x * 2n。
scalbln(±0, n) 返回 ±0。
scalbln(x, 0) 返回x。
scalbln(±∞, n) 返回 ±∞。
函数描述
按2n缩放浮点输入x。
__device__ bool signbit (double a)
返回输入的符号位。
返回值
当且仅当a是负数返回true。
函数描述
确认浮点数是不是负数。
__device__ float sin (double x)
计算输入参数的正弦。
返回值
sin(±0)返回 ±0。
sin(±∞)返回 NaN。
函数描述
计算输入参数x的正弦。
__device__ void sincos (double x, double *sptr, double *cptr)
计算第一个输入参数的正弦和余弦。
返回值
无。
函数描述
计算第一个输入参数x（以弧度为单位）的正弦和余弦。正弦和余弦的结果分别写入第二个参数sptr和第三个参数cptr。
__device__ void sincospi (double x, double *sptr, double *cptr)
计算第一个输入参数 * Π 的正弦和余弦。
返回值
无。
函数描述
计算第一个输入参数x（以弧度为单位） * Π 的正弦和余弦。正弦和余弦的结果分别写入第二个参数sptr和第三个参数cptr。
__device__ double sinh (double x)
计算输入参数的双曲正弦。
返回值
sinh(±0)返回 ±0。
sinh(±∞)返回 ±∞。
函数描述
计算输入参数x的双曲正弦。
__device__ double sinpi (double x)
计算输入参数 * Π 的正弦。
返回值
sin(±0)返回 ±0。
sin(±∞)返回 NaN。
函数描述
计算输入参数x * Π 的正弦。
__device__ double sqrt (double x)
计算输入参数的平方根。
返回值
sqrt(±0)返回 ±0。
sqrt(+∞)返回 +∞。
如果x < 0，sqrt(x)返回x。
函数描述
计算输入参数x的平方根。
__device__ double tan (double x)
计算输入参数的正切。
返回值
tan(±0)返回 ±0。
tan(±∞)返回 NaN。
函数描述
计算输入参数x的正切。
__device__ double tanh (double x)
计算输入参数的双曲正切。
返回值
tanhf(±0)返回 ±0。
函数描述
计算输入参数x的双曲正切。
__device__ double tgamma (double x)
计算输入参数的gamma函数。
返回值
tgamma(±0)返回 ±∞。
tgamma(2)返回+1。
如果计算值超出单精度表示范围，tgamma(x)返回 ±∞。
如果x < 0且是个整数，tgamma(x)返回 NaN。
tgamma(-∞)返回 NaN。
tgamma(+∞)返回 +∞。
函数描述
计算输入参数x的gamma函数。
__device__ double trunc (double x)
将输入参数截断为整数部分。
返回值
返回截断的整数部分。
函数描述
将x四舍五入到最接近的整数值，该整数值的大小不超过x。
__device__ double y0 (double x)
为输入参数计算第二类0阶贝塞尔函数的值。
返回值
返回计算的第二类0阶贝塞尔函数的值。
y0(0)返回 -∞。
y0(x)对于x < 0返回 NaN。
y0(+∞)返回 +0。
y0(NaN)返回 NaN。
函数描述
计算输入参数x的第二类0阶贝塞尔函数的值，Y0(x)。
__device__ double y1 (double x)
为输入参数计算第二类1阶贝塞尔函数的值。
返回值
返回计算的第二类1阶贝塞尔函数的值。
y1(0)返回 -∞。
y1(x)对于x < 0返回 NaN。
y1(+∞)返回 +0。
y1(NaN)返回 NaN。
函数描述
计算输入参数x的第二类1阶贝塞尔函数的值，Y1(x)。
__device__ double yn (int n, double x)
为输入参数计算第二类n阶贝塞尔函数的值。
返回值
返回计算的第二类n阶贝塞尔函数的值。
yn(0)返回 -∞。
yn(x)对于x < 0返回 NaN。
yn(+∞)返回 +0。
yn(NaN)返回 NaN。
函数描述
计算输入参数x的第二类n阶贝塞尔函数的值，Yn(x)。
1.8.17. 整数型度数学函数
__device__ int abs (int a)
参数
a
int
返回值
int
函数描述
计算a的绝对值。
__device__ long int labs (long int a)
参数
a
long int
返回值
long int
函数描述
计算a的绝对值。
__device__ long long int llabs (long long int a)
参数
a
long long int
返回值
long long long int
函数描述
计算a的绝对值。
__device__ long long int llmax (const long long int a, const long long int
b)
参数
a
long long int
b
long long int
返回值
long long int
函数描述
返回a和b中的最大值。
__device__ long long int llmin (const long long int a, const long long int
b)
参数
a
long long int
b
long long int
返回值
long long int
函数描述
返回a和b中的最小值。
__device__ unsigned long long int max (const unsigned long long int a, const
long long int b)
参数
a
long long int
b
unsigned long long int
返回值
unsigned long long int
函数描述
执行整数类型提升后，返回a和b中的最大值。
__device__ unsigned long long int max (const long long int a, const unsigned
long long int b)
参数
a
long long int
b
unsigned long long int
返回值
unsigned long long int
函数描述
执行整数类型提升后，返回a和b中的最大值。
__device__ unsigned long long int max (const unsigned long long int a, const
unsigned long long int b)
参数
a
unsigned long long int
b
unsigned long long int
返回值
unsigned long long int
函数描述
返回a和b中的最大值。
__device__ long long int max (const long long int a, const long long int b)
参数
a
long long int
b
long long int
返回值
long long int
函数描述
返回a和b中的最大值。
__device__ unsigned long int max (const unsigned long int a, const long int
b)
参数
a
unsigned long int
b
long int
返回值
unsigned long int
函数描述
执行整数类型提升后，返回a和b中的最大值。
__device__ unsigned long int max (const long int a, const unsigned long int
b)
参数
a
long int
b
unsigned long int
返回值
unsigned long int
函数描述
执行整数类型提升后，返回a和b中的最大值。
__device__ unsigned long int max (const unsigned long int a, const unsigned
long int b)
参数
a
unsigned long int
b
unsigned long int
返回值
unsigned long int
函数描述
返回a和b中的最大值。
__device__ long int max (const long int a, const long int b)
参数
a
long int
b
long int
返回值
long int
函数描述
返回a和b中的最大值。
__device__ unsigned int max (const unsigned int a, const int b)
参数
a
unsigned int
b
int
返回值
unsigned int
函数描述
执行整数类型提升后，返回a和b中的最大值。
__device__ unsigned int max (const int a, const unsigned int b)
参数
a
int
b
unsigned int
返回值
unsigned int
函数描述
执行整数类型提升后，返回a和b中的最大值。
__device__ unsigned int max (const unsigned int a, const unsigned int b)
参数
a
unsigned int
b
unsigned int
返回值
unsigned int
函数描述
返回a和b中的最大值。
__device__ int max (const int a, const int b)
参数
a
int
b
int
返回值
int
函数描述
返回a和b中的最大值。
__device__ unsigned long long int min (const unsigned long long int a, const
long long int b)
参数
a
unsigned long long int
b
long long int
返回值
unsigned long long int
函数描述
执行整数类型提升后，返回a和b中的最小值。
__device__ unsigned long long int min (const long long int a, const unsigned
long long int b)
参数
a
long long int
b
unsigned long long int
返回值
unsigned long long int
函数描述
执行整数类型提升后，返回a和b中的最小值。
__device__ unsigned long long int min (const unsigned long long int a, const
unsigned long long int b)
参数
a
unsigned long long int
b
unsigned long long int
返回值
unsigned long long int
函数描述
返回a和b中的最小值。
__device__ long long int min (const long long int a, const long long int b)
参数
a
long long int
b
long long int
返回值
long long int
函数描述
返回a和b中的最小值。
__device__ unsigned long int min (const unsigned long int a, const long int
b)
参数
a
unsigend long int
b
long int
返回值
unsigned long int
函数描述
执行整数类型提升后，返回a和b中的最小值。
__device__ unsigned long int min (const long int a, const unsigned long int
b)
参数
a
long int
b
unsigned long int
返回值
unsigned long int
函数描述
执行整数类型提升后，返回a和b中的最小值。
__device__ unsigned long int min (const unsigned long int a, const unsigned
long int b)
参数
a
unsigned long int
b
unsigned long int
返回值
unsigned long int
函数描述
返回a和b中的最小值。
__device__ long int min (const long int a, const long int b)
参数
a
long int
b
long int
返回值
long int
函数描述
返回a和b中的最小值。
__device__ unsigned int min (const unsigned int a, const int b)
参数
a
unsigned int
b
int
返回值
unsigned int
函数描述
执行整数类型提升后，返回a和b中的最小值。
__device__ unsigned int min (const int a, const unsigned int b)
参数
a
int
b
unsigned int
返回值
unsigned int
函数描述
执行整数类型提升后，返回a和b中的最小值。
__device__ unsigned int min (const unsigned int a, const unsigned int b)
参数
a
unsigned int
b
unsigned int
返回值
unsigned int
函数描述
返回a和b中的最小值。
__device__ int min (const int a, const int b)
参数
a
int
b
int
返回值
int
函数描述
返回a和b中的最小值。
__device__ unsigned long long int ullmax (const unsigned long long int a,
const unsigned long long int b)
参数
a
unsigned long long int
b
unsigned long long int
返回值
unsigned long long int
函数描述
返回a和b中的最大值。
__device__ unsigned long long int ullmin (const unsigned long long int a,
const unsigned long long int b)
参数
a
unsigned long long int
b
unsigned long long int
返回值
unsigned long long int
函数描述
返回a和b中的最小值。
__device__ unsigned int umax (const unsigned int a, const unsigned int b)
参数
a
unsigned int
b
unsigned int
返回值
unsigned int
函数描述
返回a和b中的最大值。
__device__ unsigned int umin (const unsigned int a, const unsigned int b)
参数
a
unsinged int
b
unsigned int
返回值
unsigned int
函数描述
返回a和b中的最小值。
1.8.18. 单精度intrinsic
__device__ float __cosf (float x)
计算输入参数的快速近似余弦值（ cos(x) ）。
返回值
返回
cos(x)。
函数描述
计算输入参数x的快速近似余弦值，以弧度为单位。
__device__ float __exp10f (float x)
计算输入参数的快速近似基数10指数。
返回值
返回10x。
函数描述
计算输入参数x的快速近似基数10指数，10x。
__device__ float __expf (float x)
计算输入参数的快速近似基数e指数。
返回值
返回ex。
函数描述
计算输入参数x的快速近似基数e的指数，ex。
__device__ float __fadd_rd (float x, float y)
以向下舍入模式把两个浮点数加起来。
返回值
返回
x + y。
函数描述
以向下舍入模式把两个浮点数x，y加起来。
__device__ float __fadd_rn (float x, float y)
以向最近偶数舍入模式把两个浮点数加起来。
返回值
返回
x + y。
函数描述
以最近偶数舍入模式把两个浮点数x，y加起来。
__device__ float __fadd_ru (float x, float y)
以向上舍入模式把两个浮点数加起来。
返回值
返回
x + y。
函数描述
以向上舍入模式把两个浮点数x，y加起来。
__device__ float __fadd_rz (float x, float y)
以向零舍入模式把两个浮点数加起来。
返回值
返回
x + y。
函数描述
以向零舍入模式把两个浮点数x，y加起来。
__device__ float __fdiv_rd (float x, float y)
以向下舍入模式计算两个浮点数的商。
返回值
返回
x / y。
函数描述
以向下舍入模式计算两个浮点数的商。
__device__ float __fdiv_rn (float x, float y)
以向最近偶数舍入模式计算两个浮点数的商。
返回值
返回
x / y。
函数描述
以向最近偶数舍入模式计算两个浮点数的商。
__device__ float __fdiv_ru (float x, float y)
以向上舍入模式计算两个浮点数的商。
返回值
返回
x / y。
函数描述
以向上舍入模式计算两个浮点数的商。
__device__ float __fdiv_rz (float x, float y)
以向零舍入模式计算两个浮点数的商。
返回值
返回
x / y。
函数描述
以向零舍入模式计算两个浮点数的商。
__device__ float __fdividef (float x, float y)
计算输入参数的快速近似除法。
返回值
返回
x / y。__fdividef(∞, y)对于2216< |y| < 2218返回 NaN。__fdividef(x, y)对于2216< |y| < 2218和有穷x返回0。
函数描述
计算输入参数的快速近似除法x / y。
__device__ float __fmaf_ieee_rd (float x, float y, float z)
以向下舍入模式计算融合乘法加法运算，忽略-ftz=true的编译器标志。
函数描述
行为与
__fmaf_rd(x, y, z)一致。区别在于处理非规范化的输入和输出：-ftz编译器标志无效。
__device__ float __fmaf_ieee_rn (float x, float y, float z)
以向最近偶数舍入模式计算融合乘法加法运算，忽略-ftz=true的编译器标志。
函数描述
行为与
__fmaf_rn(x, y, z)一致。区别在于处理非规范化的输入和输出：-ftz编译器标志无效。
__device__ float __fmaf_ieee_ru (float x, float y, float z)
以向最近偶数舍入模式计算融合乘法加法运算，忽略-ftz=true的编译器标志。
函数描述
行为与
__fmaf_ru(x, y, z)一致。区别在于处理非规范化的输入和输出：-ftz编译器标志无效。
__device__ float __fmaf_ieee_rz (float x, float y, float z)
以向最近偶数舍入模式计算融合乘法加法运算，忽略-ftz=true的编译器标志。
函数描述
行为与
__fmaf_rz(x, y, z)一致。区别在于处理非规范化的输入和输出：-ftz编译器标志无效。
__device__ float __fmaf_rd (float x, float y, float z)
以向下舍入模式计算单精度 x * y + z 。
返回值
返回舍入的单精度 x * y + z 的结果：
fmaf(±∞, ±0, z)返回 NaN。fmaf(±0, ±∞, z)返回 NaN。如果x * y是确切的+∞，
fmaf(x, y, -∞)返回 NaN。如果x * y是确切的-∞，
fmaf(x, y, +∞)返回 NaN。
函数描述
以向下舍入模式计算单精度
x * y + z。
__device__ float __fmaf_rn (float x, float y, float z)
以向最近偶数舍入模式计算单精度 x * y + z 。
返回值
返回舍入的单精度 x * y + z 的结果：
fmaf(±∞, ±0, z)返回 NaN。fmaf(±0, ±∞, z)返回 NaN。如果x * y是确切的+∞，
fmaf(x, y, -∞)返回 NaN。如果x * y是确切的-∞，
fmaf(x, y, +∞)返回 NaN。
函数描述
以向最近偶数舍入模式计算单精度
x * y + z。
__device__ float __fmaf_ru (float x, float y, float z)
以向上舍入模式计算单精度 x * y + z 。
返回值
返回舍入的单精度 x * y + z 的结果：
fmaf(±∞, ±0, z)返回 NaN。fmaf(±0, ±∞, z)返回 NaN。如果x * y是确切的+∞，
fmaf(x, y, -∞)返回 NaN。如果x * y是确切的-∞，
fmaf(x, y, +∞)返回 NaN。
函数描述
以向上舍入模式计算单精度
x * y + z。
__device__ float __fmaf_rz (float x, float y, float z)
以向零舍入模式计算单精度 x * y + z 。
返回值
返回舍入的单精度 x * y + z 的结果：
fmaf(±∞, ±0, z)返回 NaN。fmaf(±0, ±∞, z)返回 NaN。如果x * y是确切的+∞，
fmaf(x, y, -∞)返回 NaN。如果x * y是确切的-∞，
fmaf(x, y, +∞)返回 NaN。
函数描述
以向零舍入模式计算单精度
x * y + z。
__device__ float __fmul_rd (float x, float y, float z)
以向下舍入模式计算单精度 x * y 。
返回值
返回x * y。
函数描述
以向下舍入模式计算单精度
x * y。
__device__ float __fmul_rn (float x, float y, float z)
以向最近偶数舍入模式计算单精度 x * y 。
返回值
返回x * y。
函数描述
以向最近偶数舍入模式计算单精度
x * y。
__device__ float __fmul_ru (float x, float y, float z)
以向上舍入模式计算单精度 x * y 。
返回值
返回x * y。
函数描述
以向上舍入模式计算单精度
x * y。
__device__ float __fmul_rz (float x, float y, float z)
以向零舍入模式计算单精度 x * y 。
返回值
返回x * y。
函数描述
以向零舍入模式计算单精度
x * y。
__device__ float __frcp_rd (float x)
以向下舍入模式计算 1 / x 。
返回值
返回1 / x。
函数描述
以向下舍入模式计算
1 / x。
__device__ float __frcp_rn (float x)
以向最近偶数舍入模式计算 1 / x 。
返回值
返回1 / x。
函数描述
以向最近偶数舍入模式计算
1 / x。
__device__ float __frcp_ru (float x)
以向上舍入模式计算 1 / x 。
返回值
返回1 / x。
函数描述
以向上舍入模式计算
1 / x。
__device__ float __frcp_rz (float x)
以向零舍入模式计算 1 / x 。
返回值
返回1 / x。
函数描述
以向零舍入模式计算
1 / x。
__device__ float __frsqrt_rn (float x)
以向最近偶数舍入模式计算 1 / sqrt(x) 。
返回值
返回
1 / sqrt(x)。
函数描述
以向最近偶数舍入模式计算
1 / sqrt(x)。
__device__ float __fsqrt_rd (float x)
以向下舍入模式计算 sqrt(x) 。
返回值
返回
sqrt(x)。
函数描述
以向下舍入模式计算
sqrt(x)。
__device__ float __fsqrt_rn (float x)
以向最近偶数舍入模式计算 sqrt(x) 。
返回值
返回
sqrt(x)。
函数描述
以向最近偶数舍入模式计算
sqrt(x)。
__device__ float __fsqrt_ru (float x)
以向上舍入模式计算 sqrt(x) 。
返回值
返回
sqrt(x)。
函数描述
以向上舍入模式计算
sqrt(x)。
__device__ float __fsqrt_rz (float x)
以向零舍入模式计算 sqrt(x) 。
返回值
返回
sqrt(x)。
函数描述
以向零舍入模式计算
sqrt(x)。
__device__ float __fsub_rd (float x, float y)
以向下舍入模式计算 x - y 。
返回值
返回x - y。
函数描述
以向下舍入模式计算
x - y。
__device__ float __fsub_rn (float x, float y)
以向最近偶数舍入模式计算 x - y 。
返回值
返回x - y。
函数描述
以向最近偶数舍入模式计算
x - y。
__device__ float __fsub_ru (float x, float y)
以向上舍入模式计算 x - y 。
返回值
返回x - y。
函数描述
以向上舍入模式计算
x - y。
__device__ float __fsub_rz (float x, float y)
以向零舍入模式计算 x - y 。
返回值
返回x - y。
函数描述
以向零舍入模式计算
x - y。
__device__ float __log10f (float x)
计算log10(x)。
返回值
返回log10(x)。
函数描述
计算log10(x)。
__device__ float __log2f (float x)
计算log2(x)。
返回值
返回log2(x)。
函数描述
计算log2(x)。
__device__ float __logf (float x)
计算loge(x)。
返回值
返回loge(x)。
函数描述
计算loge(x)。
__device__ float __powf (float x, float y)
计算xy。
返回值
返回xy。
函数描述
计算xy。
__device__ float __saturatef (float x)
将输入参数映射为[+0.0, 1.0]。
返回值
如果x < 0，
__saturatef(x)返回0。如果x > 1，
__saturatef(x)返回1。如果0 \(\leqslant\) x \(\leqslant\) 1，
__saturatef(x)返回x。__saturatef(NaN)返回0。
函数描述
把输入参数映射到区间[+0.0, 1.0]。
__device__ void __sincosf (float x, float *sptr, float *cptr)
计算第一个输入参数的正弦和余弦的快速近似值。
返回值
无。
函数描述
计算第一个输入参数x的正弦和余弦的快速近似值（以弧度为单位）。正弦和余弦的结果分别写入第二个参数sptr和第三个参数cptr。
__device__ float __sinf (float x)
计算输入参数的正弦的快速近似值。
返回值
x的正弦值。
函数描述
以弧度为单位，计算x的正弦值。
__device__ float __tanf (float x)
计算输入参数的正切的快速近似值。
返回值
x的正切值。
函数描述
以弧度为单位，计算x的正切值。
1.8.19. 双精度intrinsic
这一节描述仅在device代码中支持的整数型intrinsic函数。不需要在程序中包含任何头文件就可以使用这些函数。
__device__ double __dadd_rd (double x, double y)
以向下舍入模式把两个浮点值加起来。
返回值
返回x + y。
函数描述
以向下舍入模式把两个浮点值x，y加起来。
__device__ double __dadd_rn (double x, double y)
以向最近偶数舍入模式把两个浮点值加起来。
返回值
返回x + y。
函数描述
以向最近偶数舍入模式把两个浮点值x，y加起来。
__device__ double __dadd_ru (double x, double y)
以向上舍入模式把两个浮点值加起来。
返回值
返回x + y。
函数描述
以向上舍入模式把两个浮点值x，y加起来。
__device__ double __dadd_rz (double x, double y)
以向零舍入模式把两个浮点值加起来。
返回值
返回x + y。
函数描述
以向零舍入模式把两个浮点值x，y加起来。
__device__ double __ddiv_rd (double x, double y)
以向下舍入模式计算x / y。
返回值
返回x / y。
函数描述
以向下舍入模式计算x / y。
__device__ double __ddiv_rn (double x, double y)
以向最近偶数舍入模式计算x / y。
返回值
返回x / y。
函数描述
以向最近偶数舍入模式计算x / y。
__device__ double __ddiv_ru (double x, double y)
以向上舍入模式计算x / y。
返回值
返回x / y。
函数描述
以向上舍入模式计算x / y。
__device__ double __ddiv_rz (double x, double y)
以向零舍入模式计算x / y。
返回值
返回x / y。
函数描述
以向零舍入模式计算x / y。
__device__ double __dmul_rd (double x, double y)
以向下舍入模式计算x * y。
返回值
返回x * y。
函数描述
以向下舍入模式计算x * y。
__device__ double __dmul_rn (double x, double y)
以向最近偶数舍入模式计算x * y。
返回值
返回x * y。
函数描述
以向最近偶数舍入模式计算x * y。
__device__ double __dmul_ru (double x, double y)
以向上舍入模式计算x * y。
返回值
返回x * y。
函数描述
以向上舍入模式计算x * y。
__device__ double __dmul_rz (double x, double y)
以向零舍入模式计算x * y。
返回值
返回x * y。
函数描述
以向零舍入模式计算x * y。
__device__ double __drcp_rd (double x)
以向下舍入模式计算1 / x。
返回值
返回1 / x。
函数描述
以向下舍入模式计算1 / x。
__device__ double __drcp_rn (double x)
以向最近偶数舍入模式计算1 / x。
返回值
返回1 / x。
函数描述
以向最近偶数舍入模式计算1 / x。
__device__ double __drcp_ru (double x)
以向上舍入模式计算1 / x。
返回值
返回1 / x。
函数描述
以向上舍入模式计算1 / x。
__device__ double __drcp_rz (double x)
以向零舍入模式计算1 / x。
返回值
返回1 / x。
函数描述
以向零舍入模式计算1 / x。
__device__ double __dsqrt_rd (double x)
以向下舍入模式计算 sqrt(x) 。
返回值
返回
sqrt(x)。
函数描述
以向下舍入模式计算
sqrt(x)。
__device__ double __dsqrt_rn (double x)
以向最近偶数舍入模式计算 sqrt(x) 。
返回值
返回
sqrt(x)。
函数描述
以向最近偶数舍入模式计算
sqrt(x)。
__device__ double __dsqrt_ru (double x)
以向上舍入模式计算 sqrt(x) 。
返回值
返回
sqrt(x)。
函数描述
以向上舍入模式计算
sqrt(x)。
__device__ double __dsqrt_rz (double x)
以向零舍入模式计算 sqrt(x) 。
返回值
返回
sqrt(x)。
函数描述
以向零舍入模式计算
sqrt(x)。
__device__ double __dsub_rd (double x, double y)
以向下舍入模式计算x - y。
返回值
返回x - y。
函数描述
以向下舍入模式计算x - y。
__device__ double __dsub_rn (double x, double y)
以向最近偶数舍入模式计算x - y。
返回值
返回x - y。
函数描述
以向最近偶数舍入模式计算x - y。
__device__ double __dsub_ru (double x, double y)
以向上舍入模式计算x - y。
返回值
返回x - y。
函数描述
以向上舍入模式计算x - y。
__device__ double __dsub_rz (double x, double y)
以向零舍入模式计算x - y。
返回值
返回x - y。
函数描述
以向零舍入模式计算x - y。
__device__ double __fma_rd (double x, double y, double z)
以向下舍入模式作为单个操作计算 x * y + z 。
返回值
x * y + z 作为单个操作返回的舍入值。
fmaf(±∞, ±0, z)返回 NaN。fmaf(±0, ±∞, z)返回 NaN。如果
x * y是确切的正无穷，fmaf(x, y, -∞)返回 NaN。如果
x * y是确切的负无穷，fmaf(x, y, +∞)返回 NaN。
函数描述
以向下舍入模式作为单个操作计算
x * y + z。
__device__ double __fma_rn (double x, double y, double z)
以向最近偶数舍入模式作为单个操作计算 x * y + z 。
返回值
x * y + z 作为单个操作返回的舍入值。
fmaf(±∞, ±, z)返回 NaN。fmaf(±0, ±∞, z)返回 NaN。如果
x * y是确切的正无穷，fmaf(x, y, -∞)返回 NaN。如果
x * y是确切的负无穷，fmaf(x, y, +∞)返回 NaN。
函数描述
以向最近偶数舍入模式作为单个操作计算
x * y + z。
__device__ double __fma_ru (double x, double y, double z)
以向上舍入模式作为单个操作计算 x * y + z 。
返回值
x * y + z 作为单个操作返回的舍入值。
fmaf(±∞, ±, z)返回 NaN。fmaf(±0, ±∞, z)返回 NaN。如果
x * y是确切的正无穷，fmaf(x, y, -∞)返回 NaN。如果
x * y是确切的负无穷，fmaf(x, y, +∞)返回 NaN。
函数描述
以向上舍入模式作为单个操作计算
x * y + z。
__device__ double __fma_rz (double x, double y, double z)
以向零舍入模式作为单个操作计算 x * y + z 。
返回值
x * y + z 作为单个操作返回的舍入值。
fmaf(±∞, ±, z)返回 NaN。fmaf(±0, ±∞, z)返回 NaN。如果
x * y是确切的正无穷，fmaf(x, y, -∞)返回 NaN。如果
x * y是确切的负无穷，fmaf(x, y, +∞)返回 NaN。
函数描述
以向零舍入模式作为单个操作计算
x * y + z。
1.8.20. 整数型intrinsic
这一节描述仅在device代码中支持的整数型intrinsic函数。不需要在程序中包含任何头文件就可以使用这些函数。
__device__ unsigned int __brev (unsigned int x)
把一个无符号整数中的32个bit反转。
返回值
返回bit反转之后的x的值，比如返回值的第N个bit对应x的第31 - N个bit。
函数描述
把无符号整数x中的32个bit反转。
__device__ unsigned long long int __brevll (unsigned long long int x)
把一个64位无符号整数中的64个bit顺序反转。
返回值
返回bit反转之后的x的值，比如返回值的第N个bit对应x的第63 - N个bit。
函数描述
把64位无符号整数x中的64个bit反转。
__device__ unsigned int __byte_perm (unsigned int x, unsigned int y, unsigned int s)
从两个32位无符号整数中返回选择的字节。
返回值
返回值这样计算：
result[n] := input[selector[n]]这里的result[n]是r的第n个字节。
函数描述
byte_perm(x,y,s)返回一个32位的整数，这个整数由8个输入的字节（整数x，y）中提供4个字节组成，由选择器 s 选择这4个字节。
输入的字节这样索引： input[0] = x<7:0> input[1] = x<15:8> input[2] = x<23:16> input[3] = x<31:24> input[4] = y<7:0> input[5] = y<15:8> input[6] = y<23:16> input[7] = y<31:24> 。选择器按照下面的方式组成（选择器的高16-bit是不会用到的）： selector[0] = s<2:0> selector[1] = s<6:4> selector[2] = s<10:8> selector[3] = s<14:12>
__device__ int __clz (int x)
返回32位整数中连续的高位零位数。
返回值
返回一个介于0和32（包括0和32）之间的值，表示零位的数目。
函数描述
从x的最高有效位（位31）开始计算最前面连续零位的数量。
__device__ int __clzll (long long int x)
返回64位整数中连续的高位零位数。
返回值
返回一个介于0和64（包括0和64）之间的值，表示零位的数目。
函数描述
从x的最高有效位（位63）开始计算最前面连续零位的数量。
__device__ int __ffs (int x)
查找32位整数中设置为1的最低有效位的位置。
返回值
返回一个介于0和32（含0和32）之间的值，表示第一个设置为1的位的位置。
__ffs(0)返回0。
函数描述
查找x中设置为1的第一个最低有效位的位置。
__device__ int __ffsll (long long int x)
查找64位整数中设置为1的最低有效位的位置。
返回值
返回一个介于0和64（含0和64）之间的值，表示第一个设置为1的位的位置。
__ffsll(0)返回0。
函数描述
查找x中设置为1的第一个（最低有效）位的位置。
__device__ unsigned int __funnelshift_l (unsigned int lo, unsigned int hi,
unsigned int shift)
连接 hi : lo ，左移 shift & 31 位，返回最高的32位。
返回值
返回移位后的64位值的最高的32位的值。
函数描述
将参数lo和hi连接形成的64位值向左偏移参数shift指定的量。参数lo保存64位源值的位31:0，参数hi保存64位源值的位63:32。源64位值左移
shift & 31位。返回结果的最高有效32位。
__device__ unsigned int __funnelshift_lc (unsigned int lo, unsigned int hi,
unsigned int shift)
连接 hi : lo ，左移 min(shift, 32) 位，返回最高的32位。
返回值
返回移位后的64位值的最高的32位的值。
函数描述
将参数lo和hi串联形成的64位值向左偏移参数shift指定的量。参数lo保存64位源值的位31:0，参数hi保存64位源值的位63:32。源64位值左移
min(shift, 32)位。返回结果的最高有效32位。
__device__ unsigned int __funnelshift_r (unsigned int lo, unsigned int hi,
unsigned int shift)
连接 hi : lo ，右移 shift & 31 位，返回最低的32位。
返回值
返回移位后的64位值的最高的32位的值。
函数描述
将参数lo和hi连接形成的64位值向左偏移参数shift指定的量。参数lo保存64位源值的位31:0，参数hi保存64位源值的位63:32。源64位值右移
shift & 31位。返回结果的最低有效32位。
__device__ unsigned int __funnelshift_rc (unsigned int lo, unsigned int hi,
unsigned int shift)
连接 hi : lo ，右移 min(shift, 32) 位，返回最低的32位。
返回值
返回移位后的64位值的最高的32位的值。
函数描述
将参数lo和hi连接形成的64位值向左偏移参数shift指定的量。参数lo保存64位源值的位31:0，参数hi保存64位源值的位63:32。源64位值右移
min(shift, 32)位。返回结果的最低有效32位。
__device__ int __hadd (int, int)
计算有符号输入参数的平均值，避免在加法中间结果中出现溢出。
返回值
返回一个表示这两个输入的有符号平均值的有符号整数。
函数描述
用
(x + y) >> 1计算有符号整数输入的参数x和y的平均值，避免在加法中间结果中出现溢出。
__device__ int __mul24 (int x, int y)
计算两个整数最低有效24位乘积的最低有效32位。
返回值
返回乘积x*y的最低有效32位。
函数描述
计算x和y的最低有效24位的乘积的最低有效32位。忽略x和y的高阶8位。
__device__ long long int __mul64hi (long long int x, long long int y)
计算两个64位整数乘积的最高有效64位。
返回值
返回乘积x*y的最高有效64位。
函数描述
计算128位乘积x*y的最高有效64位，其中x和y是64位整数。
__device__ int __mulhi (int x, int y)
计算两个32位整数乘积的最高有效32位。
返回值
返回乘积x*y的最高有效32位。
函数描述
计算64位乘积x*y的最高有效32位，其中x和y是32位整数。
__device__ int __popc (unsigned int x)
计算32位整数中设置为1的位数。
返回值
返回一个介于0和32（含0和32）之间的值，表示设置位的数目。
函数描述
计算x中设置为1的位数。
__device__ int __popcll (unsigned long long int x)
计算64位整数中设置为1的位数。
返回值
返回一个介于0和64（含0和64）之间的值，表示设置位的数目。
函数描述
计算x中设置为1的位数。
__device__ int __rhadd (int, int)
计算有符号输入参数的四舍五入平均值，避免中间和溢出。
返回值
返回一个有符号整数值，表示两个输入的有符号四舍五入平均值。
函数描述
用
( x + y + 1 ) >> 1计算有符号输入参数x和y的平均值，避免中间和溢出。
__device__ unsigned int __sad (int x, int y, unsigned int z)
计算 |x - y| + z，绝对差之和。
返回值
返回
|x - y| + z。
函数描述
计算
|x - y| + z，一个32位的第三个参数与第一个参数x，第二个参数y的绝对值之差的和的整数。输入的x与y是32位有符号整数，z是一个32位的无符号整数。
__device__ unsigned int __uhadd (unsigned int, unsigned int)
计算无符号输入参数的平均值，避免中间和溢出。
返回值
返回一个无符号整数值，表示两个输入的无符号平均值。
函数描述
将用
(x+y)>>1计算无符号输入参数x和y的平均值，避免中间和溢出。
__device__ unsigned int __umul24 (unsigned int x, unsigned int y)
计算两个无符号整数的最低有效24位乘积的最低有效32位。
返回值
返回乘积x*y的最低有效32位。
函数描述
计算x和y的最低有效24位的乘积的最低有效32位。忽略x和y的高阶8位。
__device__ unsigned long long int __umul64hi (unsigned long long int x, unsigned long long int y)
计算两个64位无符号整数乘积的最高有效64位。
返回值
返回乘积x*y的最高有效64位。
函数描述
计算128位乘积x*y的最高有效64位，其中x和y是64位无符号整数。
__device__ unsigned int __umulhi (unsigned int x, unsigned int y)
计算两个32位无符号整数乘积的最高有效32位。
返回值
返回乘积x*y的最高有效32位。
函数描述
计算64位乘积x*y的最高有效32位，其中x和y是32位无符号整数。
__device__ unsigned int __urhadd (unsigned int, unsigned int)
计算无符号输入参数的四舍五入平均值，避免加法中间结果溢出。
返回值
返回一个无符号整数值，表示两个输入的无符号舍入平均值。
函数描述
用
(x + y) >> 1计算有符号整数输入的参数x和y的平均值，避免加法中间结果溢出。
__device__ unsigned int __usad (unsigned int x, unsigned int y, unsigned int z)
计算 |x - y| + z，绝对差之和。
返回值
返回
|x - y| + z。
函数描述
计算
|x - y| + z，一个32位的第三个参数与第一个参数x，第二个参数y的绝对值之差的和的整数。输入的x，y与z是32位的无符号整数。
1.8.21. 类型转换intrinsic
这一节描述仅在设备上支持的类型转换intrinsic函数。不需要在程序中包含任何头文件就可以使用这些函数。
__device__ float __double2float_rd (double x)
把一个double用向下舍入模式转换成一个float。
返回值
返回转换的结果。
函数描述
把双精度浮点数的值x用向下舍入模式（向负无限舍入）转换成一个单精度浮点数的值。
__device__ float __double2float_rn (double x)
把一个double用向最近偶数舍入模式转换成一个float。
返回值
返回转换的结果。
函数描述
把双精度浮点数的值x用向最近偶数舍入模式转换成一个单精度浮点数的值。
__device__ float __double2float_ru (double x)
把一个double用向上舍入模式转换成一个float。
返回值
返回转换的结果。
函数描述
把双精度浮点数的值x用向上舍入模式转换成一个单精度浮点数的值。
__device__ float __double2float_rz (double x)
把一个double用向零舍入模式转换成一个float。
返回值
返回转换的结果。
函数描述
把双精度浮点数的值x用向零舍入模式转换成一个单精度浮点数的值。
__device__ int __double2hiint (double x)
将double中的高32位重新解释为有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x中的高32位重新解释为有符号整数。
__device__ int __double2int_rd (double x)
把一个double用向下舍入模式转换成一个有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向下舍入模式转换成一个有符号整数值。
__device__ int __double2int_rn (double x)
把一个double用向最近偶数舍入模式转换成一个有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向最近偶数舍入模式转换成一个有符号整数值。
__device__ int __double2int_ru (double x)
把一个double用向上舍入模式转换成一个有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向上舍入模式转换成一个有符号整数值。
__device__ int __double2int_rz (double x)
把一个double用向零舍入模式转换成一个有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向零舍入模式转换成一个有符号整数值。
__device__ long long int __double2ll_rd (double x)
把一个double用向下舍入模式转换成一个64位有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向下舍入模式转换成一个64位有符号整数。
__device__ long long int __double2ll_rn (double x)
把一个double用向最近偶数舍入模式转换成一个64位有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向最近偶数舍入模式转换成一个64位有符号整数。
__device__ long long int __double2ll_ru (double x)
把一个double用向上舍入模式转换成一个64位有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向上舍入模式转换成一个64位有符号整数。
__device__ long long int __double2ll_rz (double x)
把一个double用向零舍入模式转换成一个64位有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向零舍入模式转换成一个64位有符号整数。
__device__ int __double2loint (double x)
将double中的低32位重新解释为有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x中的低32位重新解释为有符号整数。
__device__ unsigned int __double2uint_rd (double x)
把一个double用向下舍入模式转换成一个unsigned int。
返回值
返回转换的结果。
函数描述
将double数据x用向下舍入模式转换成一个无符号整数值。
__device__ unsigned int __double2uint_rn (double x)
把一个double用向最近偶数舍入模式转换成一个无符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向最近偶数舍入模式转换成一个无符号整数值。
__device__ unsigned int __double2uint_ru (double x)
把一个double用向上舍入模式转换成一个无符号整数。
返回值
返回转换的结果
函数描述
将double数据x用向上舍入模式转换成一个无符号整数值。
__device__ unsigned int __double2uint_rz (double x)
把一个double用向零舍入模式转换成一个无符号整数值。
返回值
返回转换的结果。
函数描述
将double数据x用向零舍入模式转换成一个无符号整数值。
__device__ unsigned long long int __double2ull_rd (double x)
把一个double用向下舍入模式转换成一个64位无符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向下舍入模式转换成一个64位无符号整数。
__device__ unsigned long long int __double2ull_rn (double x)
把一个double用向最近偶数舍入模式转换成一个64位无符号整数。
返回值
返回转换的结果。
函数描述
将double数据x用向最近偶数舍入模式转换成一个64位无符号整数。
__device__ unsigned long long int __double2ull_ru (double x)
把一个double用向上舍入模式转换成一个64位无符号整数。
返回值
返回转换的结果
函数描述
将double数据x用向上舍入模式转换成一个64位无符号整数值。
__device__ unsigned long long int __double2ull_rz (double x)
把一个double用向零舍入模式转换成一个64位无符号整数。
返回值
返回转换的结果
函数描述
将double数据x用向零模式转换成一个64位无符号整数值。
__device__ long long int __double_as_longlong(double x)
将double中的位重新解释为64位有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x中的位重新解释为64位有符号整数。
__device__ int __float2int_rd(double x)
以向下舍入模式将浮点转换为有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x以向下舍入模式将浮点转换为有符号整数。
__device__ int __float2int_rn(double x)
以向最近偶数舍入模式将浮点转换为有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x以向最近偶数舍入模式将浮点转换为有符号整数。
__device__ int __float2int_ru(double x)
以向上舍入模式将浮点转换为有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x以向上舍入模式将浮点转换为有符号整数。
__device__ int __float2int_rz(double x)
以向零舍入模式将浮点转换为有符号整数。
返回值
返回转换的结果。
函数描述
将double数据x以向零舍入模式将浮点转换为有符号整数。
__device__ long long int __float2ll_rd (float x)
以向下舍入模式将浮点转换为64位有符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向下舍入模式将浮点转换为64位有符号整数。
__device__ long long int __float2ll_rn (float x)
以向最近偶数舍入模式将浮点转换为64位有符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向最近偶数舍入模式将浮点转换为64位有符号整数。
__device__ long long int __float2ll_ru (float x)
以向上舍入模式将浮点转换为64位有符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向上舍入模式将浮点转换为64位有符号整数。
__device__ long long int __float2ll_rz (float x)
以向零舍入模式将浮点转换为64位有符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向零舍入模式将浮点转换为64位有符号整数。
__device__ unsigned int __float2uint_rd (float x)
以向下舍入模式将浮点转换为无符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向下舍入模式将浮点转换为无符号整数。
__device__ unsigned int __float2uint_rn (float x)
以向最近偶数舍入模式将浮点转换为无符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向最近偶数舍入模式将浮点转换为无符号整数。
__device__ unsigned int __float2uint_ru (float x)
以向上舍入模式将浮点转换为无符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向上舍入模式将浮点转换为无符号整数。
__device__ unsigned int __float2uint_rz (float x)
以向零舍入模式将浮点转换为无符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向零舍入模式将浮点转换为无符号整数。
__device__ unsigned long long int __float2ull_rd (float x)
以向下舍入模式将浮点转换为64位无符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向下舍入模式将浮点转换为64位无符号整数。
__device__ unsigned long long int __float2ull_rn (float x)
以向最近偶数舍入模式将浮点转换为64位无符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向最近偶数舍入模式将浮点转换为64位无符号整数。
__device__ unsigned long long int __float2ull_ru (float x)
以向上舍入模式将浮点转换为64位无符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向上舍入模式将浮点转换为64位无符号整数。
__device__ unsigned long long int __float2ull_rz (float x)
以向零舍入模式将浮点转换为64位无符号整数。
返回值
返回转换的结果。
函数描述
将float数据x以向零舍入模式将浮点转换为64位无符号整数。
__device__ int __float_as_int (float x)
将浮点中的位重新解释为有符号整数。
返回值
返回转换的结果。
函数描述
将float数据x中的位重新解释为有符号整数。
__device__ unsigned int __float_as_uint (float x)
将浮点中的位重新解释为无符号整数。
返回值
返回转换的结果。
函数描述
将float数据x中的位重新解释为无符号整数。
__device__ double __hiloint2double (int hi, int lo)
将高和低32位整数值重新解释为双精度浮点数。
返回值
返回转换的结果。
函数描述
将hi的整数值重新解释为双精度浮点值的高32位，将lo的整数值重新解释为相同双精度浮点值的低32位。
__device__ double __int2double_rn (int x)
把一个有符号整数转换成双精度浮点数。
返回值
返回转换的结果。
函数描述
把有符号整数x转换成一个双精度浮点数的值。
__device__ float __int2float_rd (int x)
把一个有符号整数用向下舍入模式转换成单精度浮点数。
返回值
返回转换的结果。
函数描述
把有符号整数x用向下舍入模式转换成一个单精度浮点数的值。
__device__ float __int2float_rn (int x)
把一个有符号整数用向最近偶数舍入模式转换成单精度浮点数。
返回值
返回转换的结果。
函数描述
把有符号整数x用向最近偶数舍入模式转换成一个单精度浮点数的值。
__device__ float __int2float_ru (int x)
把一个有符号整数用向上舍入模式转换成单精度浮点数。
返回值
返回转换的结果。
函数描述
把有符号整数x用向上舍入模式转换成一个单精度浮点数的值。
__device__ float __int2float_rz (int x)
把一个有符号整数用向零舍入模式转换成单精度浮点数。
返回值
返回转换的结果。
函数描述
把有符号整数x用向零舍入模式转换成一个单精度浮点数的值。
__device__ float __int_as_float (int x)
将整数中的位重新解释为浮点数。
返回值
返回转换的结果。
函数描述
把有符号整数x中的位重新解释为浮点数。
__device__ double __ll2double_rd (long long int x)
把一个64位有符号整数用向下舍入模式转换成一个双精度浮点数。
返回值
返回转换的结果。
函数描述
把64位有符号整数x用向下舍入模式转换成一个双精度浮点数。
__device__ double __ll2double_rn (long long int x)
把一个64位有符号整数用向最近偶数舍入模式转换成一个双精度浮点数。
返回值
返回转换的结果。
函数描述
把64位有符号整数x用向最近偶数舍入模式转换成一个双精度浮点数。
__device__ double __ll2double_ru (long long int x)
把一个64位有符号整数用向上舍入模式转换成一个双精度浮点数。
返回值
返回转换的结果。
函数描述
把64位有符号整数x用向上舍入模式转换成一个双精度浮点数。
__device__ double __ll2double_rz (long long int x)
把一个64位有符号整数用向零舍入模式转换成一个双精度浮点数。
返回值
返回转换的结果。
函数描述
把64位有符号整数x用向零舍入模式转换成一个双精度浮点数。
__device__ float __ll2float_rd (long long int x)
把一个64位有符号整数用向下舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把64位有符号整数x用向下舍入模式转换成一个单精度浮点数。
__device__ float __ll2float_rn (long long int x)
把一个64位有符号整数用 向最近偶数舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把64位有符号整数x用 向最近偶数舍入模式转换成一个单精度浮点数。
__device__ float __ll2float_ru (long long int x)
把一个64位有符号整数用向上舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把64位有符号整数x用向上舍入模式转换成一个单精度浮点数。
__device__ float __ll2float_rz (long long int x)
把一个64位有符号整数用向零舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把64位有符号整数x用向零舍入模式转换成一个单精度浮点数。
__device__ double __longlong_as_double (long long int x)
将64位有符号整数中的位重新解释为双精度浮点数。
返回值
返回转换的结果。
函数描述
把64位有符号整数x中的位重新解释为双精度浮点数。
__device__ double __uint2double_rn (unsigned int x)
把一个无符号整数转换成一个双精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x转换成一个双精度浮点数。
__device__ float __uint2float_rd (unsigned int x)
把一个无符号整数用向下舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向下舍入模式转换成一个单精度浮点数。
__device__ float __uint2float_rn (unsigned int x)
把一个无符号整数用向最近偶数舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向最近偶数舍入模式转换成一个单精度浮点数。
__device__ float __uint2float_ru (unsigned int x)
把一个无符号整数用向上舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向上舍入模式转换成一个单精度浮点数。
__device__ float __uint2float_rz (unsigned int x)
把一个无符号整数用向零舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向零舍入模式转换成一个单精度浮点数。
__device__ float __uint_as_float (unsigned int x)
将无符号整数中的位重新解释为浮点。
返回值
返回转换的结果。
函数描述
把无符号整数x中的位重新解释为浮点。
__device__ double __ull2double_rd (unsigned long long int x)
把一个64位无符号整数用向下舍入模式转换成一个双精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向下舍入模式转换成一个双精度浮点数。
__device__ double __ull2double_rn (unsigned long long int x)
把一个64位无符号整数用向最近偶数舍入模式转换成一个双精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向最近偶数舍入模式转换成一个双精度浮点数。
__device__ double __ull2double_ru (unsigned long long int x)
把一个64位无符号整数用向上舍入模式转换成一个双精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向上舍入模式转换成一个双精度浮点数。
__device__ double __ull2double_rz (unsigned long long int x)
把一个64位无符号整数用向零舍入模式转换成一个双精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向零舍入模式转换成一个双精度浮点数。
__device__ float __ull2float_rd (unsigned long long int x)
把一个64位无符号整数用向下舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向下舍入模式转换成一个单精度浮点数。
__device__ float __ull2float_rn (unsigned long long int x)
把一个64位无符号整数用向最近偶数舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向最近偶数舍入模式转换成一个单精度浮点数。
__device__ float __ull2float_ru (unsigned long long int x)
把一个64位无符号整数用向上舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向上舍入模式转换成一个单精度浮点数。
__device__ float __ull2float_rz (unsigned long long int x)
把一个64位无符号整数用向零舍入模式转换成一个单精度浮点数。
返回值
返回转换的结果。
函数描述
把无符号整数x用向零舍入模式转换成一个单精度浮点数。
1.8.22. SIMD intrinsic
__device__ unsigned int __vabs2 (unsigned int a)
计算每半字的绝对值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成，然后每个部分计算绝对值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vabs4 (unsigned int a)
计算每字节的绝对值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，然后每个部分（字节）计算绝对值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vabsdiffs2 (unsigned int a, unsigned int b)
计算每半字绝对值差。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，函数计算绝对值的差。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vabsdiffs4 (unsigned int a, unsigned int b)
计算每字节的绝对值差。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，函数计算绝对值的差。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vabsdiffu2 (unsigned int a, unsigned int b)
计算每半字无符号整数差的绝对值：|a - b|。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，函数计算差的绝对值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vabsdiffu4 (unsigned int a, unsigned int b)
计算每字节的绝对值差。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，函数计算差的绝对值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vabsss2 (unsigned int a)
计算每半字有符号饱和值的绝对值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，函数计算有符号饱和值的绝对值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vabsss4 (unsigned int a)
计算每字节有符号饱和值的绝对值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，函数计算有符号饱和值的绝对值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vadd2 (unsigned int a, unsigned int b)
计算每半字无符号的和：a + b。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，函数计算无符号加法的结果。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vabsss4 (unsigned int a, unsigned int b)
计算每字节无符号的和：a + b。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，函数计算无符号加法的结果。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vaddss2 (unsigned int a, unsigned int b)
计算每半字有符号和的饱和值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，函数计算有符号和的饱和值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vaddss4 (unsigned int a, unsigned int b)
计算每字节有符号和的饱和值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，函数计算有符号和的饱和值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vaddus2 (unsigned int a, unsigned int b)
计算每半字无符号和的饱和值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，函数计算无符号和的饱和值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vaddus4 (unsigned int a, unsigned int b)
计算每字节无符号和的饱和值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，函数计算无符号和的饱和值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vavgs2 (unsigned int a, unsigned int b)
计算每半字有符号四舍五入平均值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，函数计有符号平均值，结果四舍五入。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vavgs4 (unsigned int a, unsigned int b)
计算每字节有符号四舍五入平均值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，函数计有符号平均值，结果四舍五入。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vavgu2 (unsigned int a, unsigned int b)
计算每半字无符号四舍五入平均值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，函数计无符号平均值，结果四舍五入。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vavgu4 (unsigned int a, unsigned int b)
计算每字节无符号四舍五入平均值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，函数计无符号平均值，结果四舍五入。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vcmpeq2 (unsigned int a, unsigned int b)
计算每半字比较。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果它们相等，局部结果为
0xffff；否则为0x0000。比如__vcmpeq2(0x1234aba5, 0x1234aba6)返回0xffff0000。
__device__ unsigned int __vcmpeq4 (unsigned int a, unsigned int b)
计算每字节比较。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果它们相等，局部结果为
0xff；否则为0x00。比如__vcmpeq4(0x1234aba5, 0x1234aba6)返回0xffffff00。
__device__ unsigned int __vcmpges2 (unsigned int a, unsigned int b)
计算每半字有符号比较： a >= b ? 0xffff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果
part_a >= part_b，局部结果为0xffff；否则为0x0000。比如__vcmpges2(0x1234aba5, 0x1234aba6)返回0xffff0000。
__device__ unsigned int __vcmpges4 (unsigned int a, unsigned int b)
计算每字节有符号比较： a >= b ? 0xff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果
part_a >= part_b，局部结果为0xff；否则为0x00。比如__vcmpges4(0x1234aba5, 0x1234aba6)返回0xffffff00。
__device__ unsigned int __vcmpgeu2 (unsigned int a, unsigned int b)
计算每半字无符号比较： a >= b ? 0xffff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果
part_a >= part_b，局部结果为0xffff；否则为0x0000。比如__vcmpgeu2(0x1234aba5, 0x1234aba6)返回0xffff0000。
__device__ unsigned int __vcmpgeu4 (unsigned int a, unsigned int b)
计算每字节无符号比较： a >= b ? 0xff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果
part_a >= part_b，局部结果为0xff；否则为0x00。比如__vcmpgeu4(0x1234aba5, 0x1234aba6)返回0xffffff00。
__device__ unsigned int __vcmpgts2 (unsigned int a, unsigned int b)
计算每半字有符号比较： a > b ? 0xffff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果
part_a >= part_b，局部结果为0xffff；否则为0x0000。比如__vcmpgts2(0x1234aba5, 0x1234aba6)返回0x00000000。
__device__ unsigned int __vcmpgts4 (unsigned int a, unsigned int b)
计算每字节有符号比较： a > b ? 0xff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果
part_a >= part_b，局部结果为0xff；否则为0x00。比如__vcmpgts4(0x1234aba5, 0x1234aba6)返回0x00000000。
__device__ unsigned int __vcmpgtu2 (unsigned int a, unsigned int b)
计算每半字无符号比较： a > b ? 0xffff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果
part_a >= part_b，局部结果为0xffff；否则为0x0000。比如__vcmpgtu2(0x1234aba5, 0x1234aba6)返回0x00000000。
__device__ unsigned int __vcmpgtu4 (unsigned int a, unsigned int b)
计算每字节无符号比较： a > b ? 0xff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果
part_a >= part_b，局部结果为0xff；否则为0x00。比如__vcmpgtu4(0x1234aba5, 0x1234aba6)返回0x00000000。
__device__ unsigned int __vcmples2 (unsigned int a, unsigned int b)
计算每半字有符号比较： a <= b ? 0xffff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果
part_a <= part_b，局部结果为0xffff；否则为0x0000。比如__vcmples2(0x1234aba5, 0x1234aba6)返回0xffffffff。
__device__ unsigned int __vcmples4 (unsigned int a, unsigned int b)
计算每字节有符号比较： a <= b ? 0xff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果
part_a <= part_b，局部结果为0xff；否则为0x00。比如__vcmples4(0x1234aba5, 0x1234aba6)返回0xffffffff。
__device__ unsigned int __vcmpleu2 (unsigned int a, unsigned int b)
计算每半字无符号比较： a <= b ? 0xffff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果
part_a <= part_b，局部结果为0xffff；否则为0x0000。比如__vcmpleu2(0x1234aba5, 0x1234aba6)返回0xffffffff。
__device__ unsigned int __vcmpleu4 (unsigned int a, unsigned int b)
计算每字节无符号比较： a <= b ? 0xff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果
part_a <= part_b，局部结果为0xff；否则为0x00。比如__vcmpleu4(0x1234aba5, 0x1234aba6)返回0xffffffff。
__device__ unsigned int __vcmplts2 (unsigned int a, unsigned int b)
计算每半字有符号比较： a < b ? 0xffff : 0
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果
part_a < part_b，局部结果为0xffff；否则为0x0000。比如__vcmplts2(0x1234aba5, 0x1234aba6)返回0x0000ffff。
__device__ unsigned int __vcmplts4 (unsigned int a, unsigned int b)
计算每字节有符号比较： a < b ? 0xff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果
part_a < part_b，局部结果为0xff；否则为0x00。比如__vcmplts4(0x1234aba5, 0x1234aba6)返回0x000000ff。
__device__ unsigned int __vcmpltu2 (unsigned int a, unsigned int b)
计算每半字无符号比较： a < b ? 0xffff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果
part_a < part_b，局部结果为0xffff；否则为0x0000。比如__vcmpltu2(0x1234aba5, 0x1234aba6)返回0x0000ffff。
__device__ unsigned int __vcmpltu4 (unsigned int a, unsigned int b)
计算每字节无符号比较： a < b ? 0xff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果
part_a < part_b，局部结果为0xff；否则为0x00。比如__vcmpltu4(0x1234aba5, 0x1234aba6)返回0x000000ff。
__device__ unsigned int __vcmpne2 (unsigned int a, unsigned int b)
计算每半字比较： a != b ? 0xffff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，如果
part_a != part_b，局部结果为0xffff；否则为0x0000。比如__vcmpeq2(0x1234aba5, 0x1234aba6)返回0x0000ffff。
__device__ unsigned int __vcmpne4 (unsigned int a, unsigned int b)
计算每字节比较: a != b ? 0xff : 0。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，如果
part_a != part_b，局部结果为0xff；否则为0x00。比如__vcmpeq4(0x1234aba5, 0x1234aba6)返回0x000000ff。
__device__ unsigned int __vhaddu2 (unsigned int a, unsigned int b)
计算每半字无符号平均值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，计算无符号平均值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vhaddu4 (unsigned int a, unsigned int b)
计算每字节无符号平均值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，计算无符号平均值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vmaxs2 (unsigned int a, unsigned int b)
计算每半字有符号最大值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，计算有符号最大值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vmaxs4 (unsigned int a, unsigned int b)
计算每字节有符号最大值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，计算有符号最大值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vmaxu2 (unsigned int a, unsigned int b)
计算每半字无符号最大值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，计算无符号最大值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vmaxu4 (unsigned int a, unsigned int b)
计算每字节无符号最大值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，计算无符号最大值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vmins2 (unsigned int a, unsigned int b)
计算每半字有符号最小值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，计算有符号最小值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vmins4 (unsigned int a, unsigned int b)
计算每字节有符号最小值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，计算有符号最小值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vminu2 (unsigned int a, unsigned int b)
计算每半字无符号最小值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，计算无符号最小值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vminu4 (unsigned int a, unsigned int b)
计算每字节无符号最大值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，计算无符号最小值。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vneg2 (unsigned int a)
计算每半字的相反数。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成，然后每个部分计算相反数。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vneg4 (unsigned int a)
计算每字节的相反数。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，然后每个部分（字节）计算相反数。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vnegss2 (unsigned int a)
计算每半字有符号相反数的饱和值。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成，然后每个部分计算有符号相反数的饱和值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vnegss4 (unsigned int a)
计算每字节有符号相反数的饱和值。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，然后每个部分（字节）计算有符号相反数的饱和值。局部结果重新组装成最后的结果，然后以
unsigned int返回计算结果。
__device__ unsigned int __vsads2 (unsigned int a, unsigned int b)
计算每半字有符号差值的绝对值的和。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，计算有符号差值的绝对值，然后求和。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vsads4 (unsigned int a, unsigned int b)
计算每字节有符号差值的绝对值的和。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，计算有符号差值的绝对值，然后求和。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vsadu2 (unsigned int a, unsigned int b)
计算每半字无符号差值的绝对值的和。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，计算有符号差值的绝对值，然后求和。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vsadu4 (unsigned int a, unsigned int b)
计算每字节无符号差值的绝对值的和。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，计算有符号差值的绝对值，然后求和。局部结果组合成最终结果，并以
unsigned int返回。
__device__ unsigned int __vseteq2 (unsigned int a, unsigned int b)
计算每半字比较。
返回值
如果a = b, 返回1否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a == part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vseteq4 (unsigned int a, unsigned int b)
计算每字节比较。
返回值
如果a = b, 返回1否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a == part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetges2 (unsigned int a, unsigned int b)
计算每半字有符号比较。
返回值
如果a >= b, 返回1；否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a >= part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetges4 (unsigned int a, unsigned int b)
计算每字节有符号比较。
返回值
如果a >= b, 返回1；否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a >= part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetgeu2 (unsigned int a, unsigned int b)
计算每半字无符号比较。
返回值
如果a >= b, 返回1；否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a >= part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetgeu4 (unsigned int a, unsigned int b)
计算每字节无符号比较。
返回值
如果a >= b, 返回1；否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a >= part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetgts2 (unsigned int a, unsigned int b)
计算每半字有符号比较。
返回值
如果a > b, 返回1；否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a > part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetgts4 (unsigned int a, unsigned int b)
计算每字节有符号比较。
返回值
如果a > b, 返回1；否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a > part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetgtu2 (unsigned int a, unsigned int b)
计算每半字无符号比较。
返回值
如果a > b, 返回1；否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a > part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetgtu4 (unsigned int a, unsigned int b)
计算每字节无符号比较。
返回值
如果a > b, 返回1；否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a > part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetles2 (unsigned int a, unsigned int b)
计算每半字有符号比较。
返回值
如果a <= b, 返回1；否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a <= part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetles4 (unsigned int a, unsigned int b)
计算每字节有符号比较。
返回值
如果a <= b, 返回1；否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a <= part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetleu2 (unsigned int a, unsigned int b)
计算每半字无符号比较。
返回值
如果a <= b, 返回1；否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a <= part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetleu4 (unsigned int a, unsigned int b)
计算每字节无符号比较。
返回值
如果a <= b, 返回1；否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a <= part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetlts2 (unsigned int a, unsigned int b)
计算每半字有符号比较。
返回值
如果a < b, 返回1；否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a < part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetlts4 (unsigned int a, unsigned int b)
计算每字节有符号比较。
返回值
如果a < b, 返回1；否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a < part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetltu2 (unsigned int a, unsigned int b)
计算每半字无符号比较。
返回值
如果a < b, 返回1；否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a < part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetltu4 (unsigned int a, unsigned int b)
计算每字节无符号比较。
返回值
如果a < b, 返回1；否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a < part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetne2 (unsigned int a, unsigned int b)
计算每半字无符号比较。
返回值
如果a != b, 返回1；否则返回0。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，判断part_a != part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsetne4 (unsigned int a, unsigned int b)
计算每字节无符号比较。
返回值
如果a != b, 返回1；否则返回0。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，判断part_a != part_b，如果每个部分都满足，返回1。
__device__ unsigned int __vsub2 (unsigned int a, unsigned int b)
计算每半字减法。
返回值
返回计算结果。
函数描述
把4字节参数分离成2个部分，每个部分有2个字节组成。对每个对应的部分，做减法操作，局部结果最后组成最终结果并以
unsigned int返回。
__device__ unsigned int __vsub4 (unsigned int a, unsigned int b)
计算每字节减法。
返回值
返回计算结果。
函数描述
把4字节参数分离成4个部分，每个部分1个字节组成。对每个对应的部分，做减法操作，局部结果最后组成最终结果并以
unsigned int返回。
__device__ unsigned int __vsubss2 (unsigned int a, unsigned int b)
计算每半字的无符号或有符号减法，取无符号整数范围内饱和值。
返回值
返回计算结果。
函数描述
把4字节参数分成2个部分，每部分由2个字节组成。对每个对应的部分，做有符号饱和减法，每部分的结果组成最终结果以
unsigned int返回。
__device__ unsigned int __vsubss4 (unsigned int a, unsigned int b)
计算有符号的每字节饱和减法。
返回值
返回计算结果。
函数描述
把4字节参数分成4个部分，每部分由1个字节组成。对每个对应的部分，做有符号饱和减法，每部分的结果组成最终结果以
unsigned int返回。
__device__ unsigned int __vsubus2 (unsigned int a, unsigned int b)
计算无符号的每半字饱和减法。
返回值
返回计算结果。
函数描述
把4字节参数分成2个部分，每部分由2个字节组成。对每个对应的部分，做无符号饱和减法，每部分的结果组成最终结果以
unsigned int返回。
__device__ unsigned int __vsubus4 (unsigned int a, unsigned int b)
计算无符号的每字节饱和减法。
返回值
返回计算结果。
函数描述
把4字节参数分成4个部分，每部分由1个字节组成。对每个对应的部分，做无符号饱和减法，每部分的结果组成最终结果以
unsigned int返回。
1.9. Texture函数
1.9.1. Texture Object API
1.9.1.1. tex1Dfetch()
template<class T>
T tex1Dfetch(mcTextureObject_t texObj, int x);
参数
texObj
mcTextureObject_t，一维texture object对象
x
int，整型texture 坐标，必须是非归一化整数型值。
返回值
T，T的可取范围为char, unsigned char, short, unsigned short, int, unsigned int, float及其int1，int2，int4向量类型。
函数描述
从使用线性空间创建的一维texture object中获取整数型texture坐标x所在位置的元素值。坐标x必须是非归一化坐标，且只支持border和clamp两种寻址模式，不支持texture filter操作，对于8bit或者16bit整数型，可以将输出数据提升成单精度浮点型输出。
1.9.1.2. tex1D()
template<class T>
T tex1D(mcTextureObject_t texObj, float x);
参数
texObj
mcTextureObject_t，一维texture object对象
x
float, 浮点texture坐标，可以是归一化坐标(-1.0~1.0)或者(0~1.0),也可以是非归一化浮点坐标。
返回值
T，T的可取范围为char, unsigned char, short, unsigned short, int, unsigned int, float及其int1，int2，int4向量类型。
函数描述
从使用MXMACA数组创建的一维texture object中，获取浮点texture坐标x所在位置的元素值。
1.9.2. Texture Reference API
1.9.2.1. tex1Dfetch()
template <class DataType>
Type tex1Dfetch(texture<DataType, mcTextureType1D, mcReadModeElementType> texRef,
int x);
参数
texRef
texture<DataType, mcTextureType1D, mcReadModeElementType>，一维texture reference，DataType的可取范围为char, unsigned char, short, unsigned short, int, unsigned int, float及其int1，int2，int4向量类型。
x
int，整型texture 坐标，必须是非归一化整数型值。
返回值
Type，Type的可取范围为char, unsigned char, short, unsigned short, int, unsigned int, float及其int1，int2，int4向量类型，与模板类型DateType一致。
template <class DataType>
Type tex1Dfetch(texture<DataType, mcTextureType1D, mcReadModeNormalizedFloat> texRef,
int x);
参数
texRef
texture<DataType, mcTextureType1D, mcReadModeElementType>，一维texture reference，DataType的可取范围为char, unsigned char, short, unsigned short, int, unsigned int, float及其int1，int2，int4向量类型。
x
int，整型texture 坐标，可以是归一化坐标(-1.0~1.0)或者(0~1.0)，也可以是非归一化浮点坐标。
返回值
Type，Type的可取范围为 float及其int1，int2，int4向量类型。
函数描述
从使用线性空间创建的一维texture reference中，获取整数型texture坐标x所在位置的元素值。坐标x必须是非归一化坐标，且只支持border和clamp两种寻址模式，不支持texture filter操作，对于8bit或者16bit整数型，可以将输出数据提升成单精度浮点型输出。
1.9.2.2. tex1D()
template<class DataType > Type
tex1D(texture<DataType, mcTextureType1D, mcReadModeElementType> texRef, float x)
参数
texRef
texture<DataType, mcTextureType1D, mcReadModeElementType>，一维texture reference，DataType的可取范围为char, unsigned char, short, unsigned short, int, unsigned int, float及其int1，int2，int4向量类型。
x
float，浮点texture 坐标
返回值
Type，Type的可取范围为char, unsigned char, short, unsigned short, int, unsigned int, float及其int1，int2，int4向量类型，与模板类型DateType一致。
template<class DataType > Type
tex1D(texture<DataType, mcTextureType1D, mcReadModeNormalizedFloat> texRef, float x)
参数
texRef
texture<DataType, mcTextureType1D, mcReadModeElementType>，一维texture reference，DataType的可取范围为char, unsigned char, short, unsigned short, int, unsigned int, float及其int1，int2，int4向量类型
x
float，浮点texture坐标
返回值
Type，Type的可取范围为 float及其int1，int2，int4向量类型。
函数描述
从使用MXMACA数组创建的一维texture reference中，获取浮点texture坐标x所在位置的元素值。
1.10. 只读数据缓存区加载函数
T __ldg(const T* address);
函数返回数据类型T在地址address的数据，这里的数据类型T可以是char、signed char、short、int、long、long long unsigned char、unsigned short、unsigned int、unsigned long、unsigned long long、char2、char4、short2、short4、int2、int4、longlong2 uchar2、uchar4、ushort2、ushort4、uint2、uint4、ulonglong2 float、float2、float4、double或者double2。当包含头文件maca_fp16.h时，数据类型T也可以是__half或者__half2。同样的，当包含头文件maca_bfloat16.h时，数据类型T也可以是maca_bfloat16或者maca_bfloat162。该操作的数据被缓存在只读数据缓存区域。
1.11. 使用缓存提示的加载函数
T __ldcg(const T* address);
T __ldca(const T* address);
T __ldcs(const T* address);
T __ldlu(const T* address);
T __ldcv(const T* address);
这些函数返回数据类型T在地址address的数据，这里的数据类型T可以是char、signed char、short、int、long、long long unsigned char、unsigned short、unsigned int、unsigned long、unsigned long long、char2、char4、short2、short4、int2、int4、longlong2 uchar2、uchar4、ushort2、ushort4、uint2、uint4、ulonglong2 float、float2、float4、double或者double2。当包含头文件maca_fp16.h时，数据类型T也可以是__half或者__half2。同样的，当包含头文件maca_bfloat16.h时，数据类型T也可以是maca_bfloat16或者maca_bfloat162。这些操作使用各自对应的缓存方式。
1.12. 使用缓存提示的存储函数
void __stwb(T* address, T value);
void __stcg(T* address, T value);
void __stcs(T* address, T value);
void __stwt(T* address, T value);
这些函数在地址address上存储数据类型为T的数据value，这里的数据类型T可以是char、signed char、short、int、long、long long、unsigned char、unsigned short、unsigned int、unsigned long、unsigned long long、char2、char4、short2、short4、int2、int4、longlong2、uchar2、uchar4、ushort2、ushort4、uint2、uint4、ulonglong2、float、float2、float4、double或者double2。当包含头文件maca_fp16.h时，数据类型T也可以是__half或者__half2。同样的，当包含头文件maca_bfloat16.h时，数据类型T也可以是maca_bfloat16或者maca_bfloat162。这些操作使用各自对应的缓存方式。
1.13. 时间函数
clock_t clock();
long long int clock64();
当在执行device代码的时候，返回每个多处理器计数器的值，该值在每个时钟周期递增。在kernel开始以及结束的时候对这个计数器取样，取两次样本的差值，并且记录每个线程为每个线程提供设备为完全执行线程所需的时钟周期数的度量的结果，但是不是device确切的消耗在执行这些指令上的时钟周期数。前一个数字比后一个数字大，因为线程时间是切片的。
1.14. Atomic函数
Atomic函数是对global或shared的内存空间执行“读-改-写”的原子操作。例如， atomicAdd() 从global或者shared的内存空间的某个地址读取一个字，对该字加1后将结果写回到相同的地址上。
该操作是原子的，它保证该操作可以在不受其他线程干扰的情况下执行（在操作完成之前，没有其他线程可以访问该地址）。
Atomic函数与memory fence不同，其不具有同步或者其他约束内存操作顺序的行为（参考 1.6 Memory Fence函数 以了解更多）。Atomic函数仅可被用于设备侧函数中。
Atomic函数的原子范围：
system范围原子：当前程序中所有MXMACA线程具备原子性，包括系统中的其他CPU和GPU。这些函数使用“_system”做为后缀，例如 atomicAdd_system。
device范围原子：与当前线程处于同一个device的所有MXMACA线程具备原子性。这些函数没有扩展后缀，例如atomicAdd。
block范围原子：与当前线程处于同一个block的所有MXMACA线程具备原子性。这些函数使用“_block”做为后缀，例如atomicAdd_block。
下例中，使用“atomicAdd_system”函数更新了地址addr的值：
__global__ void mykernel(int *addr) {
atomicAdd_system(addr, 10);
}
备注
大多数的原子操作均可通过“atomicCAS”函数实现。
1.14.1. 算术函数
1.14.1.1. atomicAdd()
int atomicAdd(int* address, int val);
unsigned int atomicAdd(unsigned int* address, unsigned int val);
unsigned long long int atomicAdd(unsigned long long int* address,
unsigned long long int val);
float atomicAdd(float* address, float val);
double atomicAdd(double* address, double val);
__half2 atomicAdd(__half2 *address, __half2 val);
__half atomicAdd(__half *address, __half val);
maca_bfloat162 atomicAdd(maca_bfloat162 *address, maca_bfloat162 val);
maca_bfloat16 atomicAdd(maca_bfloat16 *address, maca_bfloat16 val);
atomicAdd函数读取global或者shared内存（address）的原始数据（old），计算“old + val”后将结果写回address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.1.2. atomicSub()
int atomicSub(int* address, int val);
unsigned int atomicSub(unsigned int* address, unsigned int val);
atomicSub函数读取global或者shared内存（address）的原始数据（old），计算“old - val”后将结果写回address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.1.3. atomicExch()
int atomicExch(int* address, int val);
unsigned int atomicExch(unsigned int* address, unsigned int val);
unsigned long long int atomicExch(unsigned long long int* address,
unsigned long long int val);
float atomicExch(float* address, float val);
atomicExch函数读取global或者shared内存（address）的原始数据（old），将val值写入address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.1.4. atomicMin()
int atomicMin(int* address, int val);
unsigned int atomicMin(unsigned int* address, unsigned int val);
unsigned long long int atomicMin(unsigned long long int* address,
unsigned long long int val);
atomicMin函数读取global或者shared内存（address）的原始数据（old），比较old和val后（记较小的值为min）将min值写入address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.1.5. atomicMax()
int atomicMax(int* address, int val);
unsigned int atomicMax(unsigned int* address, unsigned int val);
unsigned long long int atomicMax(unsigned long long int* address,
unsigned long long int val);
atomicMax函数读取global或者shared内存（address）的原始数据（old），比较old和val后（记较大的值为max）将max值写入address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.1.6. atomicInc()
unsigned int atomicInc(unsigned int* address, unsigned int val);
atomicInc函数读取global或者shared内存（address）的原始数据（old），计算算式“(old >= val) ? 0 : (old + 1)”后将结果写入address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.1.7. atomicDec()
unsigned int atomicDec(unsigned int* address, unsigned int val);
atomicDec函数读取global或者shared内存（address）的原始数据（old），计算算式“(old == 0) || (old >= val) ? 0 : (old - 1)”后将结果写入address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.1.8. atomicCAS()
int atomicCAS(int* address, int compare, int val);
unsigned int atomicCAS(unsigned int* address, unsigned int compare, unsigned int val);
unsigned long long int atomicCAS(unsigned long long int* address,
unsigned long long int compare, unsigned long long int val);
unsigned short int atomicCAS(unsigned short int *address, unsigned short int compare,
unsigned short int val);
atomicCAS函数读取global或者shared内存（address）的原始数据（old），计算算式“old == compare ? val : old”后将结果写入address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.2. 位运算函数
1.14.2.1. atomicAnd()
int atomicAnd(int* address, int val);
unsigned int atomicAnd(unsigned int* address, unsigned int val);
unsigned long long int atomicAnd(unsigned long long int* address,
unsigned long long int val);
atomicAnd函数读取global或者shared内存（address）的原始数据（old），计算算式“old & val”后将结果写入address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.2.2. atomicOr()
int atomicOr(int* address, int val);
unsigned int atomicOr(unsigned int* address, unsigned int val);
unsigned long long int atomicOr(unsigned long long int* address,
unsigned long long int val);
atomicOr函数读取global或者shared内存（address）的原始数据（old），计算算式“old | val”后将结果写入address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.14.2.3. atomicXor()
int atomicXor(int* address, int val);
unsigned int atomicXor(unsigned int* address, unsigned int val);
unsigned long long int atomicXor(unsigned long long int* address,
unsigned long long int val);
atomicXor函数读取global或者shared内存（address）的原始数据（old），计算算式“old ^ val”后将结果写入address地址中，并返回old数据。该函数保证对应的（system，device，block中的一种）原子性。
1.15. 地址空间谓词函数
在这一节中描述的函数当参数是一个空指针的时候行为未定义。
1.15.1. __isGlobal()
__device__ unsigned int __isGlobal(const void *ptr);
如果ptr包含global内存空间中对象的通用地址，则返回1；否则返回0。
1.15.3. __isLocal()
__device__ unsigned int __isLocal(const void *ptr);
如果ptr包含local内存空间中对象的通用地址，则返回1；否则返回0。
1.16. 地址空间转换函数
1.16.1. __cvta_generic_to_global()
__device__ size_t __cvta_generic_to_global(const void *ptr);
返回对通用地址指针ptr转换到global内存地址空间的地址的值。
1.16.3. __cvta_generic_to_constant()
__device__ size_t __cvta_generic_to_constant(const void *ptr);
返回对通用地址指针ptr转换到constant内存地址空间的地址的值。
1.16.4. __cvta_generic_to_local()
__device__ size_t __cvta_generic_to_local(const void *ptr);
返回对通用地址指针ptr转换到local内存地址空间的地址的值。
1.16.5. __cvta_global_to_generic()
__device__ size_t __cvta_global_to_generic(size_t rawbits);
返回对值rawbits转换所得的global内存的通用地址指针。
1.16.7. __cvta_constant_to_generic()
__device__ size_t __cvta_constant_to_generic(size_t rawbits);
返回对值rawbits转换所得的constant内存的通用地址指针。
1.16.8. __cvta_local_to_generic()
__device__ size_t __cvta_local_to_generic(size_t rawbits);
返回对值rawbits转换所得的local内存通用地址指针。
1.17. Alloca函数
1.17.1. alloca()
__host__ __device__ void * alloca(size_t size);
alloca函数的作用是在调用者的堆栈帧中分配size字节的内存，返回一个指向已分配内存的指针。当从device代码调用该函数时，内存的开头对齐为16字节。当返回alloca()的调用者时，分配的内存会自动释放。
例子：
__device__ void foo(unsigned int num) {
int *ptr = (int *)alloca(num * sizeof(int));
// use of ptr
...
}
1.18. 编译器优化提示函数
1.18.1. __builtin_assume_aligned()
void * __builtin_assume_aligned (const void *exp, size_t align)
让编译器假设参数指针至少是按照align字节对齐的，并且返回参数指针。
例子：
void *res = __builtin_assume_aligned(ptr, 32); // 编译器可以假设res是按照最少32字节对齐
三个参数的版本：
void * __builtin_assume_aligned (const void *exp, size_t align,
<integral type> offset)
让编译器假设 (char *)exp - offset 至少是按照align字节对齐的，并且返回参数指针。
例子：
void *res = __builtin_assume_aligned(ptr, 32, 8); // 编译器可以假设"(char *)res - 8"是按照最少32字节对齐的
1.18.2. __builtin_assume()
void __builtin_assume(bool exp)
让编译器假设这个布尔参数值是true。如果参数的值在运行时不是true，那么此行为不明确。
例子：
__device__ int get(int *ptr, int idx) {
__builtin_assume(idx <= 2);
return ptr[idx];
}
1.18.3. __assume()
void __assume(bool exp)
让编译器假设这个布尔参数值是true，如果在运行时这个参数的值不是true，那么该行为不明确。
例子：
__device__ int get(int *ptr, int idx) {
__assume(idx <= 2);
return ptr[idx];
}
1.18.4. __builtin_expect()
long __builtin_expect (long exp, long c)
指示编译器期望为 exp == c ，并且返回exp的值。通常用于向编译器指示分支预测信息。
例子：
// 指示编译器"var == 0"有很大可能性是对的，因此这个if代码块的body在运行时很可能会执行
if (__builtin_expect (var, 0))
doit ();
1.18.5. __builtin_unreachable()
void __builtin_unreachable(void)
指示编译器控制流从未到达调用此函数的位置。如果控制流在运行时确实达到此点，则程序行为不明确。
例子：
// 指示编译器default分支永远不会到达。
switch (in) {
case 1: return 4;
case 2: return 10;
default: __builtin_unreachable();
}
1.18.6. 限制
__assume() 函数只在host编译器使用c1.exe时才支持，其他的几个函数都是全平台支持，受以下限制：
如果host编译器支持该函数，则可以从翻译单元中的任何位置调用该函数。
否则，必须从
__device__/__global__函数体中调用该函数，或者仅在定义了__MACA_ARCH__宏时调用该函数。
1.19. Warp Vote函数
int __all_sync(unsigned mask, int predicate);
int __any_sync(unsigned mask, int predicate);
unsigned __ballot_sync(unsigned mask, int predicate);
unsigned long __activemask();
warp vote函数对一个warp里指定(unmasked)的threads执行一个reduction-and-broadcast操作。这些函数从该warp中的每一个thread都获取整数 predicate 作为输入，并将该值与0比较。比较的结果在warp的活动线程中结合（reduced），最后根据以下指定方法将返回值广播至参与的线程：
__all_sync(unsigned mask, predicate)
对于mask指定的所有的未退出的线程的 predicate 值评估，当且仅当所有的线程的 predicate 都是非零的才返回非零。
__any_sync(unsigned mask, predicate)
对于mask指定的所有的未退出的线程的 predicate 值评估，当且仅当所有的线程的 predicate 有一个非零的才返回非零。
__ballot_sync(unsigned mask, predicate)
对于mask指定的所有的未退出的线程的 predicate 值评估，返回一个第N个bit为1当且仅当warp中的第N个线程是active线程且它的 predicate 非零。
__activemask()
返回一个64位的当前warp中所有的active线程的mask的整数。当且仅当在调用 __activemask() 时warp中第N个线程是actived，则将第N个bit位置1；否则置0。已经退出程序的线程总是会被标记为inactive。注意warp线程同步于 __activemask() 调用处，但不保证后续指令的同步性，除非后续指令为warp同步函数。
约束：参数“mask”中设置为1的线程必须为active线程。
1.20. Warp Match函数
__match_any_sync 和 __match_all_sync 实现了在warp内线程之间的变量广播比较操作。
1.20.1. 提要
unsigned long __match_any_sync(unsigned long mask, T value);
unsigned long __match_all_sync(unsigned long mask, T value, int *pred);
数据类型T可以是int、unsigned int、long、unsigned long、long long、unsigned long long、float或者double。
1.20.2. 描述
__match_sync() 接口允许对value值在mask标记的线程同步后在warp中跨线程广播比较。
__match_any_sync
返回与mask线程中有相同value的线程掩码。
__match_all_sync
如果与全部mask线程具有相同的value值返回该mask；否则返回0。如果所有mask线程具有相同的value值将指示变量pred设置为true；否则设置为false。
这些带有 _sync 的match intrinsic有一个mask参数表明参与这个操作的线程。每个bit都对应着一个线程的laneID，每一个参与的线程对应的bit必须设置为1来确保它们在硬件执行内部函数之前正确聚合。所有mask标识的未退出的线程必须使用相同的mask执行相同的intrinsic，否则结果会是不确定的。
约束：mask中设置为1的线程必须为active线程。
1.21. Warp Reduce函数
__reduce_sync(unsigned mask, T value) 在mask标记的线程同步后对value数据执行一个规约操作。对于{add，min，max}操作T可以是无符号和有符号的，对于{and，or，xor}操作T仅支持无符号。
1.21.1. 提要
// add/min/max
unsigned int __reduce_add_sync(unsigned long mask, unsigned int value);
unsigned int __reduce_min_sync(unsigned long mask, unsigned int value);
unsigned int __reduce_max_sync(unsigned long mask, unsigned int value);
int __reduce_add_sync(unsigned long mask, int value);
int __reduce_min_sync(unsigned long mask, int value);
int __reduce_max_sync(unsigned long mask, int value);
// and/or/xor
unsigned int __reduce_and_sync(unsigned long mask, unsigned int value);
unsigned int __reduce_or_sync(unsigned long mask, unsigned int value);
unsigned int __reduce_xor_sync(unsigned long mask, unsigned int value);
1.21.2. 描述
__reduce_add_sync, __reduce_min_sync, __reduce_max_sync
返回在mask标记线程中对value执行算数求和、最小或者最大规约操作的结果。
__reduce_and_sync, __reduce_or_sync, __reduce_xor_sync
返回在mask标记线程中对value执行逻辑AND、OR或者XOR规约操作的结果。
mask指示了该调用中参与运算的线程。每个bit都对应着一个线程的laneID，每一个参与的线程对应的bit必须设置为1来确保它们在硬件执行内部函数之前正确聚合。所有mask标识的未退出的线程必须使用相同的mask执行相同的intrinsic，否则结果会是不确定的。
约束：mask中设置为1的线程必须为active线程。
1.22. Warp Shuffle函数
__shfl_sync 、 __shfl_up_sync 、 __shfl_down_sync 和 __shfl_xor_sync 实现在warp中的线程之间的变量相互交换。
1.22.1. 提要
T __shfl_sync(unsigned long mask, T var, int srcLane, int width=warpSize);
T __shfl_up_sync(unsigned long mask, T var, unsigned int delta, int width=warpSize);
T __shfl_down_sync(unsigned long mask, T var, unsigned int delta, int width=warpSize);
T __shfl_xor_sync(unsigned long mask, T var, int laneMask, int width=warpSize);
T可以是int、unsigned int、long、unsigned long、long long、unsigned long long、float、double、half或者half2。
1.22.2. 描述
__shfl_sync()接口允许不通过shared内存实现warp中的线程之间的变量交换。warp中所有active线程（mask指示的线程）同时进行交换，每个线程根据类型移动4个或8个字节。
warp中的thread被称为lane，可以有一个在0~warpSize-1之间的索引。支持四种源lane寻址模式：
__shfl_sync()
直接从索引的lane拷贝。
__shfl_up_sync()
从调用线程的lane索引相对减少差值之后的laneID对应的lane处拷贝。
__shfl_down_sync()
从调用线程的lane索引相对增加差值之后的laneID对应的lane处拷贝。
__shfl_xor_sync()
基于自己laneID的异或操作获得的laneID对应的lane处拷贝。
线程只能从另一个active的参与 __shfl_sync() 命令的线程处读取数据，如果目标线程是inactive的，那么检索到的值是未定义的。
所有的 __shfl_sync() intrinsic都有一个可选择添加的参数 width ,它将会改变这些intrinsic的行为。 width 的值必须是2的正整数次幂，如果不是或者比warpSize大，结果将是未定义的。
__shfl_sync() 返回 srcLane 指定ID的线程的 var 变量的值。如果width比warpSize小，那么每一个warp的子group将作为一个独立的实体，拥有一个逻辑的从0开始的laneID系统。如果 srcLane 超过了[0:width-1]，返回的结果对应的将由 srcLane mod width指定的线程的var的值决定。
__shfl_up_sync() 通过caller 线程的laneID减少 delta 来计算srcLaneID。计算出的srcLaneID对应的线程的var的值将被返回：实际上，var再warp中向上移动了 delta 个lane。如果width比warpSize小，那么每一个warp的子group将作为一个独立的实体，拥有一个逻辑的从0开始的laneID系统。srcLaneID不会环绕width改变，因此低laneID的lane的值将不会改变。
__shfl_down_sync() 通过caller 线程的laneID增加 delta 来计算srcLaneID。计算出的srcLaneID对应的线程的var的值将被返回：实际上，var再warp中向上移动了 delta 个lane。如果width比warpSize小，那么每一个warp的子group将作为一个独立的实体，拥有一个逻辑的从0开始的laneID系统。srcLaneID不会环绕width改变，因此低laneID的lane的值将不会改变。
__shfl_xor_sync() 通过caller 线程的laneID与 laneMask 做与运算来计算srcLaneID。计算出的srcLaneID对应的线程的var的值将被返回。如果width比warpSize小，每组宽度连续的线程能够访问之前线程组中的元素，但是如果它们想访问之后组的线程，它们自己的var的值会被返回。这种模式实现了一种蝴蝶寻址模式，如用于树缩减和广播的模式。
这些intrinsic有一个mask参数表明参与这个操作的线程。每个bit都对应着一个线程的laneID，每一个参与的线程对应的bit必须设置为1来确保它们在硬件执行内部函数之前正确聚合。所有mask标识的未退出的线程必须使用相同的mask执行相同的intrinsic，否则结果会是不确定的。
约束：mask中设置为1的线程必须为active线程。
1.22.3. 例子
#include <stdio.h>
__global__ void bcast(int arg)
{
int laneId = threadIdx.x & 0x1f;
int value;
if (laneId == 0) // 注意：除了第零个lane，
value = arg; // 其他线程不会使用这个变量
value = __shfl_sync(0xffffffffffffffffUL, value, 0); // 同步warp中所有线程，并且从lane 0处取得“value”
if (value != arg)
printf("Thread %d failed.\n", threadIdx.x);
}
int main()
{
bcast<<<1, 64>>>(1234);
mcDeviceSynchronize();
return 0;
}
1.23. Nanosleep函数
__nanosleep 是设备侧的以纳秒为单位的休眠函数。
1.23.1. 提要
void __nanosleep(unsigned ns);
1.23.2. 描述
__nanosleep
__nanosleep(ns)支持thread以近似纳秒单位的休眠。该单位受运行主频影响，故仅为近似纳秒级为单位，不应用于实时性要求极高的时间度量场景。
1.23.3. 例子
__device__ void mutex_lock(unsigned int *mutex) {
unsigned int ns = 8;
while (atomicCAS(mutex, 0, 1) == 1) {
__nanosleep(ns);
if (ns < 256) {
ns *= 2;
}
}
}
__device__ void mutex_unlock(unsigned int *mutex) {
atomicExch(mutex, 0);
}
1.24. Warp matrix函数
C++ warp matrix操作用来求解形如 D=A*B+C 的矩阵乘加问题。这些操作需要warp中所有线程共同完成，它们所处的条件分支必须相同，否则执行结果是未定义的。
1.24.1. 描述
以下所有函数和类型都定义在 wmma 命名空间中。
template <typename Use, int m, int n, int k, typename T, typename Layout = void>
class fragment;
void load_matrix_sync(fragment<...> &f, const T* p, unsigned ldm);
void load_matrix_sync(fragment<...> &f, const T* p, unsigned ldm, layout_t layout);
void store_matrix_sync(T* p, const fragment<...> &f, unsigned ldm, layout_t layout);
void fill_fragment(fragment<...> &f, const T& v);
void mma_sync(fragment<...> &d, const fragment<...> &a, const fragment<...> &b,
const fragment<...> &c, bool satf = false);
fragment
warp中所有线程共同存储矩阵的数据结构。矩阵分片到内存中的映射方式是不确定的。
定义矩阵分片时必须明确模板中的参数。第一个模板参数指示矩阵分片如何参与矩阵运算。 Use 可以接受的类型有：
matrix_a将fragment用作第一个被乘数A。matrix_b将fragment用作第二个被乘数B。accumulator将fragment用作累加数或者目标结果（C或D）。
m 、 n 和 k 指示了矩阵的shape。每个矩阵的shape取决于它的角色。对于 matrix_a 为 m x k ，对于 matrix_b 为 k x n ，对于 accumulator 为 m x n 。
数据类型T对于被乘数可以是 double 、 float 、 __half 、 maca_bfloat16 、 signed char 或者 unsigned char ，对于累加数可以是 double float int 和 __half 。必须为 matrix_a 和 matrix_b 矩阵分片指定Layout模板参数。 row_major 或 col_major 分别表示矩阵的行或列的元素在内存中是连续的。 accumulator 矩阵的 Layout 参数应保留默认值 void 。当加载或者存储累加数的时候再指定行或列布局。
load_matrix_sync
warp中的所有线程都执行到 load_matrix_sync 时从内存中加载矩阵。 p 指向矩阵在内存中的第一个元素。 ldm 描述了连续行（行主序）或列（列主序）之间的元素个数。如果矩阵分片是 accumulator ， layout 参数必须是 mem_row_major 或者 mem_col_major 。对于 matrix_a 和 matrix_b 的矩阵分片， 内存布局从分片的 Layout 参数中推断。 p 、 ldm 、 layout 以及 f 的所有模板参数在同一warp的所有线程中必须相同。
store_matrix_sync
warp中的所有线程都执行到 store_matrix_sync 时将矩阵存储到内存中。 p 指向矩阵在内存中的第一个元素。 ldm 描述了连续行（行主序）或列（列主序）之间的元素个数。如果矩阵分片是 accumulator ， layout 参数必须是 mem_row_major 或者 mem_col_major 。 p 、 ldm 、 layout 以及 f 的所有模板参数在同一warp的所有线程中必须相同。
fill_fragment
使用变量 v 的值填充矩阵分片。因为分片到内存中的映射方式是不确定的，需要warp中的所有线程调用该函数并提供相同的参数值。
mma_sync
warp中的所有线程都执行到 mma_sync 时执行矩阵乘加运算 D=A*B+C 。支持 C=A*B+C 的原地操作。warp中的所有线程的每个矩阵分片的模板参数和 satf 值必须相同。此外，模板参数 m 、 n 和 k 必须在分片 A 、 B 、 C 和 D 之间匹配。该函数必须被warp中的所有线程调用，否则行为是未定义的。
如果 satf （saturate to finite value）是 true ，则为目标结果附加以下数值属性：
如果一个元素结果为正无穷大，则调整为
+MAX_NORM。如果一个元素结果为负无穷大，则调整为
-MAX_NORM。如果一个元素结果为NaN，则调整为
0。
由于矩阵分片到内存中的映射方式是不确定的，因此必须在调用 store_matrix_sync 后才能从内存中访问单个元素。有一种特殊场景是warp中的所有线程对所有分片元素执行相同操作，此时可以使用以下类成员直接访问元素。
enum fragment<Use, m, n, k, T, Layout>::num_elements;
T fragment<Use, m, n, k, T, Layout>::x[num_elements];
例如，以下代码将 accumulator 矩阵缩放一半。
wmma::fragment<wmma::accumulator, 16, 16, 16, float> frag;
float alpha = 0.5f;
/*...*/
for (int t = 0; t < frag.num_elements; t++)
frag.x[t] *= alpha;
1.24.2. 其他浮点类型
maca_bfloat16
该数据格式是另一种fp16格式，其范围与f32相同，但精度有所降低（7bits）。可以引入 maca_bfloat16.h 头文件然后使用 maca_bfloat16 数据格式。使用 maca_bfloat16 的矩阵分片需要与 float 类型的累加数组合使用。支持的形状和操作与 __half 保持一致。
tf32
该类型是一种特殊的浮点格式，范围与f32相同，但精度有所降低（>=10bits）。该格式的布局在设备端已定义实现，可以在WMMA操作中直接使用这种浮点格式。数据格式之间的转换是在设备端完成的，用户不需要手动进行。
该类型唯一支持的矩阵形状是16x16x8（m-n-k）。
1.24.3. 双精度类型
使用该类型对应的函数时必须使用 double 类型的 fragment 。
1.24.4. 元素类型和矩阵形状
下表是矩阵乘加运算支持的 matrix_a 、 matrix_b 和 accumulator 的组合：
Matrix A |
Matrix B |
Accumulator |
Matrix Size (m-n-k) |
|---|---|---|---|
__half |
__half |
float |
16x16x16 |
__half |
__half |
float |
32x8x16 |
__half |
__half |
float |
8x32x16 |
__half |
__half |
__half |
16x16x16 |
__half |
__half |
__half |
32x8x16 |
__half |
__half |
__half |
8x32x16 |
unsigned char |
unsigned char |
int |
16x16x16 |
unsigned char |
unsigned char |
int |
32x8x16 |
unsigned char |
unsigned char |
int |
8x32x16 |
signed char |
signed char |
int |
16x16x16 |
signed char |
signed char |
int |
32x8x16 |
signed char |
signed char |
int |
8x32x16 |
其他浮点类型支持：
Matrix A |
Matrix B |
Accumulator |
Matrix Size (m-n-k) |
|---|---|---|---|
maca_bfloat16 |
maca_bfloat16 |
float |
16x16x16 |
maca_bfloat16 |
maca_bfloat16 |
float |
32x8x16 |
maca_bfloat16 |
maca_bfloat16 |
float |
8x32x16 |
precision::tf32 |
precision::tf32 |
float |
16x16x8 |
双精度类型支持：
Matrix A |
Matrix B |
Accumulator |
Matrix Size (m-n-k) |
|---|---|---|---|
double |
double |
double |
8x8x4 |
1.24.5. 示例
以下代码实现了在单个warp里进行16x16x16矩阵乘法。
#include <mma.h>
__global__ void wmma_ker(half *a, half *b, float *c) {
// 声明矩阵分片
wmma::fragment<wmma::matrix_a, 16, 16, 16, half, wmma::col_major> a_frag;
wmma::fragment<wmma::matrix_b, 16, 16, 16, half, wmma::row_major> b_frag;
wmma::fragment<wmma::accumulator, 16, 16, 16, float> c_frag;
// 输出初始化为0
wmma::fill_fragment(c_frag, 0.0f);
// 加载输入
wmma::load_matrix_sync(a_frag, a, 16);
wmma::load_matrix_sync(b_frag, b, 16);
// 执行矩阵乘法
wmma::mma_sync(c_frag, a_frag, b_frag, c_frag);
// 保存输出
wmma::store_matrix_sync(c, c_frag, 16, wmma::mem_row_major);
}
1.25. Asynchronous Data Copies
MXMACA引入memcpy_asyn API允许设备隐式管理异步数据拷贝。memcpy_async特性允许MXMACA内核重叠数据移动和计算。
1.25.1. memcpy_async API
memcpy_async API由maca_async.h头文件提供。
cooperative_groups::memcpy_async 使用 cooperative_groups::wait 同步。
拷贝和计算模型通过 shared 内存预存数据。
通常应用这样一种拷贝和计算模型：
从global内存取数据
将数据存储到shared内存中
在shared内存数据上进行运算，最终将结果写回到global内存中。
下面的两个小节将描述这个模型在有/无memcpy_async的情况下的表达方式：
1.25.2. 没有memcpy_async
在没有memcpy_async的情况下，拷贝阶段表示如下：shared[local_idx] = global[global_idx]。这个global到shared的内存拷贝将会扩展为从global内存读取数据到寄存器，然后从寄存器写数据到shared内存。
当这个模型出现在迭代计算中，每一个thread block需要在从global到shared内存的拷贝之后进行同步，来确保在计算流程开始之前所有的到shared内存的写入都已经完成。thread block在计算阶段结束之后也需要再次同步，防止在所有的thread完成计算之前在shared内存的覆盖写入。这个模型在下面的代码段描述：
__global__ void without_memcpy_async(uint32_t* global_out,
uint32_t const* global_in,
uint32_t size,
uint32_t num_batch_per_block)
{
auto grid = cooperative_groups::this_grid();
auto block = cooperative_groups::this_thread_block();
// 输入的size应该与num_batch_per_block * grid.size()相等
assert(size == num_batch_per_block * grid.size());
// block.size() * sizeof(int) 字节
extern __shared__ uint32_t shared[];
uint32_t local_idx = block.thread_rank();
for (uint32_t batch = 0; batch < num_batch_per_block; ++batch) {
// 计算global内存中当前block的batch index
uint32_t block_batch_idx =
block.group_index().x * block.size() + grid.size() * batch;
uint32_t global_idx = block_batch_idx + local_idx;
shared[local_idx] = global_in[global_idx];
// 等待所有线程完成
block.sync();
// 计算并将结果写回global内存
global_out[global_idx] =
shared[local_idx] + shared[block.size() - local_idx - 1];
// 等待使用shared内存计算完成
block.sync();
}
}
1.25.3. 有memcpy_async
当具备memcpy_async的时候，从global内存到shared内存的赋值： shared[local_idx] = global_in[global_idx]; 可以被替换成为cooperative_groups里面的异步拷贝操作：
cooperative_groups::memcpy_async(group, shared, global_in + batch_idx,
sizeof(int) * block.size());
memcpy_async API从global内存起始地址global_in + batch_idx拷贝sizeof(int) * block.size()字节的数据到shared内存。这个操作就像由另外一个线程执行一样，在完成复制之后，它与当前线程通过wait同步。在数据复制操作完成之前，修改global数据或者读取/写入shared数据会引入数据竞争。
__global__ void with_memcpy_async(uint32_t* global_out,
uint32_t const* global_in,
uint32_t size,
uint32_t num_batch_per_block)
{
auto grid = cooperative_groups::this_grid();
auto block = cooperative_groups::this_thread_block();
// 输入的size应该与num_batch_per_block * grid.size()相等
assert(size == num_batch_per_block * grid.size());
// block.size() * sizeof(int) 字节
extern __shared__ uint32_t shared[];
uint32_t local_idx = block.thread_rank();
for (uint32_t batch = 0; batch < num_batch_per_block; ++batch) {
// 计算global内存中当前block的batch index
uint32_t block_batch_idx =
block.group_index().x * block.size() + grid.size() * batch;
uint32_t global_idx = block_batch_idx + local_idx;
// 整个 thread-group 协作地拷贝整个 batch 到 shared 内存:
cooperative_groups::memcpy_async(block,
shared,
global_in + block_batch_idx,
sizeof(uint32_t) * block.size());
// Join所有线程，等待所有的copy完成
cooperative_groups::wait(block);
// 计算并将结果写回global内存
global_out[global_idx] =
shared[local_idx] + shared[block.size() - local_idx - 1];
// 等待使用shared内存计算完成
block.sync();
}
}
1.26. Assert函数
断言函数，在设备侧函数中调用该函数以阻止致命的错误。
void assert(int expression);
当expression等于0时，阻止当前kernel执行。并且每个设备侧线程（expression为0时）会按如下格式打印stderr：
<filename>:<line number>:<function>:
block: [blockIdx.x, blockIdx.y, blockIdx.z],
thread: [threadIdx.x, threadIdx.y, threadIdx.z],
Assertion `<expression>` failed.
1.27. Trap函数
可在任意设备线程中调用 __trap() 以触发trap动作。
void __trap();
终止kernel的执行并在host侧引发中断。
1.28. Breakpoint函数
在任意设备线程中调用 __brkpt() 来停止当前kernel的执行。
void __brkpt();
1.29. 格式化输出
设备侧的printf函数可以对设备侧的信息进行格式化输出。函数原型如下：
int printf(const char *format[, arg, …]);
与标准C库的printf函数类似，设备侧printf函数根据输入的format参数，将输入的参数格式化的输出到主机端的流。其返回值与标准C库中的printf一致。
设备侧的printf函数会被设备侧的每个活动线程执行，其执行结果以warp为单位保序。
1.29.1. Format Specifiers
与标准C库的printf一致，其拥有这样的格式: %[flags][width][.precision][size]type
目前支持:
Flags: #、“空格”、0、+、-
Width: *、“0-9”
Precision: “0-9”
Size: h、l、ll
Type: “%diouxXfFeEgGaAcspn”
1.29.2. 限制
Printf输出的最终格式由主机端决定。这意味着格式字符串必须由主机系统的编译器和C库控制。我们将努力确保MXMACA的printf函数支持的格式说明符的形成来自最常见的主机编译器的通用子集，但确切的行为将取决于主机操作系统。
如格式说明符所述，printf()将接受有效标志和类型的所有组合，但其无法确定在最终输出格式化的主机系统上组合有效。如果程序发出包含无效组合的格式字符串，输出可能未定义。
1.29.3. 例子
如下代码：
#include <stdio.h>
__global__ void helloMXMACA(float f)
{
printf("Hello thread %d, f=%f\n", threadIdx.x, f);
}
int main()
{
helloMXMACA<<<1, 5>>>(1.2345f);
return 0;
}
将会输出：
Hello thread 0, f=1.2345
Hello thread 1, f=1.2345
Hello thread 2, f=1.2345
Hello thread 3, f=1.2345
Hello thread 4, f=1.2345
注意每个线程均会执行printf命令（这里不考虑有条件分支的场景），因此输出行与grid中启动的线程一样多。当printf函数作用与条件分支（假设条件变量与threadIdx.x相关）中，则各线程可能执行不同的打印。
如下代码：
#include <stdio.h>
__global__ void helloMXMACA(float f)
{
if (threadIdx.x == 0)
printf("Hello thread %d, f=%f\n", threadIdx.x, f) ;
}
int main()
{
helloMXMACA<<<1, 5>>>(1.2345f);
return 0;
}
将会输出:
Hello thread 0, f=1.2345
if()语句限制了仅有线程0将调用printf，因此只能看到一行输出。
1.30. 动态Global内存操作
__device__ void* malloc(size_t size);
__device__ void free( void * ptr);
从global内存中动态的申请和释放buffer。
__device__ void* memcpy(void* dest, const void* src, size_t size);
从 src 指向的内存地址复制 size 字节到 dest 指向的内存地址。
__device__ void* memset(void* ptr, int value, size_t size);
将 src 指向的地址开始的 size 字节的内存块里面的值设置为value（解析成 unsigned char ）
malloc() 函数从device heap中分配至少 size 字节内存并返回一个指向这块分配的内存的指针。如果没有足够的内存则返回NULL。返回的指针确保是16字节边界对齐。
1.30.1. 堆内存分配
在任何 malloc() 或 free() 加载到上下文之前，device的堆内存有一个固定的大小被指定。如果使用 malloc() 而没有指定固定的堆大小，一个默认的8 MB堆内存会被分配。
下面的api函数提供获取、设置堆大小的能力：
mcDeviceGetLimit(size_t* size, mcLimitMallocHeapSize)
mcDeviceSetLimit(mcLimitMallocHeapSize, size_t size)
堆大小保证最少 size 字节， mcDeviceGetLimit 返回当前要求的堆大小。
1.30.2. 与host内存交互的api
1.30.3. 例子
1.30.3.1. Per Thread 分配
如下代码：
#include <stdlib.h>
#include <stdio.h>
__global__ void mallocTest()
{
size_t size = 123;
char* ptr = (char*)malloc(size);
memset(ptr, 0, size);
printf("Thread %d got pointer: %p\n", threadIdx.x, ptr);
free(ptr);
}
int main()
{
// 设置一个128 MB的堆大小. 注意这个动作必须在任何kernel launch之前完成
mcDeviceSetLimit(mcLimitMallocHeapSize, 128*1024*1024);
mallocTest<<<1, 5>>>();
mcDeviceSynchronize();
return 0;
}
将会输出：
Thread 0 got pointer: 00057020
Thread 1 got pointer: 0005708c
Thread 2 got pointer: 000570f8
Thread 3 got pointer: 00057164
Thread 4 got pointer: 000571d0
1.30.3.2. Per Thread block 分配
#include <stdlib.h>
__global__ void mallocTest()
{
__shared__ int* data;
// block中的第一个线程执行分配动作并通过shared内存将指针与其block中所有其他的线程共享，
// 因此可以轻松地合并访问。每个线程分配64字节。
if (threadIdx.x == 0)
{
size_t size = blockDim.x * 64;
data = (int*)malloc(size);
}
__syncthreads();
// 检查是否失败
if (data == NULL)
return;
// 把线程ID写入指针，保证合并
int* ptr = data;
for (int i = 0; i < 64; ++i)
ptr[i * blockDim.x + threadIdx.x] = threadIdx.x;
// 保证在释放之前所有的线程都完毕
__syncthreads();
// 只有一个线程执行释放的动作
if (threadIdx.x == 0)
free(data);
}
int main()
{
mcDeviceSetLimit(mcLimitMallocHeapSize, 128 * 1024 * 1024);
mallocTest<<<10, 128>>>();
mcDeviceSynchronize();
return 0;
}
1.31. 执行配置
任何对于 __global__ 函数的调用必须明确“执行配置”。执行配置定义了将会在device上执行的函数的grid、block的维度，同时也定义了相关的流。
执行配置通过在函数名与带括号的参数列表之间插入形如 <<<Dg, Db, Ns, S>>> 的表达式来确定，其中：
Dg的数据类型为dim3，该参数确定了grid的维度与大小，Dg.x * Dg.y * Dg.z的值为启动的block的数量。
Db的数据类型为dim3，该参数确定了block的维度与大小，Db.x * Db.y * Db.z的值为每个block中thread的数量。
Ns的数据类型为size_t，该参数指定了除静态分配的shared内存之外，本次调用中每个block可动态分配的shared内存的大小（单位：字节）。这些动态分配的内存可以被任何声明为external的数组（ 1.2.3 __shared__ ）使用；该参数为可选参数，默认为0。
S的数据类型为mcStream_t，该参数指定了相关的流对象。该参数为可选参数，默认为0。
例如，一个kernel函数声明为：
__global__ void Func(float* parameter);
可以使用如下方式调用该kernel函数：
Func<<< Dg, Db, Ns >>>(parameter);
执行配置的参数会在函数参数计算之前被计算。
如果Dg或者Db超出device允许的最大值，则函数调用会失败。当Ns超出device可用的最大shared内存时，将会减少静态分配所需的内存。
1.32. Launch Bounds（启动边界）
每个kernel使用的寄存器越少，多处理器上的thread与block就可能存在的越多，这样可以提升性能。
因此，编译器使用启发式方法来最小化寄存器使用量，同时将寄存器溢出和指令计数保持在最小。
应用程序可以通过在 __global__ 函数中使用 __launch_bounds__() 标识符的形式，向编译器提供附加信息来有选择地帮助这些启发式。
__global__ void
__launch_bounds__(maxThreadsPerBlock)
MyKernel(...)
{
...
}
maxThreadsPerBlock确定每次程序启动MyKernel的时候，每个block的最大线程数量。
如果指定了启动边界，编译器首先从它们派生出内核应该使用的寄存器数量上限，以确保maxThreadsPerBlock线程可以驻留在多处理器上。
1.33. #pragma unroll
编译器在默认情况下会展开具有较小次数的循环。也可以使用 #pragma unroll 指令指示编译器展开任意循环。该指令的位置必须在一个循环前面，同时也只作用于这个循环。指令后可以跟随一个可选的整型常数表达式（ICE）。当没有指定ICE并且循环次数是常数的时候，编译器将会将循环完全展开。当ICE的值为1时，编译器将不会展开循环。当ICE的值是一个非正整数或者大于 int 类型最大值的时候，编译器将忽略该指令。
例子：
struct S1_t
{
static const int value = 4;
};
template <int X, typename T2>
__device__ void foo(int *p1, int *p2)
{
// 没有参数，循环将被完全展开
#pragma unroll
for (int i = 0; i < 12; ++i)
p1[i] += p2[i] * 2;
// unroll value = 8
#pragma unroll(X + 1)
for (int i = 0; i < 12; ++i)
p1[i] += p2[i] * 4;
// unroll value = 1, 不展开循环
#pragma unroll 1
for (int i = 0; i < 12; ++i)
p1[i] += p2[i] * 8;
// unroll value = 4
#pragma unroll(T2::value)
for (int i = 0; i < 12; ++i)
p1[i] += p2[i] * 16;
}
__global__ void bar(int *p1, int *p2)
{
foo<7, S1_t>(p1, p2);
}
1.34. 关于内联汇编
MXMACA暂时不支持内嵌汇编，如有需要可联系沐曦客户支持部门协助。
2. Cooperative Groups
2.1. 介绍
Cooperative Groups是一个MXMACA编程模型的扩展，目的是组织线程之间的交互。Cooperative Groups允许开发者表达交互线程的粒度，帮助他们进行更有效的并行分解。
2.2. 编程模型概念
Cooperative Groups编程模型描述MXMACA thread blocks内部以及相互之间的同步模式。它为应用提供定义他们自己的线程分组的方法，以及同步它们的接口。还提供新的强制执行特定限制的launch APIs来保证同步的功能。这些原语在MXMACA中启用新的协作并行模型，包括生产者-消费者并行性，机会并行性，以及整个Grid的整体同步。
Cooperative Groups编程模型由以下元素构成：
表示协作线程分组的数据类型；
获取MXMACA launch API定义的隐式分组的操作（比如 thread blocks）；
将现有分组划分为新分组的操作集合；
数据移动和操作的算法集合（比如 memcpy_async， reduce， scan）；
同步组内所有线程的操作；
检查组属性的操作；
暴露低级别、特定于组且通常由硬件加速的操作集合。
Cooperative Groups中的主要概念是对象命名其中一部分的线程集。这种将组表示为一级程序对象的方式改进了软件组合，因为集合函数可以接收表示参与线程组的显式对象。该对象还使程序员的意图明确，从而消除了从而消除了代码脆弱的不合理架构假设、对编译器优化的不良限制以及与GPU的更好的兼容性。
要编写高效的代码，最好使用专门的group（通用会失去很多编译时优化），并通过引用将这些组对象传递给打算以某种写作方式使用这些线程的函数。
要使用Cooperative Groups，请包含头文件：
#include <maca_cooperative_groups.h>
并使用Cooperative Groups的命名空间：
using namespace cooperative_groups;
// 或者使用一个别名防止集体算法污染命名空间
namespace cg = cooperative_groups;
代码可以使用mxcc正常编译，但是如果你想使用memcpy_async， reduce或者scan的功能，并且你的host侧编译器的默认方言不是c++11或更高，你需要在命令行添加–std=c++11。
2.2.1. 组示例
为了说明组的概念，此示例尝试执行块范围的规约求和，如果没有cooperative groups，写代码的时候在实现上有隐藏的约束：
__device__ int sum(int *x, int n) {
__syncthreads();
return total;
}
__global__ void parallel_kernel(float *x) {
// ...
// 整个线程块都必须调用sum
sum(x, n);
}
所有线程块的线程都必须到达__syncthreads() barrier，但是这个约束对于想使用sum的开发者来说是隐藏的。使用Cooperative Groups，一个更好的实现方式：
__device__ int sum(const thread_block& g, int *x, int n) {
// ...
g.sync();
return total;
}
__global__void parallel_kernel(...) {
// ...
// 整个线程块都必须调用sum
thread_block tb = this_thread_block();
sum(tb, x, n);
}
2.3. 组类型
2.3.1. 隐式组
隐式组代表内核的启动配置。无论内核是如何编写的，它始终具有一定数量的thread、block和block维度、单个grid和grid维度。另外，如果使用多设备协同启动API，可以有多个grid（每个设备一个grid）。这些组为分解成更细粒度的组提供了一个起点，这些组通常是硬件加速的，并且更专门用于开发人员正在解决的问题。
尽管您可以在代码的任何位置创建隐式组，但这样做很危险。为隐式组创建句柄是一个集体操作–组中的所有线程都必须参与。如果组不是在所有线程都到达的分支中创建的，则可能导致死锁或者数据损坏。因此，建议您预先为隐式组创建一个句柄（尽可能早，在任何分支发生之前）并在整个内核中使用这个句柄。
2.3.1.1. Thread Block Group
⼤家对于这样的thread block定义的thread group已经⾮常了解了。Cooperative Group扩展引⼊⼀个新的数据类型， thread_block，来显示地表示kernel中的这一概念。
class thread_block;
// 如下⽅式构造：
thread_block g = this_thread_block();
// Public 成员函数：
static void sync(); // 同步组内的线程
static unsigned int thread_rank(); // 在[0, num_threads)区间内为调⽤线程排序
static dim3 group_index(); // 在启动的grid中当前block的3-D index
static dim3 thread_index(); // 在启动的block中当前thread的3-D index
static dim3 dim_threads(); // 以units为单位的启动的block的尺⼨
static unsigned int num_threads(); // 当前group中总的线程数
// 传统成员函数（别名）：
static unsigned int size(); // 当前group中总的线程数(num_threads的别名)
static dim3 group_dim(); // 启动的block的尺⼨(dim_threads的别名)
例子：
/// 从global内存加载数据到shared内存
__global__ void kernel(int *globalInput) {
__shared__ int x;
thread_block g = this_thread_block();
// 选⼀个leader
if (g.thread_rank() == 0) {
// ⼀次从global中加载所有thread需要的数据到shared
x = (*globalInput);
}
// 在加载数据到shared内存完毕之后，如果block中所有的线程需要使⽤这个数据，你需
g.sync(); // 等价于 __syncthreads();
}
// 注意： group中所有的线程都必须参与集体操作，否则⾏为是未定义的。
// thread_block数据类型是从更加generic的类型thread_group派⽣出来的，thread_group
// 可以用来表⽰更⼴泛的group
2.3.1.2. Grid Group
这个group对象表示在⼀个单独的grid中启动的所有threads。除了sync()之外的接口任何时间都可以调用，但是为了整个grid同步，你需要使用cooperative launch API（mcLaunchCooperativeKernel）。
class grid_group;
// 如下构造⽅式：
grid_group g = this_grid();
// Public 成员函数：
bool is_valid() const; // 返回当前grid_group是否可以同步
void sync() const; // 同步当前group中所有的线程
static unsigned long long thread_rank(); // 调⽤线程在[0, num_threads)上的排序
static unsigned long long block_rank()； // 调⽤block在[0, num_blocks)上的排序
static unsigned long long num_threads(); // group中threads的总数⽬
static unsigned long long num_blocks(); // group中block的总数⽬
static dim3 dim_blocks(); // 以units为单位的启动的block的⼤⼩
static dim3 block_index(); // 在启动的grid中当前block的3-D index
// 传统成员函数（别名）
static unsigned long long size(); // 当前group中总的线程数(num_threads的别名)
static dim3 group_dim(); // 启动的grid的尺⼨(dim_blocks的别名)
2.3.1.3. Multi Grid Group
这个group对象表示⼀个multi-device cooperative launch⾥⾯所有devices的所有threads。与grid_group不同，所有的API需要你使⽤合适的启动API（mcLaunchCooperativeKernelMultiDevice）。
class multi_grid_group;
// 如下构造⽅式
// 内核必须通过cooperative multi-device API启动
multi_grid_group g = this_multi_grid();
// Public 成员函数：
bool is_valid() const; // 返回当前multi_grid_group是否可以同步
void sync() const; // 同步当前group中所有的线程
unsigned long long num_threads(); // group中threads的总数⽬
unsigned long long thread_rank(); // 调⽤线程在[0, num_threads)上的排序
unsigned int grid_rank(); // 调⽤线程在[0, num_grids)上的排序
// 传统成员函数（别名）
static unsigned long long size(); // 当前group中总的线程数(num_threads的别名)
// 描述: 所有devices不推荐使⽤multi_grid_group。
2.3.2. 显式组
2.3.2.1. Thread Block Tile
⼀个模板化版本的tiled group, 模板参数⽤来指定tile的size，这样在编译时知道size，才有可能实现更优化的执⾏。
template <unsigned int Size, typename ParentT = void>
class thread_block_tile;
// 如下构造⽅式
template <unsigned int Size, typename ParentT>
_CG_QUALIFIER thread_block_tile<Size, ParentT> tiled_partition(const ParentT &g)
Size必须是2的幂，并且不⼤于64。
Parent T 是分割出这个⼦group的⽗类型。它是⾃动推断的，但是存储这个信息的void值将会在group句柄中存储，⽽不是这个类型中。
// Public 成员函数
void sync() const; // 同步group内的线程
unsigned long long num_threads() const; // group中线程总数
unsigned long long thread_rank() const; // 调⽤线程在[0, num_threads)上的排序
unsigned long long meta_group_size() const; // 返回parent group 分割创建的组的数量
unsigned long long meta_group_rank() const; // 从⽗group划分的tiles集合中的组的线性秩
// （由meta_group_size限定）
T shfl_up(T var, int delta) const; // 参考Warp Shuffle Functions
T shfl_down(T var, int delta) const; // 参考Warp Shuffle Functions
T shfl_xor(T var, int delta) const; // 参考Warp Shuffle Functions
T any(int predicate) const; // 参考Warp Vote Functions
T all(int predicate) const; //参考Warp Vote Functions
T ballot(int predicate) const; // 参考Warp Vote Functions
T match_any(T val) const; // 参考Warp Match Functions
T match_all(T val, int &pred) const; // 参考Warp Match Functions
// 传统成员函数（别名）
unsigned long long size() const; // 当前group中总的线程数(num_threads的别名)
在C++11及更高版本标准机型编译时，shfl, shfl_up, shfl_down与shfl_xor这些函数接收任意类型的对象。意味着只要满⾜以下条件，就可以shuffle⾮整数型的类型：
具有可复制性：⽐如， is_trivially_copyable<T>::value == true
sizeof(T) <= 32
例⼦：
// 下⾯的代码将会创建两组tiled groups, size分别是32 和 4：
// 后者将源代码编码在类型中，⽽前者将其存储在句柄中
thread_block block = this_thread_block();
thread_block_tile<32> tile32 = tiled_partition<32>(block);
thread_block_tile<4, thread_block> tile4 = tiled_partition<4>(block);
备注
这里要使用模板化的数据结构 thread_block_tile ，分组的size通过模板参数传递给 tiled_partition 而非函数参数。
Warp-Synchronous代码模型
开发者可能会写出之前隐式地假定warp size的warp-synchronize代码，并且根据这个数字编写代码。现在需要显式地指定这个数字。
__global__ void cooperative_kernel(...) {
// 获取默认的“当前thread block” 分组
thread_block my_block = this_thread_block();
// 细分为32个thread的分组，tiled子分组
// tiled子分组将父分组均匀地划分为相邻的thread集合
// ——在这种情况下，每个分组有一个warp size数量的thread
auto my_tile = tiled_partition<64>(my_block);
// 下面的操作将会只被每个block的前64个thread组成的
// tiled分组执行
if（my_tile.meta_group_rank() == 0) {
// ...
my_tile.sync();
}
}
Single thread分组
表示当前thread的分组可以通过 this_thread 这个函数获取：
thread_block_tile<1> this_thread();
下面的 memcpy_async API使用一个 thread_group，来从源到目标拷贝一个元素：
#include <maca_cooperative_groups.h>
#include <maca_async.h>
cooperative_groups::memcpy_async(cooperative_groups::this_thread(),
dest, src, sizeof(int));
2.3.2.2. Coalesced Groups
在MXMACA的SIMT架构下，在硬件层面，多处理器以一组64线程（称作warps）的方式执行。如果在应用代码中存在数据依赖的条件分支，导致一个warp内的thread岔道，那么warp串行地执行每个分支，同时disable掉不在当前执行分支上的线程。在分支上的，保持active的线程被称作coalesced。Cooperative Groups有能力去发现，并且创建一个包含所有的coalesced线程的分组。
通过 coalesced_threads() 构造这个分组的句柄是机会主义的。它返回那个调用点当时active thread组成的集合，并且不保证哪一个thread是被返回的（只要他们是active的），或者说它们在整个执行过程中将会保持coalesced（它们在执行过程中作为一个集体，但是之后也可能再次分岔）。
class coalesced_group;
// 通过如下⽅式构造：
coalesced_group active = coalesced_threads();
// Public 成员函数：
void sync() const; // 同步group内的线程
unsigned long long num_threads() const; // group中线程总数
unsigned long long thread_rank() const; // 调⽤线程在[0, num_threads)上的排序
unsigned long long meta_group_size() const; // 返回parent group 分割创建的组的数量
// 如果这个group是通过查询活动线程集创建的，
// ⽐如coalesced_threads(), meta_group_size()值为1
unsigned long long meta_group_rank() const; // 从⽗group划分的tiles集合中的
// （由meta_group_size限定）
T shfl_up(T var, int delta) const; // 参考Warp Shuffle Functions
T shfl_down(T var, int delta) const; // 参考Warp Shuffle Functions
T shfl_xor(T var, int delta) const; // 参考Warp Shuffle Functions
T any(int predicate) const; // 参考Warp Vote Functions
T all(int predicate) const; //参考Warp Vote Functions
T ballot(int predicate) const; // 参考Warp Vote Functions
T match_any(T val) const; // 参考Warp Match Functions
T match_all(T val, int &pred) const; // 参考Warp Match Functions
// 传统成员函数（别名）
unsigned long long size() const; // 当前group中总的线程数(num_threads的别名
在C++11及更高版本标准机型编译时，shfl, shfl_up, shfl_down与shfl_xor这些函数接收任意类型的对象。意味着只要满⾜以下条件，就可以shuffle⾮整数型的类型：
具有可复制性：⽐如，is_trivially_copyable<T>::value == true
sizeof(T) <= 32
例子：
__global__ void kernel(int *gIn) {
if (threadIdx.x == *gIn) {
coalesced_group active = coalesced_threads();
active.sync();
}
}
Discovery Pattern
开发者通常需要与当前active的线程集合共事。没有对存在的线程进行假设，而是开发人员使用碰巧存在的线程。可以通过下面的“聚合warp中线程之间的原子增量”的例子看出来：
{
unsigned int writemask = __activemask();
unsigned int total = __popc(writemask);
unsigned int prefix = __popc(writemask & __lanemask_lt());
// 发现laneID最小的active thread
int elected_lane = __ffs(writemask) - 1;
int base_offset = 0;
if (prefix == 0) {
base_offset = atomicAdd(p, total);
}
base_offset = __shfl_sync(writemask, base_offset, elected_lane);
int thread_offset = prefix + base_offset;
return thread_offset;
}
使用Cooperative Groups重新写这个功能如下：
{
using cg = namespace cooperative_groups;
cg::coalesced_group g = cg::coalesced_threads();
int prev;
if (g.thread_rank() == 0) {
prev = atomicAdd(p, g.num_threads());
}
prev = g.thread_rank() + g.shfl(prev, 0);
return prev;
}
2.4. 组分割
2.4.1. tiled_partition
template <unsigned int Size, typename ParentT>
thread_block_tile<Size, ParentT> tiled_partition(const ParentT& g);
thread_group tiled_partition(const thread_group& parent, unsigned int tilesz);
tiled_partition 方法是一组分割父组到一个一维的，行优先的，子分组的平铺。将一共创建 (size(parent) / tilesz) 个子分组，因此父组的size必须是可以被Size整除的数字。允许的父组的类型是 thread_block 或者 thread_block_tile。
实现可能导致调用的thread一直等到所有的父组的成员调用了这个操作，之后才恢复执行。功能限制于本地的硬件条件，1/2/4/8/16/32/64，并且 cooperative_groups::size(parent) 必须比参数Size大。
例子：
/// 下面的代码将会创建一个32-thread tile
thread_block block = this_thread_block();
thread_block_tile<32> tile32 = tiled_partition<32>(block);
我们也可以把这些组分割成更小的组，每个组的size是4：
auto tile4 = tiled_partition<4>(tile32);
// 或使用一个通用的组
// thread_group tile4 = tiled_partition(tile32, 4);
假设我们要包含下面的代码行：
if (tile4.thread_rank() == 0) printf("Hello from tile4 rank 0\n");
那么这个表达将会被block中每第四个线程打印。
2.4.2. labeled_partition
coalesced_group labeled_partition(const coalesced_group& g, int label);
template <unsigned int Size>
coalesced_group labeled_partition(const thread_block_tile<Size>& g, int label);
labeled_partition 方法是一个分割父组到一个一维的子分组（组内线程都是coalesced）的操作集合。实现将会评估条件label然后把有同样label值的线程放到相同的组。
实现可能导致调用的thread一直等到所有的父组的成员调用了这个操作，之后才恢复执行。
备注
这个功能仍然在测试中以后可能会有轻微改动。
2.4.3. binary_partition
coalesced_group binary_partition(const coalesced_group& g, bool pred);
template<unsigned int Size>
coalesced_group binary_partition(const thread_block_tile<Size>& g, bool pred);
binary_partition() 方法是一个分割父组到一个一维的子分组（组内线程都是coalesced）的操作集合。实现将会评估条件pred然后把有同样pred值的线程放到相同的组。它是 labeled_partition() 的一种特殊形式，label只能为0或1。
实现可能导致调用的thread一直等到所有的父组的成员调用了这个操作，之后才恢复执行。
备注
这个功能仍然在测试中以后可能会有轻微改动。
2.5. 组操作集合
2.5.1. 同步
2.5.1.1. sync
cooperative_groups::sync(T& group);
sync 函数同步指定的分组内的线程。T可以是任何存在的分组类型，它们都支持同步操作。如果这个分组是一个grid_group或者一个multi_grid_group，内核必须使用合适的cooperative启动接口来启动。
2.5.2. 数据移动
2.5.2.1. memcpy_async
memcpy_async 是一个组级别的内存拷贝操作集合，它对非阻塞的全局到共享内存的内存交换应用硬件加速支持。对于分组内的特定的线程集合， memcpy_async 会通过单独的一个流水步骤移动指定数量的字节或者输入类型的元素。此外，为了获取最佳的性能表现，需要全局以及共享内存按照16字节对齐。只有当拷贝源是全局内存并且拷贝目标是共享内存，并且两块内存编码都必须是16，8或者4字节对齐的时候这个操作才是异步的，否则它就是一个通常意义上的内存拷贝操作。异步内存拷贝的数据应该只能在 wait 之后读取，表示把数据移动到共享内存的操作阶段已经结束了。
必须等待所有未处理的请求可能会失去一些灵活性（但是会获得简单性）。为了有效地重叠数据传输和执行，能够在等待和操作请求N的同时启动N+1 memcpy_async 请求很重要。
用法1
template <typename TyGroup, typename TyElem, typename TyShape>
void memcpy_async(
const TyGroup &group,
TyElem *__restrict__ _dst,
const TyElem *__restrict__ _src,
const TyShape &shape
);
执行shape字节数的数据拷贝。
用法2
template <typename TyGroup, typename TyElem,
typename TyDstLayout, typename TySrcLayout>
void memcpy_async(
const TyGroup &group,
TyElem *__restrict__ dst,
const TyDstLayout &dstLayout,
const TyElel *__restrict__ src,
const TySrcLayout &srcLayout
);
执行 min(dstLayout, srcLayout) 个元素的拷贝。
代码生成要求： C++11
头文件 maca_async.h 需要被包含。
例子：
/// 这个例子在block上把elementsPerThreadBlock个有效数据从全局内存拷贝到
/// 限制大小的共享内存（elementsInShared）。
#include <maca_cooperative_groups.h>
#include <maca_async.h>
namespace cg = cooperative_groups;
__global__ void kernel(int *global_data) {
cg::thread_block tb = cg::this_thread_block();
const size_t elementsPerThreadBlock = 16 * 1024;
const size_t elementsInShared = 128;
__shared__ int local_smem[elementsInShared];
size_t copy_count;
size_t index = 0;
while (index < elementsPerThreadBlock) {
cg::memcpy_async(tb, local_smem, elementsInShared, global_data + index,
elementsPerThreadBlock - index);
copy_count = min(elementsInShared, elementsPerThreadBlock - index);
cg::wait(tb);
// 操作local_smem
index += copy_count;
}
}
2.6. Grid 同步
在介绍Cooperative Groups之前，MXMACA编程模型只允许在内核完成边界处的thread block之间进行同步。内核边界带来了一种隐含的状态无效，以及潜在的性能影响。
举个例子，在具体的应用场景，应用有很多的小内核，每一个内核表示一个流水进程中的一个状态。对于当前的MXMACA编程模型这些内核的存在是必要的，以保证运行在一个确定的流水线状态的thread block在下一个流水线状态之前输出了下一个流水线状态可能需要的数据。在这样的场景下，提供全局thread block同步的能力将会允许应用重构以拥有当给定阶段完成时能在设备上同步的持久thread block。
想要一个内核的整个grid同步，你只需要简单的使用 grid.sync() 函数：
grid_group grid = this_grid();
grid.sync();
而且在启动内核的时候，使用MXMACA 运行时启动API mcLaunchCooperativeKernel 替代<<<…>>>执行配置语法是必要的。
例子：
要保证GPU上的thread block的共同驻留，启动的block的数量需要仔细思考。比如像下面的尽可能多的启动SM可以启动的thread block：
int device = 0;
mcDeviceProp deviceProp;
mcGetDeviceProperties(&deviceProp, dev);
mcLaunchCooperativeKernel((void*)my_kernel, deviceProp.multiProcessorCount,
numThreads, args);
或者，你可以通过使用占用计算器计算每个SM可以同时容纳多少block来最大限度地提高暴露的并行性，如下所示：
/// 下面的代码将会启动一个在默认stream上的最大限度占用GPU的内核
int numBlocksPerSm = 0；
// my_kernel启动的线程数量
int numThreads = 128;
mcDeviceProp deviceProp;
mcGetDeviceProperties(&deviceProp, dev);
mcOccupancyMaxActiveBlocksPerMultiProcessor(&numBlocksPerSm,
my_kernel, numThreads, 0);
// 启动
void* kernelArgs[] = { /* 添加内核参数 */ }；
dim3 dimBlock(numThreads, 1, 1);
dim3 dimGrid(deviceProp.multiProcessorCount * numBlocksPerSm, 1, 1);
mcLaunchCooperativeKernel((void*)my_kernel, dimGrid, dimBlock, kernelArgs);
推荐通过查询设备的 mcDevAttrCooperativeLaunch 属性来先确认设备支持cooperative launch：
int dev = 0;
int supportsCoopLaunch = 0;
mcDeviceGetAttribute(&supportsCoopLaunch, mcDevAttrCooperativeLaunch, dev);
如果设备0的属性显示支持cooperative launch， supportsCoopLaunch 将会被设为1。
2.7. 多设备同步
为了支持使用Cooperative Groups进行多设备之间的同步，必须使用MXMACA启动接口 mcLaunchCooperativeKernelMultiDevice。这个与现存的 MXMACA 接口明显不同的接口允许一个主机线程在多个设备上启动一个内核。除了 mcLaunchCooperativeKernel 的限制与保证之外，这个接口有其他的语法：
这个接口保证启动是原子的，比如：如果这个接口调用成功，提供的线程块的数量将会在所有指定的设备上启动。
通过这个接口启动的函数必须是相同的。驱动不会在这一点上有显示的检查，因为是不可行的。这一点需要应用来保证。
在提供的
mcLaunchParams中没有映射到相同设备的两个条目。这个启动的所有目标设备必须有相同的计算能力——主要版本以及次要版本。
所有设备上每个grid的block size, grid size以及共享内存的数量都必须相同。这意味着每个设备上可以启动的block数量的最大值是受有最少SM数量的设备的限制的。
任何用户定义的
__device__，__constant__或者__managed__的出现在模块中的设备侧全局变量拥有正在启动的CU函数，并在每个设备上独立实例化。用户有责任给这些全局变量合适的初始化。
可以通过启用对等访问（通过对所有参与的设备设置 mcCtxEnablePeerAccess 或者 mcDeviceEnablePeerAccess ）。
启动参数应该使用一个结构体的数组定义（一个设备一个结构体对象），并且使用 mcLaunchCooperativeKernelMultiDevice 启动。
例子：
mcDeviceProp deviceProp;
mcGetDeviceCount(&numGpus);
// 每个设备的启动参数
mcLaunchParams *launchParams =
(mcLaunchParams*)malloc(sizeof(mcLaunchParams) * numGpus);
mcStream_t *streams = (mcStream_t*)malloc(sizeof(mcStream_t) * numGpus);
// 启动过程中拷贝内核启动参数
// 也可以使用每个设备独立的内核参数拷贝，但是函数/内核的签名以及名字必须相同
void* kernelArgs = { /* 添加内核参数 */ }
for (int i = 0; i < numGpus; i++) {
mcSetDevice(i);
// 每个设备的stream，但是每个设备也可以使用默认的NULL stream
mcStreamCreate(&streams[i]);
// 循环其他设备以及设置 mcDeviceEnablePeerAccess 以获取一个更快的barrier的实现
}
// 所有设备必须相同的计算能力并且有相同的启动配置
// 这里查询设备0是必要的
mcGetDeviceProperties(&deviceProp[i], 0);
dim3 dimBlock(numThreads, 1, 1);
dim3 dimGrid(deviceProp.multiProcessorCount, 1, 1);
for (int i = 0; i < numGpus; i++) {
launchParamsList[i].func = (void*)my_kernel;
launchParamsList[i].gridDim = dimGrid;
launchParamsList[i].blockDim = dimBlock;
launchParamsList[i].sharedMem = 0;
launchParamsList[i].stream = streams[i];
launchParamsList[i].args = kernelArgs;
}
mcLaunchCooperativeKernelMultiDevice(launchParams, numGpus);
此外，就像grid级别的同步，设备侧代码看起来也很像：
multi_grid_group multi_grid = this_multi_grid();
multi_grid.sync();
但是代码需要用独立编译的方式，传递-rdc=true到mxcc。
推荐通过查询设备的 mcDevAttrCooperativeMultiDeviceLaunch 属性来先确认设备支持多设备cooperative launch：
int dev = 0;
int supportsMdCoopLaunch = 0;
mcDeviceGetAttribute(&supportsMdCoopLaunch,
mcDevAttrCooperativeMultiDeviceLaunch, dev);
如果设备0的属性显示支持多设备cooperative launch， supportsMdCoopLaunch 将会被设为1。
3. C++ 语言支持
关于mxcc支持的ISO C++标准，参见表 3.1。
语言标准 |
Flag |
支持程度 |
|---|---|---|
C++98/C++03 |
-std=c++98 |
除了export完全支持 |
C++11 |
-std=c++11 |
完全支持 |
C++14 |
-std=c++14 |
完全支持 |
C++17 |
-std=c++17 |
部分支持 |
C++20 |
-std=c++20 |
部分支持 |
C++2b（暂定C++23） |
-std=c++2b |
部分支持 |
3.1. C++98 支持状态
mxcc支持了除了export（C++11中移除）之外的所有的C++98标准的特性。
3.2. C++11支持状态
mxcc支持C++11所有的特性，可以使用-std=c++11的选项应用C++11。
3.3. C++14支持状态
mxcc支持C++14所有的特性，可以使用-std=c++14的选项应用C++14。
3.4. C++17以及之后标准支持状态
mxcc不完全支持C++17及之后C++标准，不建议使用。