4.5. 半精度转换与数据移动

要使用这些函数，请在程序中包含头文件cuda_fp16.h。

Functions

__host__ __device__ __half __double2half(const double a): 将双精度数字转换为半精度（采用四舍五入到最近的偶数模式），并返回带有转换值的half。
__host__ __device__ __half2 __float22half2_rn(const float2 a): 将float2数值的两个分量转换为半精度（采用四舍五入到最近的偶数模式），并返回包含转换后值的half2。
__host__ __device__ __half __float2half(const float a): 将浮点数转换为半精度（采用四舍五入到最接近的偶数模式），并返回带有转换值的half。
__host__ __device__ __half2 __float2half2_rn(const float a): 将输入转换为半精度（采用四舍五入到最近的偶数模式），并将转换后的值填充到half2的两个半部分中。
__host__ __device__ __half __float2half_rd(const float a): 将浮点数转换为半精度（向下舍入模式）并返回带有转换值的half。
__host__ __device__ __half __float2half_rn(const float a): 将浮点数转换为半精度（采用四舍五入到最接近的偶数模式），并返回带有转换值的half。
__host__ __device__ __half __float2half_ru(const float a): 将浮点数转换为半精度（向上舍入模式）并返回带有转换值的half。
__host__ __device__ __half __float2half_rz(const float a): 将浮点数转换为半精度（采用向零舍入模式），并返回带有转换值的half。
__host__ __device__ __half2 __floats2half2_rn(const float a, const float b): 将两个输入浮点数转换为半精度（采用四舍五入到最接近的偶数模式），并返回包含转换后值的half2。
__host__ __device__ float2 __half22float2(const __half2 a): 将half2的两半转换为float2并返回结果。
__host__ __device__ __half2::__half2(const __half2_raw &h2r): 从__half2_raw构造。
__host__ __device__ constexpr __half2::__half2(const __half &a, const __half &b): 从两个__half变量构造。
__host__ __device__ __half2::__half2(const __half2 &&src): 移动构造函数，适用于 C++11 及后续版本。
__host__ __device__ __half2::__half2(const __half2 &src): 拷贝构造函数。
__half2::__half2()=default: 默认构造函数。
__host__ __device__ __half2::operator __half2_raw() const: 转换为 __half2_raw 的转换运算符。
__host__ __device__ __half2 & __half2::operator=(const __half2_raw &h2r): 从 __half2_raw 的赋值运算符。
__host__ __device__ __half2 & __half2::operator=(const __half2 &&src): 移动赋值运算符，适用于 C++11 及后续版本。
__host__ __device__ __half2 & __half2::operator=(const __half2 &src): 复制赋值运算符。
__host__ __device__ signed char __half2char_rz(const __half h): 将半精度浮点数转换为有符号字符，采用向零舍入模式。
__host__ __device__ float __half2float(const __half a): 将half数字转换为浮点数。
__host__ __device__ __half2 __half2half2(const __half a): 返回一个half2，其两个半部分都等于输入值。
__device__ int __half2int_rd(const __half h): 将半精度浮点数转换为向下取整模式的有符号整数。
__device__ int __half2int_rn(const __half h): 将半精度浮点数转换为有符号整数，采用四舍五入到最接近的偶数模式。
__device__ int __half2int_ru(const __half h): 将半精度浮点数转换为带符号整数（向上取整模式）。
__host__ __device__ int __half2int_rz(const __half h): 将半精度浮点数转换为有符号整数，采用向零取整模式。
__device__ long long int __half2ll_rd(const __half h): 将半精度浮点数转换为有符号64位整数（向下取整模式）。
__device__ long long int __half2ll_rn(const __half h): 将半精度浮点数转换为带符号的64位整数，采用四舍五入到最近的偶数模式。
__device__ long long int __half2ll_ru(const __half h): 将半精度浮点数转换为带符号的64位整数（向上取整模式）。
__host__ __device__ long long int __half2ll_rz(const __half h): 将半精度浮点数转换为带符号的64位整数，采用向零取整模式。
__device__ short int __half2short_rd(const __half h): 将半精度浮点数转换为有符号短整数，采用向下舍入模式。
__device__ short int __half2short_rn(const __half h): 将半精度浮点数转换为带符号的短整型数，采用四舍五入到最接近的偶数模式。
__device__ short int __half2short_ru(const __half h): 将半精度浮点数转换为带符号的短整型，采用向上取整模式。
__host__ __device__ short int __half2short_rz(const __half h): 将半精度浮点数转换为带符号的短整型数，采用向零取整模式。
__host__ __device__ unsigned char __half2uchar_rz(const __half h): 将半精度浮点数转换为无符号字符，采用向零舍入模式。
__device__ unsigned int __half2uint_rd(const __half h): 将半精度浮点数转换为无符号整数，采用向下舍入模式。
__device__ unsigned int __half2uint_rn(const __half h): 将半精度浮点数转换为无符号整数，采用四舍五入到最接近的偶数模式。
__device__ unsigned int __half2uint_ru(const __half h): 将半精度浮点数转换为无符号整数，采用向上取整模式。
__host__ __device__ unsigned int __half2uint_rz(const __half h): 将半精度浮点数转换为无符号整数，采用向零舍入模式。
__device__ unsigned long long int __half2ull_rd(const __half h): 将半精度浮点数转换为无符号64位整数，采用向下舍入模式。
__device__ unsigned long long int __half2ull_rn(const __half h): 将半精度浮点数转换为无符号64位整数，采用四舍五入到最接近的偶数模式。
__device__ unsigned long long int __half2ull_ru(const __half h): 将半精度浮点数转换为无符号64位整数，采用向上取整模式。
__host__ __device__ unsigned long long int __half2ull_rz(const __half h): 将半精度浮点数转换为无符号64位整数，采用向零舍入模式。
__device__ unsigned short int __half2ushort_rd(const __half h): 将半精度浮点数转换为无符号短整型，采用向下舍入模式。
__device__ unsigned short int __half2ushort_rn(const __half h): 将半精度浮点数转换为无符号短整数，采用四舍五入到最接近的偶数模式。
__device__ unsigned short int __half2ushort_ru(const __half h): 将半精度浮点数转换为无符号短整型，采用向上取整模式。
__host__ __device__ unsigned short int __half2ushort_rz(const __half h): 将半精度浮点数转换为无符号短整型，采用向零舍入模式。
__host__ __device__ constexpr __half::__half(const __half_raw &hr): 从__half_raw构造。
__host__ __device__ __half::__half(const unsigned short val): 使用默认的舍入到最近偶数模式，从unsigned short整型输入构造__half。
__host__ __device__ __half::__half(const unsigned int val): 使用默认的舍入到最近偶数模式，从unsigned int输入构造__half。
__host__ __device__ __half::__half(const short val): 使用默认的舍入到最近偶数模式，从short整数输入构造__half。
__host__ __device__ __half::__half(const double f): 使用默认的舍入到最近偶数舍入模式从double输入构造__half。
__host__ __device__ __half::__half(const unsigned long val): 使用默认的舍入到最近偶数模式，从unsigned long输入构造__half。
__host__ __device__ __half::__half(const float f): 使用默认的舍入到最近偶数舍入模式，从float输入构造__half。
__host__ __device__ __half::__half(const int val): 使用默认的舍入到最近偶数舍入模式，从int输入构造__half。
__host__ __device__ __half::__half(const long val): 使用默认的舍入到最近偶数舍入模式，从long输入构造__half。
__host__ __device__ __half::__half(const long long val): 使用默认的舍入到最近偶数模式从long long输入构造__half。
__half::__half()=default: 默认构造函数。
__host__ __device__ __half::__half(const __nv_bfloat16 f): 使用默认的舍入到最近偶数模式，从__nv_bfloat16输入构造__half。
__host__ __device__ __half::__half(const unsigned long long val): 使用默认的舍入到最近偶数模式，从unsigned long long输入构造__half。
__host__ __device__ __half::operator __half_raw() const volatile: 将类型转换为__half_raw运算符，输入为volatile。
__host__ __device__ __half::operator __half_raw() const: 类型转换为 __half_raw 运算符。
__host__ __device__ constexpr __half::operator bool() const: 转换为bool数据类型的转换运算符。
__host__ __device__ __half::operator char() const: 转换为实现定义的 char 数据类型的转换运算符。
__host__ __device__ __half::operator float() const: 类型转换为 float 操作符。
__host__ __device__ __half::operator int() const: 转换为int数据类型的转换运算符。
__host__ __device__ __half::operator long() const: 转换为long数据类型的转换运算符。
__host__ __device__ __half::operator long long() const: 转换为 long long 数据类型的转换运算符。
__host__ __device__ __half::operator short() const: 转换为 short 数据类型的转换运算符。
__host__ __device__ __half::operator signed char() const: 转换为signed char数据类型的转换运算符。
__host__ __device__ __half::operator unsigned char() const: 转换为 unsigned char 数据类型的转换运算符。
__host__ __device__ __half::operator unsigned int() const: 转换为unsigned int数据类型的转换运算符。
__host__ __device__ __half::operator unsigned long() const: 转换为 unsigned long 数据类型的转换运算符。
__host__ __device__ __half::operator unsigned long long() const: 转换为 unsigned long long 数据类型的转换运算符。
__host__ __device__ __half::operator unsigned short() const: 转换为unsigned short数据类型的转换运算符。
__host__ __device__ __half & __half::operator=(const float f): 使用默认的舍入到最近偶数模式，将float输入类型转换为__half的赋值运算符。
__host__ __device__ volatile __half & __half::operator=(const volatile __half_raw &hr) volatile: 从volatile __half_raw到volatile __half的赋值运算符。
__host__ __device__ __half & __half::operator=(const long long val): 从long long赋值运算符进行类型转换，使用默认的向最近偶数舍入模式。
__host__ __device__ volatile __half & __half::operator=(const __half_raw &hr) volatile: 从__half_raw到volatile __half的赋值运算符。
__host__ __device__ __half & __half::operator=(const unsigned int val): 从unsigned int赋值操作符进行类型转换，使用默认的向最近偶数舍入模式。
__host__ __device__ __half & __half::operator=(const unsigned short val): 从unsigned short类型转换的赋值运算符，使用默认的向最近偶数舍入模式。
__host__ __device__ __half & __half::operator=(const short val): 从short类型转换的赋值运算符，使用默认的向最近偶数舍入模式。
__host__ __device__ __half & __half::operator=(const double f): 使用默认的舍入到最近偶数舍入模式，将double输入类型转换为__half赋值运算符。
__host__ __device__ __half & __half::operator=(const __half_raw &hr): 从__half_raw的赋值运算符。
__host__ __device__ __half & __half::operator=(const unsigned long long val): 从unsigned long long类型转换的赋值运算符，使用默认的向最近偶数舍入模式。
__host__ __device__ __half & __half::operator=(const int val): 从int类型转换的赋值运算符，使用默认的向最近偶数舍入模式。
__host__ __device__ short int __half_as_short(const __half h): 将half中的位重新解释为有符号短整数。
__host__ __device__ unsigned short int __half_as_ushort(const __half h): 将half中的位重新解释为无符号短整数。
__host__ __device__ __half2 __halves2half2(const __half a, const __half b): 将两个half数值合并为一个half2数值。
__host__ __device__ float __high2float(const __half2 a): 将half2的高16位转换为浮点数并返回结果。
__host__ __device__ __half __high2half(const __half2 a): 返回half2输入的高16位。
__host__ __device__ __half2 __high2half2(const __half2 a): 从half2输入中提取高16位。
__host__ __device__ __half2 __highs2half2(const __half2 a, const __half2 b): 从两个half2输入中分别提取高16位，并组合成一个half2数值。
__host__ __device__ __half __int2half_rd(const int i): 将有符号整数转换为半精度浮点数，采用向下舍入模式。
__host__ __device__ __half __int2half_rn(const int i): 将有符号整数转换为半精度浮点数，采用四舍五入到最近的偶数模式。
__host__ __device__ __half __int2half_ru(const int i): 将有符号整数转换为半精度浮点数，采用向上舍入模式。
__host__ __device__ __half __int2half_rz(const int i): 将有符号整数转换为半精度浮点数，采用向零舍入模式。
__device__ __half2 __ldca(const __half2 *const ptr): 生成一条ld.global.ca加载指令。
__device__ __half __ldca(const __half *const ptr): 生成一条ld.global.ca加载指令。
__device__ __half __ldcg(const __half *const ptr): 生成一条ld.global.cg加载指令。
__device__ __half2 __ldcg(const __half2 *const ptr): 生成一条ld.global.cg加载指令。
__device__ __half __ldcs(const __half *const ptr): 生成一条ld.global.cs加载指令。
__device__ __half2 __ldcs(const __half2 *const ptr): 生成一条ld.global.cs加载指令。
__device__ __half2 __ldcv(const __half2 *const ptr): 生成一条ld.global.cv加载指令。
__device__ __half __ldcv(const __half *const ptr): 生成一条ld.global.cv加载指令。
__device__ __half2 __ldg(const __half2 *const ptr): 生成一条ld.global.nc加载指令。
__device__ __half __ldg(const __half *const ptr): 生成一条ld.global.nc加载指令。
__device__ __half __ldlu(const __half *const ptr): 生成一条ld.global.lu加载指令。
__device__ __half2 __ldlu(const __half2 *const ptr): 生成一条ld.global.lu加载指令。
__host__ __device__ __half __ll2half_rd(const long long int i): 将有符号64位整数转换为半精度浮点数（采用向下舍入模式）。
__host__ __device__ __half __ll2half_rn(const long long int i): 将有符号64位整数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。
__host__ __device__ __half __ll2half_ru(const long long int i): 将有符号64位整数转换为半精度浮点数，采用向上舍入模式。
__host__ __device__ __half __ll2half_rz(const long long int i): 将有符号64位整数转换为半精度浮点数，采用向零舍入模式。
__host__ __device__ float __low2float(const __half2 a): 将half2的低16位转换为float并返回结果。
__host__ __device__ __half __low2half(const __half2 a): 返回half2输入的低16位。
__host__ __device__ __half2 __low2half2(const __half2 a): 从half2输入中提取低16位。
__host__ __device__ __half2 __lowhigh2highlow(const __half2 a): 交换half2输入的两半部分。
__host__ __device__ __half2 __lows2half2(const __half2 a, const __half2 b): 从两个half2输入中各提取低16位，并组合成一个half2数值。
__device__ __half __shfl_down_sync(const unsigned int mask, const __half var, const unsigned int delta, const int width=warpSize): 在线程束内的线程之间交换变量。
__device__ __half2 __shfl_down_sync(const unsigned int mask, const __half2 var, const unsigned int delta, const int width=warpSize): 在线程束内的线程之间交换变量。
__device__ __half2 __shfl_sync(const unsigned int mask, const __half2 var, const int srcLane, const int width=warpSize): 在线程束内的线程之间交换变量。
__device__ __half __shfl_sync(const unsigned int mask, const __half var, const int srcLane, const int width=warpSize): 在线程束内的线程之间交换变量。
__device__ __half2 __shfl_up_sync(const unsigned int mask, const __half2 var, const unsigned int delta, const int width=warpSize): 在线程束内的线程之间交换变量。
__device__ __half __shfl_up_sync(const unsigned int mask, const __half var, const unsigned int delta, const int width=warpSize): 在线程束内的线程之间交换变量。
__device__ __half2 __shfl_xor_sync(const unsigned int mask, const __half2 var, const int laneMask, const int width=warpSize): 在线程束内的线程之间交换变量。
__device__ __half __shfl_xor_sync(const unsigned int mask, const __half var, const int laneMask, const int width=warpSize): 在线程束内的线程之间交换变量。
__host__ __device__ __half __short2half_rd(const short int i): 将有符号短整数转换为半精度浮点数，采用向下舍入模式。
__host__ __device__ __half __short2half_rn(const short int i): 将有符号短整数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。
__host__ __device__ __half __short2half_ru(const short int i): 将有符号短整数转换为半精度浮点数，采用向上舍入模式。
__host__ __device__ __half __short2half_rz(const short int i): 将有符号短整型转换为半精度浮点数，采用向零舍入模式。
__host__ __device__ __half __short_as_half(const short int i): 将带符号短整型中的位重新解释为half。
__device__ void __stcg(__half2 *const ptr, const __half2 value): 生成一条st.global.cg存储指令。
__device__ void __stcg(__half *const ptr, const __half value): 生成一条st.global.cg存储指令。
__device__ void __stcs(__half2 *const ptr, const __half2 value): 生成一条st.global.cs存储指令。
__device__ void __stcs(__half *const ptr, const __half value): 生成一条st.global.cs存储指令。
__device__ void __stwb(__half2 *const ptr, const __half2 value): 生成一条st.global.wb存储指令。
__device__ void __stwb(__half *const ptr, const __half value): 生成一条st.global.wb存储指令。
__device__ void __stwt(__half *const ptr, const __half value): 生成一条st.global.wt存储指令。
__device__ void __stwt(__half2 *const ptr, const __half2 value): 生成一条st.global.wt存储指令。
__host__ __device__ __half __uint2half_rd(const unsigned int i): 将一个无符号整数转换为半精度浮点数，采用向下舍入模式。
__host__ __device__ __half __uint2half_rn(const unsigned int i): 将一个无符号整数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。
__host__ __device__ __half __uint2half_ru(const unsigned int i): 将一个无符号整数转换为半精度浮点数，采用向上舍入模式。
__host__ __device__ __half __uint2half_rz(const unsigned int i): 将一个无符号整数转换为半精度浮点数，采用向零舍入模式。
__host__ __device__ __half __ull2half_rd(const unsigned long long int i): 将一个无符号64位整数转换为半精度浮点数，采用向下舍入模式。
__host__ __device__ __half __ull2half_rn(const unsigned long long int i): 将一个无符号64位整数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。
__host__ __device__ __half __ull2half_ru(const unsigned long long int i): 将一个无符号64位整数转换为半精度浮点数，采用向上舍入模式。
__host__ __device__ __half __ull2half_rz(const unsigned long long int i): 将一个无符号64位整数转换为半精度浮点数，采用向零舍入模式。
__host__ __device__ __half __ushort2half_rd(const unsigned short int i): 将一个无符号短整型数转换为半精度浮点数，采用向下舍入模式。
__host__ __device__ __half __ushort2half_rn(const unsigned short int i): 将一个无符号短整型数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。
__host__ __device__ __half __ushort2half_ru(const unsigned short int i): 将一个无符号短整数转换为半精度浮点数，采用向上舍入模式。
__host__ __device__ __half __ushort2half_rz(const unsigned short int i): 将一个无符号短整型数转换为半精度浮点数，采用向零舍入模式。
__host__ __device__ __half __ushort_as_half(const unsigned short int i): 将无符号短整数的位重新解释为half。
__host__ __device__ __half2 make_half2(const __half x, const __half y): 向量函数，将两个__half数值合并为一个__half2数值。

4.5.1. 功能

__host__ __device__ __half __double2half(const double a)

将双精度数字转换为半精度（采用四舍五入到最接近的偶数模式），并返回带有转换值的half。

将双精度数字 a 转换为半精度，采用四舍五入到最接近的偶数模式。

Parameters

a – [输入] - double类型。仅用于读取。

Returns

半精度

a 使用四舍五入到最近偶数模式转换为半精度。
__double2half \( (\pm 0)\) 返回 \( \pm 0 \)。
__double2half \( (\pm \infty)\) 返回 \( \pm \infty \)。
__double2half(NaN) 返回 NaN。

__host__ __device__ __half2 __float22half2_rn(const float2 a)

将float2数值的两个分量转换为半精度（采用四舍五入到最接近偶数的舍入模式），并返回包含转换后值的half2。

将float2的两个分量转换为半精度（采用四舍五入到最接近偶数模式），并将结果组合成一个half2数值。返回值的低16位对应a.x，高16位对应a.y。

另请参阅

__float2half_rn(float) 更多详情请参阅。

Parameters

a – [输入] - float2类型。仅用于读取。

Returns

half2

half2 对应的半精度值与转换后的 float2 分量相等。

__host__ __device__ __half __float2half(const float a)

将浮点数转换为半精度（采用四舍五入到最接近的偶数模式），并返回带有转换值的half。

将浮点数 a 转换为半精度，采用四舍五入到最接近的偶数模式。

另请参阅

__float2half_rn(float) 更多详情请参阅。

Parameters

a – [输入] - 浮点数。仅用于读取。

Returns

半精度

a 使用四舍五入到最近偶数模式转换为半精度。

__host__ __device__ __half2 __float2half2_rn(const float a)

将输入转换为半精度（采用四舍五入到最近的偶数模式），并将转换后的值填充到half2的两个半部分中。

将输入a转换为半精度（采用四舍五入到最近的偶数模式），并将转换后的值填充到half2的两个半部分中。

另请参阅

__float2half_rn(float) 更多详情请参阅。

Parameters

a – [输入] - 浮点数。仅用于读取。

Returns

half2

一个half2值，其两个半部分都等于转换后的半精度数值。

__host__ __device__ __half __float2half_rd(const float a)

将浮点数转换为半精度（向下舍入模式）并返回带有转换值的half。

将浮点数 a 转换为半精度（向下舍入模式）。

Parameters

a – [输入] - 浮点数。仅用于读取。

Returns

半精度

a 使用向下舍入模式转换为半精度。
__float2half_rd \( (\pm 0)\) 返回 \( \pm 0 \)。
__float2half_rd \( (\pm \infty)\) 返回 \( \pm \infty \)。
__float2half_rd(NaN) 返回 NaN。

__host__ __device__ __half __float2half_rn(const float a)

将浮点数转换为半精度（采用四舍五入到最接近的偶数模式），并返回带有转换值的half。

将浮点数 a 转换为半精度，采用四舍五入到最近的偶数模式。

Parameters

a – [输入] - 浮点数。仅用于读取。

Returns

半精度

a 使用四舍五入到最近偶数模式转换为半精度。
__float2half_rn \( (\pm 0)\) 返回 \( \pm 0 \)。
__float2half_rn \( (\pm \infty)\) 返回 \( \pm \infty \)。
__float2half_rn(NaN) 返回 NaN。

__host__ __device__ __half __float2half_ru(const float a)

将浮点数转换为半精度（向上舍入模式）并返回带有转换值的half。

将浮点数 a 转换为半精度，采用向上取整模式。

Parameters

a – [输入] - 浮点数。仅用于读取。

Returns

半精度

a 使用向上取整模式转换为半精度。
__float2half_ru \( (\pm 0)\) 返回 \( \pm 0 \)。
__float2half_ru \( (\pm \infty)\) 返回 \( \pm \infty \)。
__float2half_ru(NaN) 返回 NaN。

__host__ __device__ __half __float2half_rz(const float a)

将浮点数转换为半精度（采用向零舍入模式），并返回带有转换后值的half。

将浮点数 a 转换为半精度，采用向零舍入模式。

Parameters

a – [输入] - 浮点数。仅用于读取。

Returns

半精度

a 使用向零舍入模式转换为半精度。
__float2half_rz \( (\pm 0)\) 返回 \( \pm 0 \)。
__float2half_rz \( (\pm \infty)\) 返回 \( \pm \infty \)。
__float2half_rz(NaN) 返回 NaN。

__host__ __device__ __half2 __floats2half2_rn(const float a, const float b)

将两个输入的浮点数转换为半精度（采用四舍五入到最接近的偶数模式），并返回包含转换后值的half2。

将两个输入浮点数转换为半精度（采用四舍五入到最近的偶数模式），并将结果组合成一个half2数值。返回值的低16位对应输入a，高16位对应输入b。

另请参阅

__float2half_rn(float) 更多详情请参阅。

Parameters

a – [输入] - 浮点数。仅用于读取。
b – [输入] - 浮点数。仅用于读取。

Returns

half2

对应的半精度值等于转换后的输入浮点数的half2值。

__host__ __device__ float2 __half22float2(const __half2 a)

将half2的两个部分都转换为float2并返回结果。

将half2输入a的两半转换为float2并返回结果。

另请参阅

__half2float(__half) 更多详情请参阅。

Parameters

a – [输入] - half2类型。仅用于读取。

Returns

float2

a 转换为 float2。

__host__ __device__ signed char __half2char_rz(const __half h)

将半精度浮点数转换为有符号字符，采用向零舍入模式。

将半精度浮点值 h 转换为有符号字符整数，采用向零取整模式。NaN输入将被转换为0。

Parameters

h – [输入] - 半精度浮点数。仅用于读取。

Returns

有符号字符

h 使用向零舍入模式转换为有符号字符。
__half2char_rz \( (\pm 0)\) 返回0。
__half2char_rz \( (x), x > 127\) 返回 SCHAR_MAX = 0x7F。
__half2char_rz \( (x), x < -128\) 返回 SCHAR_MIN = 0x80。
__half2char_rz(NaN) 返回 0。

__host__ __device__ float __half2float(const __half a)

将half数字转换为浮点数。

将半精度数字 a 转换为浮点数。

Parameters

a – [输入] - 浮点数。仅用于读取。

Returns

浮点数

a 转换为浮点数。
__half2float \( (\pm 0)\) 返回 \( \pm 0 \)。
__half2float \( (\pm \infty)\) 返回 \( \pm \infty \)。
__half2float(NaN) 返回 NaN。

__host__ __device__ __half2 __half2half2(const __half a)

返回一个half2，其两个半部分都等于输入值。

返回一个half2数值，其两个部分均等于输入的ahalf数值。

Parameters

a – [输入] - 半精度。仅用于读取。

Returns

half2

向量，其两半均等于输入 a。

__device__ int __half2int_rd(const __half h)

将半精度浮点数转换为向下取整模式的有符号整数。

将半精度浮点值h转换为向下取整模式的有符号整数。NaN输入会被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

int

h 使用向下取整模式转换为有符号整数。
__half2int_rd \( (\pm 0)\) 返回 0。
__half2int_rd \( (+\infty)\) 返回 INT_MAX = 0x7FFFFFFF。
__half2int_rd \( (-\infty)\) 返回 INT_MIN = 0x80000000。
__half2int_rd(NaN) 返回 0。

__device__ int __half2int_rn(const __half h)

将半精度浮点数转换为有符号整数，采用四舍五入到最近的偶数模式。

将半精度浮点值h转换为采用四舍五入到最近偶数模式的带符号整数。NaN输入会被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

int

h 使用四舍五入到最近偶数模式转换为有符号整数。
__half2int_rn \( (\pm 0)\) 返回0。
__half2int_rn \( (+\infty)\) 返回 INT_MAX = 0x7FFFFFFF。
__half2int_rn \( (-\infty)\) 返回 INT_MIN = 0x80000000。
__half2int_rn(NaN) 返回 0。

__device__ int __half2int_ru(const __half h)

将半精度浮点数转换为有符号整数，采用向上取整模式。

将半精度浮点值h转换为向上取整模式的有符号整数。NaN输入将被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

int

h 使用向上取整模式转换为有符号整数。
__half2int_ru \( (\pm 0)\) 返回 0。
__half2int_ru \( (+\infty)\) 返回 INT_MAX = 0x7FFFFFFF。
__half2int_ru \( (-\infty)\) 返回 INT_MIN = 0x80000000。
__half2int_ru(NaN) 返回 0。

__host__ __device__ int __half2int_rz(const __half h)

将半精度浮点数转换为有符号整数，采用向零取整模式。

将半精度浮点值h转换为向零取整模式下的有符号整数。NaN输入会被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

int

h 使用向零取整模式转换为有符号整数。
__half2int_rz \( (\pm 0)\) 返回0。
__half2int_rz \( (+\infty)\) 返回 INT_MAX = 0x7FFFFFFF。
__half2int_rz \( (-\infty)\) 返回 INT_MIN = 0x80000000。
__half2int_rz(NaN) 返回 0。

__device__ long long int __half2ll_rd(const __half h)

将半精度浮点数转换为有符号64位整数，采用向下取整模式。

将半精度浮点值h转换为向下舍入模式下的有符号64位整数。NaN输入将返回十六进制值为0x8000000000000000的long long int类型。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

长整型

h 使用向下取整模式转换为有符号64位整数。
__half2ll_rd \( (\pm 0)\) 返回0。
__half2ll_rd \( (+\infty)\) 返回 LLONG_MAX = 0x7FFFFFFFFFFFFFFF。
__half2ll_rd \( (-\infty)\) 返回 LLONG_MIN = 0x8000000000000000。
__half2ll_rd(NaN) 返回 0x8000000000000000。

__device__ long long int __half2ll_rn(const __half h)

将半精度浮点数转换为带符号的64位整数，采用四舍五入到最近的偶数模式。

将半精度浮点值h转换为采用四舍五入到最近偶数模式的有符号64位整数。NaN输入将返回十六进制值为0x8000000000000000的long long int类型。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

长整型

h 使用四舍五入到最近偶数模式转换为有符号64位整数。
__half2ll_rn \( (\pm 0)\) 返回0。
__half2ll_rn \( (+\infty)\) 返回 LLONG_MAX = 0x7FFFFFFFFFFFFFFF。
__half2ll_rn \( (-\infty)\) 返回 LLONG_MIN = 0x8000000000000000。
__half2ll_rn(NaN) 返回 0x8000000000000000。

__device__ long long int __half2ll_ru(const __half h)

将半精度浮点数转换为带符号的64位整数，采用向上取整模式。

将半精度浮点值h转换为向上取整模式下的有符号64位整数。NaN输入将返回十六进制值为0x8000000000000000的long long int类型。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

长整型

h 使用向上取整模式转换为有符号64位整数。
__half2ll_ru \( (\pm 0)\) 返回 0。
__half2ll_ru \( (+\infty)\) 返回 LLONG_MAX = 0x7FFFFFFFFFFFFFFF。
__half2ll_ru \( (-\infty)\) 返回 LLONG_MIN = 0x8000000000000000。
__half2ll_ru(NaN) 返回 0x8000000000000000。

__host__ __device__ long long int __half2ll_rz(const __half h)

将半精度浮点数转换为带符号的64位整数，采用向零取整模式。

将半精度浮点值h转换为采用向零取整模式的有符号64位整数。NaN输入将返回十六进制值为0x8000000000000000的long long int类型。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

长整型

h 使用向零舍入模式转换为有符号64位整数。
__half2ll_rz \( (\pm 0)\) 返回0。
__half2ll_rz \( (+\infty)\) 返回 LLONG_MAX = 0x7FFFFFFFFFFFFFFF。
__half2ll_rz \( (-\infty)\) 返回 LLONG_MIN = 0x8000000000000000。
__half2ll_rz(NaN) 返回 0x8000000000000000。

__device__ short int __half2short_rd(const __half h)

将半精度浮点数转换为有符号短整数，采用向下舍入模式。

将半精度浮点值h转换为舍入模式下的有符号短整数。NaN输入将被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

短整型

h 使用向下取整模式转换为有符号短整型。
__half2short_rd \( (\pm 0)\) 返回0。
__half2short_rd \( (x), x > 32767\) 返回 SHRT_MAX = 0x7FFF。
__half2short_rd \( (x), x < -32768\) 返回 SHRT_MIN = 0x8000。
__half2short_rd(NaN) 返回 0。

__device__ short int __half2short_rn(const __half h)

将半精度浮点数转换为带符号的短整型数，采用四舍五入到最接近的偶数模式。

将半精度浮点值h转换为采用四舍五入到最近偶数模式的有符号短整型。NaN输入将被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

短整型

h 使用四舍五入到最近偶数模式转换为有符号短整型。
__half2short_rn \( (\pm 0)\) 返回0。
__half2short_rn \( (x), x > 32767\) 返回 SHRT_MAX = 0x7FFF。
__half2short_rn \( (x), x < -32768\) 返回 SHRT_MIN = 0x8000。
__half2short_rn(NaN) 返回 0。

__device__ short int __half2short_ru(const __half h)

将半精度浮点数转换为带符号的短整型，采用向上取整模式。

将半精度浮点值h转换为向上取整模式的有符号短整数。NaN输入将被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

短整型

h 使用向上取整模式转换为有符号短整型。
__half2short_ru \( (\pm 0)\) 返回0。
__half2short_ru \( (x), x > 32767\) 返回 SHRT_MAX = 0x7FFF。
__half2short_ru \( (x), x < -32768\) 返回 SHRT_MIN = 0x8000。
__half2short_ru(NaN) 返回 0。

__host__ __device__ short int __half2short_rz(const __half h)

将半精度浮点数转换为带符号的短整型，采用向零取整模式。

将半精度浮点值h转换为向零取整模式下的有符号短整数。NaN输入将被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

短整型

h 使用向零取整模式转换为有符号短整型。
__half2short_rz \( (\pm 0)\) 返回0。
__half2short_rz \( (x), x > 32767\) 返回 SHRT_MAX = 0x7FFF。
__half2short_rz \( (x), x < -32768\) 返回 SHRT_MIN = 0x8000。
__half2short_rz(NaN) 返回 0。

__host__ __device__ unsigned char __half2uchar_rz(const __half h)

将半精度浮点数转换为无符号字符，采用向零舍入模式。

将半精度浮点值h转换为无符号字符，采用向零舍入模式。NaN输入会被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号字符

h 使用向零舍入模式转换为无符号字符。
__half2uchar_rz \( (\pm 0)\) 返回 0。
__half2uchar_rz \( (x), x > 255\) 返回 UCHAR_MAX = 0xFF。
__half2uchar_rz \( (x), x < 0.0\) 返回0。
__half2uchar_rz(NaN) 返回 0。

__device__ unsigned int __half2uint_rd(const __half h)

将半精度浮点数转换为无符号整数，采用向下舍入模式。

将半精度浮点值h转换为向下取整模式的无符号整数。NaN输入会被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号整数

h 使用向下取整模式转换为无符号整数。
__half2uint_rd \( (\pm 0)\) 返回0。
__half2uint_rd \( (+\infty)\) 返回 UINT_MAX = 0xFFFFFFFF。
__half2uint_rd \( (x), x < 0.0\) 当x小于0时返回0。
__half2uint_rd(NaN) 返回 0。

__device__ unsigned int __half2uint_rn(const __half h)

将半精度浮点数转换为无符号整数，采用四舍五入到最接近的偶数模式。

将半精度浮点值h转换为采用四舍五入到最近偶数模式的无符号整数。NaN输入会被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号整数

h 使用四舍五入到最近偶数模式转换为无符号整数。
__half2uint_rn \( (\pm 0)\) 返回 0。
__half2uint_rn \( (+\infty)\) 返回 UINT_MAX = 0xFFFFFFFF。
__half2uint_rn \( (x), x < 0.0\) 返回0。
__half2uint_rn(NaN) 返回 0。

__device__ unsigned int __half2uint_ru(const __half h)

将半精度浮点数转换为无符号整数，采用向上取整模式。

将半精度浮点值 h 转换为向上取整模式的无符号整数。NaN输入会被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号整型

h 使用向上取整模式转换为无符号整数。
__half2uint_ru \( (\pm 0)\) 返回0。
__half2uint_ru \( (+\infty)\) 返回 UINT_MAX = 0xFFFFFFFF。
__half2uint_ru \( (x), x < 0.0\) 返回0。
__half2uint_ru(NaN) 返回 0。

__host__ __device__ unsigned int __half2uint_rz(const __half h)

将半精度浮点数转换为无符号整数，采用向零舍入模式。

将半精度浮点值h转换为向零取整模式的无符号整数。NaN输入会被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号整数

h 使用向零舍入模式转换为无符号整数。
__half2uint_rz \( (\pm 0)\) 返回 0。
__half2uint_rz \( (+\infty)\) 返回 UINT_MAX = 0xFFFFFFFF。
__half2uint_rz \( (x), x < 0.0\) 返回0。
__half2uint_rz(NaN) 返回 0。

__device__ unsigned long long int __half2ull_rd(const __half h)

将半精度浮点数转换为无符号64位整数，采用向下取整模式。

将半精度浮点值h转换为无符号64位整数（向下舍入模式）。NaN输入返回0x8000000000000000。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号长整型

h 使用向下取整模式转换为无符号64位整数。
__half2ull_rd \( (\pm 0)\) 返回 0。
__half2ull_rd \( (+\infty)\) 返回 ULLONG_MAX = 0xFFFFFFFFFFFFFFFF。
__half2ull_rd \( (x), x < 0.0\) 返回0。
__half2ull_rd(NaN) 返回 0x8000000000000000。

__device__ unsigned long long int __half2ull_rn(const __half h)

将半精度浮点数转换为无符号64位整数，采用四舍五入到最接近的偶数模式。

将半精度浮点值h转换为无符号64位整数，采用四舍五入到最近的偶数模式。NaN输入返回0x8000000000000000。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号长整型

h 使用四舍五入到最近偶数模式转换为无符号64位整数。
__half2ull_rn \( (\pm 0)\) 返回0。
__half2ull_rn \( (+\infty)\) 返回 ULLONG_MAX = 0xFFFFFFFFFFFFFFFF。
__half2ull_rn \( (x), x < 0.0\) 返回0。
__half2ull_rn(NaN) 返回 0x8000000000000000。

__device__ unsigned long long int __half2ull_ru(const __half h)

将半精度浮点数转换为无符号64位整数，采用向上取整模式。

将半精度浮点值h转换为无符号64位整数（向上舍入模式）。NaN输入返回0x8000000000000000。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号长整型

h 使用向上取整模式转换为无符号64位整数。
__half2ull_ru \( (\pm 0)\) 返回0。
__half2ull_ru \( (+\infty)\) 返回 ULLONG_MAX = 0xFFFFFFFFFFFFFFFF。
__half2ull_ru \( (x), x < 0.0\) 返回0。
__half2ull_ru(NaN) 返回 0x8000000000000000。

__host__ __device__ unsigned long long int __half2ull_rz(const __half h)

将半精度浮点数转换为无符号64位整数，采用向零舍入模式。

将半精度浮点值h转换为无符号64位整数（采用向零舍入模式）。NaN输入将返回0x8000000000000000。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号长整型

h 使用向零舍入模式转换为无符号64位整数。
__half2ull_rz \( (\pm 0)\) 返回0。
__half2ull_rz \( (+\infty)\) 返回 ULLONG_MAX = 0xFFFFFFFFFFFFFFFF。
__half2ull_rz \( (x), x < 0.0\) 当x小于0时返回0。
__half2ull_rz(NaN) 返回 0x8000000000000000。

__device__ unsigned short int __half2ushort_rd(const __half h)

将半精度浮点数转换为无符号短整型，采用向下舍入模式。

将半精度浮点值h转换为向下舍入模式的无符号短整型。NaN输入将被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号短整型

h 使用向下取整模式转换为无符号短整型。
__half2ushort_rd \( (\pm 0)\) 返回0。
__half2ushort_rd \( (+\infty)\) 返回 USHRT_MAX = 0xFFFF。
__half2ushort_rd \( (x), x < 0.0\) 当x小于0时返回0。
__half2ushort_rd(NaN) 返回 0。

__device__ unsigned short int __half2ushort_rn(const __half h)

将半精度浮点数转换为无符号短整数，采用四舍五入到最接近的偶数模式。

将半精度浮点值 h 转换为无符号短整型，采用四舍五入到最接近的偶数模式。NaN输入将被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号短整型

h 使用四舍五入到最近偶数模式转换为无符号短整型。
__half2ushort_rn \( (\pm 0)\) 返回0。
__half2ushort_rn \( (+\infty)\) 返回 USHRT_MAX = 0xFFFF。
__half2ushort_rn \( (x), x < 0.0\) 当x小于0时返回0。
__half2ushort_rn(NaN) 返回 0。

__device__ unsigned short int __half2ushort_ru(const __half h)

将半精度浮点数转换为无符号短整型，采用向上取整模式。

将半精度浮点值h转换为向上取整模式的无符号短整数。NaN输入会被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号短整型

h 使用向上取整模式转换为无符号短整型。
__half2ushort_ru \( (\pm 0)\) 返回0。
__half2ushort_ru \( (+\infty)\) 返回 USHRT_MAX = 0xFFFF。
__half2ushort_ru \( (x), x < 0.0\) 当x小于0时返回0。
__half2ushort_ru(NaN) 返回 0。

__host__ __device__ unsigned short int __half2ushort_rz(const __half h)

将半精度浮点数转换为无符号短整型，采用向零舍入模式。

将半精度浮点值h以向零取整模式转换为无符号短整型。NaN输入将被转换为0。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号短整型

h 使用向零舍入模式转换为无符号短整数。
__half2ushort_rz \( (\pm 0)\) 返回0。
__half2ushort_rz \( (+\infty)\) 返回 USHRT_MAX = 0xFFFF。
__half2ushort_rz \( (x), x < 0.0\) 返回0。
__half2ushort_rz(NaN) 返回 0。

__host__ __device__ short int __half_as_short(const __half h)

将half中的位重新解释为有符号短整数。

将半精度浮点数 h 中的位重新解释为有符号短整型。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

短整型

重新解释后的值。

__host__ __device__ unsigned short int __half_as_ushort(const __half h)

将half中的位重新解释为无符号短整型。

将半精度浮点数 h 的位重新解释为无符号短整型数。

Parameters

h – [输入] - 半精度。仅用于读取。

Returns

无符号短整型

重新解释后的值。

__host__ __device__ __half2 __halves2half2(const __half a, const __half b)

将两个half数值合并为一个half2数值。

将两个输入的half数值a和b合并为一个half2数值。输入a存储在返回值的低16位，输入b存储在高16位。

Parameters

a – [输入] - 半精度。仅用于读取。
b – [输入] - 半精度。仅用于读取。

Returns

half2

一个half2，其中一半等于a，另一半等于b。

__host__ __device__ float __high2float(const __half2 a)

将half2的高16位转换为浮点数并返回结果。

将half2输入a的高16位转换为32位浮点数并返回结果。

另请参阅

__half2float(__half) 更多详情请参阅。

Parameters

a – [输入] - half2类型。仅用于读取。

Returns

浮点数

a的高16位转换为浮点数。

__host__ __device__ __half __high2half(const __half2 a)

返回half2输入的高16位。

返回half2输入a的高16位。

Parameters

a – [输入] - half2类型。仅用于读取。

Returns

半精度

输入的高16位。

__host__ __device__ __half2 __high2half2(const __half2 a)

从half2输入中提取高16位。

从half2输入a中提取高16位，并返回一个新的half2数值，其高低半部分均等于所提取的位。

Parameters

a – [输入] - half2类型。仅用于读取。

Returns

half2

half2的两个半部分均等于输入的高16位。

__host__ __device__ __half2 __highs2half2(const __half2 a, const __half2 b)

从两个half2输入中分别提取高16位，并组合成一个half2数值。

从两个half2输入中分别提取高16位，并组合成一个half2数值。输入a的高16位存储在返回值的低16位中，输入b的高16位存储在返回值的高16位中。

Parameters

a – [输入] - half2类型。仅用于读取。
b – [输入] - half2类型。仅用于读取。

Returns

half2

a 和 b 的高16位。

__host__ __device__ __half __int2half_rd(const int i)

将有符号整数转换为半精度浮点数，采用向下舍入模式。

将有符号整数值 i 转换为向下舍入模式的半精度浮点值。

Parameters

i – [输入] - 整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __int2half_rn(const int i)

将有符号整数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。

将有符号整数值 i 转换为采用四舍五入到最近偶数模式的半精度浮点值。

Parameters

i – [输入] - 整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __int2half_ru(const int i)

将有符号整数转换为半精度浮点数，采用向上舍入模式。

将有符号整数值 i 转换为采用向上舍入模式的半精度浮点值。

Parameters

i – [输入] - 整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __int2half_rz(const int i)

将有符号整数转换为半精度浮点数，采用向零舍入模式。

将有符号整数值 i 转换为采用向零舍入模式的半精度浮点值。

Parameters

i – [输入] - 整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__device__ __half2 __ldca(const __half2 *const ptr)

生成一条ld.global.ca加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half __ldca(const __half *const ptr)

生成一条ld.global.ca加载指令。

Parameters: ptr – [输入] - 内存地址
Returns: ptr 所指向的值

__device__ __half __ldcg(const __half *const ptr)

生成一条ld.global.cg加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half2 __ldcg(const __half2 *const ptr)

生成一条ld.global.cg加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half __ldcs(const __half *const ptr)

生成一条ld.global.cs加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half2 __ldcs(const __half2 *const ptr)

生成一条ld.global.cs加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half2 __ldcv(const __half2 *const ptr)

生成一条ld.global.cv加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half __ldcv(const __half *const ptr)

生成一条ld.global.cv加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half2 __ldg(const __half2 *const ptr)

生成一条ld.global.nc加载指令。

defined(CUDA_ARCH) || (CUDA_ARCH >= 300)

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half __ldg(const __half *const ptr)

生成一条ld.global.nc加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half __ldlu(const __half *const ptr)

生成一条ld.global.lu加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__device__ __half2 __ldlu(const __half2 *const ptr)

生成一条ld.global.lu加载指令。

Parameters: ptr – [输入] - 内存位置
Returns: ptr 所指向的值

__host__ __device__ __half __ll2half_rd(const long long int i)

将有符号64位整数转换为半精度浮点数，采用向下舍入模式。

将有符号64位整数值i转换为向下舍入模式的半精度浮点值。

Parameters

i – [输入] - long long int。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ll2half_rn(const long long int i)

将有符号64位整数转换为半精度浮点数，采用四舍五入到最近的偶数模式。

将有符号64位整数值i转换为采用最近偶数舍入模式的半精度浮点值。

Parameters

i – [输入] - long long int。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ll2half_ru(const long long int i)

将有符号64位整数转换为半精度浮点数，采用向上舍入模式。

将有符号64位整数值i转换为向上取整模式的半精度浮点值。

Parameters

i – [输入] - long long int类型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ll2half_rz(const long long int i)

将有符号64位整数转换为半精度浮点数，采用向零舍入模式。

将有符号64位整数值i转换为采用向零舍入模式的半精度浮点值。

Parameters

i – [输入] - long long int。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ float __low2float(const __half2 a)

将half2的低16位转换为浮点数并返回结果。

将half2输入a的低16位转换为32位浮点数并返回结果。

另请参阅

__half2float(__half) 更多详情请参阅。

Parameters

a – [输入] - half2类型。仅用于读取。

Returns

浮点数

a的低16位转换为浮点数。

__host__ __device__ __half __low2half(const __half2 a)

返回half2输入的低16位。

返回half2输入a的低16位。

Parameters

a – [输入] - half2类型。仅用于读取。

Returns

半精度

返回包含输入a低16位的half值。

__host__ __device__ __half2 __low2half2(const __half2 a)

从half2输入中提取低16位。

从half2输入a中提取低16位，并返回一个新的half2数值，该数值的两个半部分都等于所提取的位。

Parameters

a – [输入] - half2类型。仅用于读取。

Returns

half2

half2的两个部分均等于输入的低16位。

__host__ __device__ __half2 __lowhigh2highlow(const __half2 a)

交换half2输入的两半部分。

交换half2输入的两半部分，并返回一个交换后的新half2数值。

Parameters

a – [输入] - half2类型。仅用于读取。

Returns

half2

a 交换其两半部分。

__host__ __device__ __half2 __lows2half2(const __half2 a, const __half2 b)

从两个half2输入中分别提取低16位，并组合成一个half2数值。

从两个half2输入中分别提取低16位，并组合成一个half2数值。输入a的低16位存储在返回值的低16位中，输入b的低16位存储在返回值的高16位中。

Parameters

a – [输入] - half2类型。仅用于读取。
b – [输入] - half2类型。仅用于读取。

Returns

half2

a 和 b 的低16位。

__device__ __half __shfl_down_sync(const unsigned int mask, const __half var, const unsigned int delta, const int width = warpSize)

在线程束内的线程之间交换变量。

从相对于调用者ID更高的线程复制数据。

通过将delta加到调用线程ID上来计算源线程ID。返回由结果线程ID持有的var值：这具有将var沿warp向下移动delta个线程的效果。如果width小于warpSize，则warp的每个子部分将作为一个独立实体运行，其起始逻辑线程ID为0。与__shfl_up_sync()类似，源线程的ID号不会环绕width值，且上部的delta个线程将保持不变。线程只能从另一个正在积极参与__shfl_*sync()命令的线程中读取数据。如果目标线程处于非活动状态，则检索到的值未定义。

注意

有关此函数的更多详细信息，请参阅CUDA C++编程指南中的Warp Shuffle Functions章节。

Parameters

mask – [输入] - 无符号整型。仅用于读取。
- 表示参与调用的线程。
- 必须为每个参与的线程设置一个位，表示线程的车道ID，以确保在执行硬件内部函数之前它们正确收敛。
- 每个调用线程必须在mask中有自己的位设置，并且mask中指定的所有未退出线程必须使用相同的mask执行相同的内在函数，否则结果将是未定义的。
var – [in] - half. 仅用于读取。
delta – [输入] - 无符号整型。仅用于读取。
width – [输入] - int. 仅用于读取。

Returns

从源线程ID返回由var引用的2字节字作为half。

__device__ __half2 __shfl_down_sync(const unsigned int mask, const __half2 var, const unsigned int delta, const int width = warpSize)

在线程束内的线程之间交换变量。

从相对于调用者ID更高的线程复制数据。

通过将delta添加到调用线程ID来计算源线程ID。返回结果线程ID持有的var值：这具有将var沿warp向下移动delta个线程的效果。如果width小于warpSize，则warp的每个子部分都作为一个独立实体运行，起始逻辑线程ID为0。与__shfl_up_sync()类似，源线程的ID号不会环绕width值，且上部的delta个线程将保持不变。线程只能从当前正在参与__shfl_*sync()命令的其他线程读取数据。如果目标线程处于非活动状态，则获取的值是未定义的。

注意

有关此函数的更多详细信息，请参阅CUDA C++编程指南中的Warp Shuffle Functions章节。

Parameters

mask – [输入] - 无符号整型。仅用于读取。
- 表示参与调用的线程。
- 必须为每个参与的线程设置一个比特位，表示该线程的车道ID，以确保在执行硬件内部指令前它们能正确汇聚。
- 每个调用线程必须在mask中拥有自己的位设置，并且mask中指定的所有未退出线程必须使用相同的mask执行相同的内在函数，否则结果将是未定义的。
var – [输入] - half2。仅用于读取。
delta – [输入] - 无符号整型。仅用于读取。
width – [in] - int. 仅用于读取。

Returns

从源线程ID返回由var引用的4字节字作为half2。

__device__ __half2 __shfl_sync(const unsigned int mask, const __half2 var, const int srcLane, const int width = warpSize)

在线程束内的线程之间交换变量。

直接从索引线程复制。

返回由srcLane指定的线程ID所持有的var值。如果width小于warpSize，则warp的每个子部分将作为一个独立实体运行，其起始逻辑线程ID为0。如果srcLane超出范围[0:width-1]，则返回的值对应于srcLane对width取模后所持有的var值（即在同一个子部分内）。width的值必须是2的幂；如果width不是2的幂，或者大于warpSize，则结果未定义。线程只能从正在参与__shfl_*sync()命令的另一个线程读取数据。如果目标线程处于非活动状态，则获取的值未定义。

注意

有关此函数的更多详细信息，请参阅CUDA C++编程指南中的Warp Shuffle Functions章节。

Parameters

mask – [输入] - 无符号整型。仅用于读取。
- 表示参与调用的线程。
- 必须为每个参与的线程设置一个位（表示线程的通道ID），以确保在执行硬件内部函数之前它们能正确汇聚。
- 每个调用线程必须在mask中拥有自己的位设置，并且mask中指定的所有未退出线程必须使用相同的mask执行相同的内在函数，否则结果将是未定义的。
var – [输入] - half2。仅用于读取。
srcLane – [in] - int. 仅用于读取。
width – [in] - int. 仅用于读取。

Returns

从源线程ID返回由var引用的4字节字作为half2。

__device__ __half __shfl_sync(const unsigned int mask, const __half var, const int srcLane, const int width = warpSize)

在线程束内的线程之间交换变量。

直接从索引线程复制。

返回由srcLane指定的线程ID所持有的var值。如果width小于warpSize，则warp的每个子部分将作为一个独立实体运行，其起始逻辑线程ID为0。如果srcLane超出范围[0:width-1]，则返回的值对应于srcLane对width取模后所持有的var值（即在同一个子部分内）。width的值必须是2的幂；如果width不是2的幂，或者大于warpSize，则结果未定义。线程只能从当前正在参与__shfl_*sync()命令的其他线程读取数据。如果目标线程处于非活动状态，则获取的值未定义。

注意

有关此函数的更多详细信息，请参阅CUDA C++编程指南中的Warp Shuffle Functions章节。

Parameters

mask – [输入] - 无符号整型。仅用于读取。
- 表示参与调用的线程。
- 必须为每个参与的线程设置一个比特位，表示线程的车道ID，以确保它们在硬件执行该内部函数之前正确收敛。
- 每个调用线程必须在mask中拥有自己的位设置，并且mask中指定的所有未退出线程必须使用相同的mask执行相同的内在函数，否则结果将是未定义的。
var – [输入] - half. 仅用于读取。
srcLane – [in] - int. 仅用于读取。
width – [in] - int. 仅用于读取。

Returns

从源线程ID返回由var引用的2字节字作为half。

__device__ __half2 __shfl_up_sync(const unsigned int mask, const __half2 var, const unsigned int delta, const int width = warpSize)

在线程束内的线程之间交换变量。

从ID相对于调用者较低的线程复制数据。

通过从调用者的线程通道ID中减去delta来计算源线程ID。返回由结果线程通道ID持有的var值：实际上，var会沿着线程束向上移动delta个线程。如果width小于warpSize，则线程束的每个子部分将作为一个独立的实体运行，其起始逻辑线程ID为0。源线程索引不会环绕width的值，因此实际上较低的delta个线程将保持不变。width的值必须是2的幂；如果width不是2的幂，或者大于warpSize，则结果未定义。线程只能从另一个正在积极参与__shfl_*sync()命令的线程中读取数据。如果目标线程处于非活动状态，则检索到的值未定义。

注意

有关此函数的更多详细信息，请参阅CUDA C++编程指南中的Warp Shuffle Functions章节。

Parameters

mask – [输入] - 无符号整型。仅用于读取。
- 表示参与调用的线程。
- 必须为每个参与的线程设置一个位（表示线程的通道ID），以确保在硬件执行该内部函数之前它们能正确汇聚。
- 每个调用线程必须在mask中拥有自己的位设置，并且mask中指定的所有未退出线程必须使用相同的mask执行相同的内在函数，否则结果将是未定义的。
var – [输入] - half2。仅用于读取。
delta – [输入] - 无符号整型。仅用于读取。
width – [in] - int. 仅用于读取。

Returns

从源线程ID返回由var引用的4字节字作为half2。

__device__ __half __shfl_up_sync(const unsigned int mask, const __half var, const unsigned int delta, const int width = warpSize)

在线程束内的线程之间交换变量。

从相对于调用者ID较低的线程复制数据。

通过从调用者的线程通道ID中减去delta来计算源线程ID。返回由结果线程通道ID持有的var值：实际上，var会在线程束中向上移动delta个线程。如果width小于warpSize，则线程束的每个子部分将作为一个独立的实体运行，其起始逻辑线程ID为0。源线程索引不会环绕width的值，因此实际上较低的delta个线程将保持不变。width的值必须是2的幂；如果width不是2的幂，或者大于warpSize，则结果未定义。线程只能从另一个正在参与__shfl_*sync()命令的线程中读取数据。如果目标线程处于非活动状态，则检索到的值未定义。

注意

有关此函数的更多详细信息，请参阅CUDA C++编程指南中的Warp Shuffle Functions章节。

Parameters

mask – [输入] - 无符号整型。仅用于读取。
- 表示参与调用的线程。
- 必须为每个参与的线程设置一个比特位，表示线程的车道ID，以确保在执行硬件内部函数之前它们能正确汇聚。
- 每个调用线程必须在mask中拥有自己的位设置，并且mask中指定的所有未退出线程必须使用相同的mask执行相同的内在函数，否则结果将是未定义的。
var – [in] - half. 仅用于读取。
delta – [输入] - 无符号整型。仅用于读取。
width – [in] - int. 仅用于读取。

Returns

从源线程ID返回由var引用的2字节字作为half。

__device__ __half2 __shfl_xor_sync(const unsigned int mask, const __half2 var, const int laneMask, const int width = warpSize)

在线程束内的线程之间交换变量。

基于自身线程ID的按位异或操作从线程复制数据。

通过执行调用线程ID与laneMask:的按位异或运算来计算源线程ID，并返回结果线程ID所持有的var值。如果width小于warpSize，则每组连续的width个线程可以访问前面线程组中的元素，但如果它们尝试访问后面线程组中的元素，则会返回它们自己的var值。此模式实现了类似树形归约和广播中使用的蝶形寻址模式。线程只能从正在参与__shfl_*sync()命令的其他线程读取数据。如果目标线程处于非活动状态，则获取的值是未定义的。

注意

有关此函数的更多详细信息，请参阅CUDA C++编程指南中的Warp Shuffle Functions章节。

Parameters

mask – [输入] - 无符号整型。仅用于读取。
- 表示参与调用的线程。
- 必须为每个参与的线程设置一个比特位，表示线程的通道ID，以确保在执行硬件内部指令前它们能正确收敛。
- 每个调用线程必须在mask中有自己的位设置，并且mask中指定的所有未退出线程必须使用相同的mask执行相同的内在函数，否则结果将是未定义的。
var – [输入] - half2。仅用于读取。
laneMask – [in] - int. 仅用于读取。
width – [输入] - int. 仅用于读取。

Returns

从源线程ID返回由var引用的4字节字作为half2。

__device__ __half __shfl_xor_sync(const unsigned int mask, const __half var, const int laneMask, const int width = warpSize)

在线程束内的线程之间交换变量。

基于自身线程ID的按位异或操作从线程复制数据。

通过执行调用线程ID与laneMask:的按位异或运算来计算源线程ID，并返回结果线程ID所持有的var值。如果width小于warpSize，则每组连续的width个线程可以访问前面线程组中的元素，但如果它们尝试访问后面线程组中的元素，则会返回它们自己的var值。此模式实现了类似树形归约和广播中使用的蝶形寻址模式。线程只能从正在参与__shfl_*sync()命令的其他线程读取数据。如果目标线程处于非活动状态，则获取的值是未定义的。

注意

有关此函数的更多详细信息，请参阅CUDA C++编程指南中的Warp Shuffle Functions章节。

Parameters

mask – [输入] - 无符号整型。仅用于读取。
- 表示参与调用的线程。
- 必须为每个参与的线程设置一个比特位，表示该线程的车道ID，以确保在执行硬件内部指令前它们能正确汇聚。
- 每个调用线程必须在mask中有自己的位设置，并且mask中指定的所有未退出线程必须使用相同的mask执行相同的内在函数，否则结果将是未定义的。
var – [in] - half. 仅用于读取。
laneMask – [输入] - int. 仅用于读取。
width – [输入] - int. 仅用于读取。

Returns

从源线程ID返回由var引用的2字节字作为half。

__host__ __device__ __half __short2half_rd(const short int i)

将有符号短整数转换为半精度浮点数，采用向下舍入模式。

将有符号短整数值 i 转换为向下舍入模式的半精度浮点值。

Parameters

i – [输入] - 短整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __short2half_rn(const short int i)

将有符号短整数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。

将有符号短整数值 i 转换为半精度浮点值，采用四舍五入到最接近的偶数模式。

Parameters

i – [输入] - 短整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __short2half_ru(const short int i)

将有符号短整数转换为半精度浮点数，采用向上舍入模式。

将有符号短整数值 i 转换为向上舍入模式的半精度浮点值。

Parameters

i – [输入] - 短整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __short2half_rz(const short int i)

将有符号短整数转换为半精度浮点数，采用向零舍入模式。

将有符号短整数值 i 转换为采用向零舍入模式的半精度浮点值。

Parameters

i – [输入] - 短整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __short_as_half(const short int i)

将带符号短整型中的位重新解释为half。

将有符号短整数 i 的位重新解释为半精度浮点数。

Parameters

i – [输入] - 短整型。仅用于读取。

Returns

半精度

重新解释后的值。

__device__ void __stcg(__half2 *const ptr, const __half2 value)

生成一条st.global.cg存储指令。

Parameters

ptr – [out] - 内存位置
value – [in] - 要存储的值

__device__ void __stcg(__half *const ptr, const __half value)

生成一条st.global.cg存储指令。

Parameters

ptr – [out] - 内存位置
value – [in] - 要存储的值

__device__ void __stcs(__half2 *const ptr, const __half2 value)

生成一条st.global.cs存储指令。

Parameters

ptr – [out] - 内存位置
value – [in] - 要存储的值

__device__ void __stcs(__half *const ptr, const __half value)

生成一条st.global.cs存储指令。

Parameters

ptr – [out] - 内存位置
value – [in] - 要存储的值

__device__ void __stwb(__half2 *const ptr, const __half2 value)

生成一条st.global.wb存储指令。

Parameters

ptr – [输出] - 内存位置
value – [in] - 要存储的值

__device__ void __stwb(__half *const ptr, const __half value)

生成一条st.global.wb存储指令。

Parameters

ptr – [out] - 内存位置
value – [in] - 要存储的值

__device__ void __stwt(__half *const ptr, const __half value)

生成一条st.global.wt存储指令。

Parameters

ptr – [out] - 内存位置
value – [in] - 要存储的值

__device__ void __stwt(__half2 *const ptr, const __half2 value)

生成一条st.global.wt存储指令。

Parameters

ptr – [out] - 内存位置
value – [in] - 要存储的值

__host__ __device__ __half __uint2half_rd(const unsigned int i)

将一个无符号整数转换为半精度浮点数，采用向下舍入模式。

将无符号整数值 i 转换为向下舍入模式的半精度浮点值。

Parameters

i – [输入] - 无符号整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __uint2half_rn(const unsigned int i)

将一个无符号整数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。

将无符号整数值 i 转换为采用四舍五入到最近偶数模式的半精度浮点值。

Parameters

i – [输入] - 无符号整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __uint2half_ru(const unsigned int i)

将一个无符号整数转换为半精度浮点数，采用向上舍入模式。

将无符号整数值 i 转换为半精度浮点值，采用向上舍入模式。

Parameters

i – [输入] - 无符号整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __uint2half_rz(const unsigned int i)

将一个无符号整数转换为半精度浮点数，采用向零舍入模式。

将无符号整数值 i 转换为采用向零舍入模式的半精度浮点值。

Parameters

i – [输入] - 无符号整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ull2half_rd(const unsigned long long int i)

将一个无符号64位整数转换为半精度浮点数，采用向下舍入模式。

将无符号64位整数值i转换为向下舍入模式的半精度浮点值。

Parameters

i – [输入] - 无符号长整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ull2half_rn(const unsigned long long int i)

将一个无符号64位整数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。

将无符号64位整数值i转换为采用四舍五入到最近偶数模式的半精度浮点值。

Parameters

i – [输入] - 无符号长整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ull2half_ru(const unsigned long long int i)

将一个无符号64位整数转换为半精度浮点数，采用向上舍入模式。

将无符号64位整数值i转换为向上舍入模式的半精度浮点值。

Parameters

i – [输入] - 无符号长整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ull2half_rz(const unsigned long long int i)

将一个无符号64位整数转换为半精度浮点数，采用向零舍入模式。

将无符号64位整数值i转换为采用向零舍入模式的半精度浮点值。

Parameters

i – [输入] - 无符号长整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ushort2half_rd(const unsigned short int i)

将一个无符号短整型数转换为半精度浮点数，采用向下舍入模式。

将无符号短整数值 i 转换为向下舍入模式的半精度浮点值。

Parameters

i – [输入] - 无符号短整型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ushort2half_rn(const unsigned short int i)

将一个无符号短整型数转换为半精度浮点数，采用四舍五入到最接近的偶数模式。

将无符号短整数值 i 转换为采用四舍五入到最近偶数模式的半精度浮点值。

Parameters

i – [输入] - unsigned short int类型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ushort2half_ru(const unsigned short int i)

将一个无符号短整数转换为半精度浮点数，采用向上舍入模式。

将无符号短整数值 i 转换为向上舍入模式的半精度浮点值。

Parameters

i – [输入] - unsigned short int类型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ushort2half_rz(const unsigned short int i)

将一个无符号短整型数转换为半精度浮点数，采用向零舍入模式。

将无符号短整数值 i 转换为采用向零舍入模式的半精度浮点值。

Parameters

i – [输入] - unsigned short int类型。仅用于读取。

Returns

半精度

i 转换为半精度浮点数。

__host__ __device__ __half __ushort_as_half(const unsigned short int i)

将无符号短整数的位重新解释为half。

将无符号短整数 i 中的位重新解释为半精度浮点数。

Parameters

i – [输入] - 无符号短整型。仅用于读取。

Returns

半精度

重新解释后的值。

__host__ __device__ __half2 make_half2(const __half x, const __half y)

向量函数，将两个__half数值合并为一个__half2数值。

将两个输入的__half数值x和y合并为一个__half2数值。输入的x存储在返回值的低16位，输入的y存储在高16位。

Parameters

x – [输入] - 半精度浮点数。仅用于读取。
y – [输入] - 半精度浮点数。仅用于读取。

Returns

__half2

一个__half2向量，其中一半等于x，另一半等于y。