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

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

函数

__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): 在 warp 内的线程之间交换变量。
__device__ __half2 __shfl_down_sync(const unsigned int mask, const __half2 var, const unsigned int delta, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __half2 __shfl_sync(const unsigned int mask, const __half2 var, const int srcLane, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __half __shfl_sync(const unsigned int mask, const __half var, const int srcLane, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __half2 __shfl_up_sync(const unsigned int mask, const __half2 var, const unsigned int delta, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __half __shfl_up_sync(const unsigned int mask, const __half var, const unsigned int delta, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __half2 __shfl_xor_sync(const unsigned int mask, const __half2 var, const int laneMask, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __half __shfl_xor_sync(const unsigned int mask, const __half var, const int laneMask, const int width=warpSize): 在 warp 内的线程之间交换变量。
__host__ __device__ __half __short2half_rd(const short int i): 将有符号 short 整数转换为半精度浮点数，采用向下舍入模式。
__host__ __device__ __half __short2half_rn(const short int i): 将有符号 short 整数转换为半精度浮点数，采用舍入到最近的偶数模式。
__host__ __device__ __half __short2half_ru(const short int i): 将有符号 short 整数转换为半精度浮点数，采用向上舍入模式。
__host__ __device__ __half __short2half_rz(const short int i): 将有符号 short 整数转换为半精度浮点数，采用向零舍入模式。
__host__ __device__ __half __short_as_half(const short int i): 将有符号 short 整数中的位重新解释为 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): 将无符号 short 整数转换为半精度浮点数，采用向下舍入模式。
__host__ __device__ __half __ushort2half_rn(const unsigned short int i): 将无符号 short 整数转换为半精度浮点数，采用舍入到最近的偶数模式。
__host__ __device__ __half __ushort2half_ru(const unsigned short int i): 将无符号 short 整数转换为半精度浮点数，采用向上舍入模式。
__host__ __device__ __half __ushort2half_rz(const unsigned short int i): 将无符号 short 整数转换为半精度浮点数，采用向零舍入模式。
__host__ __device__ __half __ushort_as_half(const unsigned short int i): 将无符号 short 整数中的位重新解释为 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 转换为半精度，采用舍入到最近的偶数模式。

参数

a – [in] - double。只读。

返回值

half

使用舍入到最近的偶数模式将 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) 以获取更多详细信息。

参数

a – [in] - float2。只读。

返回值

half2

其对应半字等于转换后的 float2 分量的 half2。

__host__ __device__ __half __float2half(const float a)

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

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

另请参阅

__float2half_rn(float) 以获取更多详细信息。

参数

a – [in] - float。只读。

返回值

half

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

__host__ __device__ __half2 __float2half2_rn(const float a)

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

将输入 a 转换为半精度，采用舍入到最近的偶数模式，并使用转换后的值填充 half2 的两个半字。

另请参阅

__float2half_rn(float) 以获取更多详细信息。

参数

a – [in] - float。只读。

返回值

half2

具有两个半字都等于转换后的半精度数的 half2 值。

__host__ __device__ __half __float2half_rd(const float a)

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

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

参数

a – [in] - float。只读。

返回值

half

使用向下舍入模式将 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 转换为半精度，采用舍入到最近的偶数模式。

参数

a – [in] - float。只读。

返回值

half

使用舍入到最近的偶数模式将 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 转换为半精度，采用向上舍入模式。

参数

a – [in] - float。只读。

返回值

half

使用向上舍入模式将 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 转换为半精度，采用向零舍入模式。

参数

a – [in] - float。只读。

返回值

half

使用向零舍入模式将 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) 以获取更多详细信息。

参数

a – [in] - float。只读。
b – [in] - float。只读。

返回值

half2

具有对应半字等于转换后的输入浮点数的 half2 值。

__host__ __device__ float2 __half22float2(const __half2 a)

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

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

另请参阅

__half2float(__half) 以获取更多详细信息。

参数

a – [in] - half2。只读。

返回值

float2

转换为 float2 的 a。

__host__ __device__ signed char __half2char_rz(const __half h)

以向零舍入模式将半精度数转换为有符号字符。

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

参数

h – [in] - half。只读。

返回值

signed char

使用向零舍入模式将 h 转换为有符号 char。
__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 转换为 float。

参数

a – [in] - float。只读。

返回值

float

转换为 float 的 a。
__half2float \( (\pm 0)\) 返回 \( \pm 0 \)。
__half2float \( (\pm \infty)\) 返回 \( \pm \infty \)。
__half2float(NaN) 返回 NaN。

__host__ __device__ __half2 __half2half2(const __half a)

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

返回 half2 数字，其两个半字都等于输入 a half 数字。

参数

a – [in] - half。只读。

返回值

half2

向量，其两个半字都等于输入 a。

__device__ int __half2int_rd(const __half h)

以向下舍入模式将半精度数转换为有符号整数。

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

参数

h – [in] - half。只读。

返回值

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。

参数

h – [in] - half。只读。

返回值

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。

参数

h – [in] - half。只读。

返回值

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。

参数

h – [in] - half。只读。

返回值

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。

参数

h – [in] - half。只读。

返回值

long long int (长长整型)

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。

参数

h – [in] - half。只读。

返回值

long long int (长长整型)

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。

参数

h – [in] - half。只读。

返回值

long long int (长长整型)

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。

参数

h – [in] - half。只读。

返回值

long long int (长长整型)

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 转换为下舍入模式下的有符号 short 整数。 NaN 输入被转换为 0。

参数

h – [in] - half。只读。

返回值

short int (短整型)

h 已转换为使用下舍入模式的有符号 short 整数。
__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 转换为最近偶数舍入模式下的有符号 short 整数。 NaN 输入被转换为 0。

参数

h – [in] - half。只读。

返回值

short int (短整型)

h 已转换为使用最近偶数舍入模式的有符号 short 整数。
__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 转换为上舍入模式下的有符号 short 整数。 NaN 输入被转换为 0。

参数

h – [in] - half。只读。

返回值

short int (短整型)

h 已转换为使用上舍入模式的有符号 short 整数。
__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 转换为向零舍入模式下的有符号 short 整数。 NaN 输入被转换为 0。

参数

h – [in] - half。只读。

返回值

short int (短整型)

h 已转换为使用向零舍入模式的有符号 short 整数。
__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 转换为向零舍入模式下的 unsigned char。 NaN 输入被转换为 0。

参数

h – [in] - half。只读。

返回值

unsigned char (无符号字符型)

h 已转换为使用向零舍入模式的 unsigned char。
__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 转换为下舍入模式下的 unsigned integer。 NaN 输入被转换为 0。

参数

h – [in] - half。只读。

返回值

unsigned int (无符号整型)

h 已转换为使用下舍入模式的 unsigned integer。
__half2uint_rd \( (\pm 0)\) 返回 0。
__half2uint_rd \( (+\infty)\) 返回 UINT_MAX = 0xFFFFFFFF。
__half2uint_rd \( (x), x < 0.0\) 返回 0。
__half2uint_rd(NaN) 返回 0。

__device__ unsigned int __half2uint_rn(const __half h)

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

将半精度浮点值 h 转换为最近偶数舍入模式下的 unsigned integer。 NaN 输入被转换为 0。

参数

h – [in] - half。只读。

返回值

unsigned int (无符号整型)

h 已转换为使用最近偶数舍入模式的 unsigned integer。
__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 转换为上舍入模式下的 unsigned integer。 NaN 输入被转换为 0。

参数

h – [in] - half。只读。

返回值

unsigned int (无符号整型)

h 已转换为使用上舍入模式的 unsigned integer。
__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 转换为向零舍入模式下的 unsigned integer。 NaN 输入被转换为 0。

参数

h – [in] - half。只读。

返回值

unsigned int (无符号整型)

h 已转换为使用向零舍入模式的 unsigned integer。
__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 转换为下舍入模式下的 unsigned 64 位整数。 NaN 输入返回 0x8000000000000000。

参数

h – [in] - half。只读。

返回值

unsigned long long int (无符号长长整型)

h 已转换为使用下舍入模式的 unsigned 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 转换为最近偶数舍入模式下的 unsigned 64 位整数。 NaN 输入返回 0x8000000000000000。

参数

h – [in] - half。只读。

返回值

unsigned long long int (无符号长长整型)

h 已转换为使用最近偶数舍入模式的 unsigned 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 转换为上舍入模式下的 unsigned 64 位整数。 NaN 输入返回 0x8000000000000000。

参数

h – [in] - half。只读。

返回值

unsigned long long int (无符号长长整型)

h 已转换为使用上舍入模式的 unsigned 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 转换为向零舍入模式下的 unsigned 64 位整数。 NaN 输入返回 0x8000000000000000。

参数

h – [in] - half。只读。

返回值

unsigned long long int (无符号长长整型)

h 已转换为使用向零舍入模式的 unsigned 64 位整数。
__half2ull_rz \( (\pm 0)\) 返回 0。
__half2ull_rz \( (+\infty)\) 返回 ULLONG_MAX = 0xFFFFFFFFFFFFFFFF。
__half2ull_rz \( (x), x < 0.0\) 返回 0。
__half2ull_rz(NaN) 返回 0x8000000000000000。

__device__ unsigned short int __half2ushort_rd(const __half h)

以向下舍入模式将半精度数转换为无符号短整数。

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

参数

h – [in] - half。只读。

返回值

unsigned short int

h 转换为无符号短整型，采用向下舍入模式。
__half2ushort_rd \( (\pm 0)\) 返回 0。
__half2ushort_rd \( (+\infty)\) 返回 USHRT_MAX = 0xFFFF。
__half2ushort_rd \( (x), x < 0.0\) 返回 0。
__half2ushort_rd(NaN) 返回 0。

__device__ unsigned short int __half2ushort_rn(const __half h)

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

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

参数

h – [in] - half。只读。

返回值

unsigned short int

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

__device__ unsigned short int __half2ushort_ru(const __half h)

以向上舍入模式将半精度数转换为无符号短整数。

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

参数

h – [in] - half。只读。

返回值

unsigned short int

h 转换为无符号短整型，采用向上舍入模式。
__half2ushort_ru \( (\pm 0)\) 返回 0。
__half2ushort_ru \( (+\infty)\) 返回 USHRT_MAX = 0xFFFF。
__half2ushort_ru \( (x), x < 0.0\) 返回 0。
__half2ushort_ru(NaN) 返回 0。

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

以向零舍入模式将半精度数转换为无符号短整数。

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

参数

h – [in] - half。只读。

返回值

unsigned short int

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 中的位重新解释为有符号短整型。

参数

h – [in] - half。只读。

返回值

short int (短整型)

重新解释后的值。

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

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

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

参数

h – [in] - half。只读。

返回值

unsigned short int

重新解释后的值。

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

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

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

参数

a – [in] - half。只读。
b – [in] - half 类型。只读。

返回值

half2

返回的 half2 类型数值，其中一个 half 值等于 a，另一个等于 b。

__host__ __device__ float __high2float(const __half2 a)

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

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

另请参阅

__half2float(__half) 以获取更多详细信息。

参数

a – [in] - half2。只读。

返回值

float

返回 a 的高 16 位转换成的 float 类型数值。

__host__ __device__ __half __high2half(const __half2 a)

返回 half2 输入的高 16 位。

返回 half2 类型输入 a 的高 16 位。

参数

a – [in] - half2。只读。

返回值

half

返回输入的高 16 位。

__host__ __device__ __half2 __high2half2(const __half2 a)

从 half2 输入中提取高 16 位。

从 half2 类型输入 a 中提取高 16 位，并返回一个新的 half2 类型数值，其两个 half 值都等于提取出的位。

参数

a – [in] - half2。只读。

返回值

half2

返回的 half2 类型数值，其两个 half 值都等于输入的高 16 位。

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

从两个 half2 输入中的每一个提取高 16 位，并合并为一个 half2 数。

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

参数

a – [in] - half2。只读。
b – [in] - half2 类型。只读。

返回值

half2

返回 a 和 b 的高 16 位组合而成的 half2 类型数值。

__host__ __device__ __half __int2half_rd(const int i)

以向下舍入模式将有符号整数转换为半精度数。

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

参数

i – [in] - int 类型。只读。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __int2half_rn(const int i)

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

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

参数

i – [in] - int 类型。只读。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __int2half_ru(const int i)

以向上舍入模式将有符号整数转换为半精度数。

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

参数

i – [in] - int 类型。只读。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __int2half_rz(const int i)

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

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

参数

i – [in] - int 类型。只读。

返回值

half

返回 i 转换成的 half 类型数值。

__device__ __half2 __ldca(const __half2 *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half __ldca(const __half *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half __ldcg(const __half *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half2 __ldcg(const __half2 *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half __ldcs(const __half *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half2 __ldcs(const __half2 *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half2 __ldcv(const __half2 *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half __ldcv(const __half *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half2 __ldg(const __half2 *const ptr)

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

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half __ldg(const __half *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half __ldlu(const __half *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

__device__ __half2 __ldlu(const __half2 *const ptr)

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

参数: ptr – [in] - 内存位置
返回值: 返回 ptr 指向的数值

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

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

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

参数

i – [in] - long long int 类型。只读。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - long long int 类型。只读。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - long long int 类型。只读。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - long long int 类型。只读。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ float __low2float(const __half2 a)

将 half2 的低 16 位转换为 float 并返回结果。

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

另请参阅

__half2float(__half) 以获取更多详细信息。

参数

a – [in] - half2。只读。

返回值

float

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

__host__ __device__ __half __low2half(const __half2 a)

返回 half2 输入的低 16 位。

返回 half2 输入 a 的低 16 位。

参数

a – [in] - half2。只读。

返回值

half

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

__host__ __device__ __half2 __low2half2(const __half2 a)

从 half2 输入中提取低 16 位。

从 half2 输入 a 中提取低 16 位，并返回一个新的 half2 数，其两个半字都等于提取的位。

参数

a – [in] - half2。只读。

返回值

half2

半字都等于输入低 16 位的 half2。

__host__ __device__ __half2 __lowhigh2highlow(const __half2 a)

交换 half2 输入的两个半字。

交换 half2 输入的两个半字，并返回一个交换了半字的新 half2 数。

参数

a – [in] - half2。只读。

返回值

half2

半字被交换的 a。

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

从两个 half2 输入中提取低 16 位，并将它们组合成一个 half2 数字。

从两个 half2 输入中的每一个提取低 16 位，并将它们组合成一个 half2 数。来自输入 a 的低 16 位存储在返回值的低 16 位中，来自输入 b 的低 16 位存储在返回值的高 16 位中。

参数

a – [in] - half2。只读。
b – [in] - half2 类型。只读。

返回值

half2

a 和 b 的低 16 位。

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

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

从线程 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 函数部分。

参数

mask – [in] - unsigned int。仅被读取。
- 指示参与调用的线程。
- 必须为每个参与线程设置一个位（表示线程的 lane ID），以确保在硬件执行 intrinsic 之前它们已正确收敛。
- 每个调用线程都必须在 mask 中设置自己的位，并且 mask 中命名的所有非退出线程都必须使用相同的 mask 执行相同的 intrinsic，否则结果是未定义的。
var – [in] - half。仅被读取。
delta – [in] - unsigned int。仅被读取。
width – [in] - int。仅被读取。

返回值

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

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

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

从线程 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 函数部分。

参数

mask – [in] - unsigned int。仅被读取。
- 指示参与调用的线程。
- 必须为每个参与线程设置一个位（表示线程的 lane ID），以确保在硬件执行 intrinsic 之前它们已正确收敛。
- 每个调用线程都必须在 mask 中设置自己的位，并且 mask 中命名的所有非退出线程都必须使用相同的 mask 执行相同的 intrinsic，否则结果是未定义的。
var – [in] - half2。仅被读取。
delta – [in] - unsigned int。仅被读取。
width – [in] - int。仅被读取。

返回值

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

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

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

从索引线程直接复制。

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

注意

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

参数

mask – [in] - unsigned int。仅被读取。
- 指示参与调用的线程。
- 必须为每个参与线程设置一个位（表示线程的 lane ID），以确保在硬件执行 intrinsic 之前它们已正确收敛。
- 每个调用线程都必须在 mask 中设置自己的位，并且 mask 中命名的所有非退出线程都必须使用相同的 mask 执行相同的 intrinsic，否则结果是未定义的。
var – [in] - half2。仅被读取。
srcLane – [in] - int。仅被读取。
width – [in] - int。仅被读取。

返回值

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

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

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

从索引线程直接复制。

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

注意

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

参数

mask – [in] - unsigned int。仅被读取。
- 指示参与调用的线程。
- 必须为每个参与线程设置一个位（表示线程的 lane ID），以确保在硬件执行 intrinsic 之前它们已正确收敛。
- 每个调用线程都必须在 mask 中设置自己的位，并且 mask 中命名的所有非退出线程都必须使用相同的 mask 执行相同的 intrinsic，否则结果是未定义的。
var – [in] - half。仅被读取。
srcLane – [in] - int。仅被读取。
width – [in] - int。仅被读取。

返回值

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

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

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

从线程 ID 相对于调用者更低的线程复制。

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

注意

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

参数

mask – [in] - unsigned int。仅被读取。
- 指示参与调用的线程。
- 必须为每个参与线程设置一个位（表示线程的 lane ID），以确保在硬件执行 intrinsic 之前它们已正确收敛。
- 每个调用线程都必须在 mask 中设置自己的位，并且 mask 中命名的所有非退出线程都必须使用相同的 mask 执行相同的 intrinsic，否则结果是未定义的。
var – [in] - half2。仅被读取。
delta – [in] - unsigned int。仅被读取。
width – [in] - int。仅被读取。

返回值

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

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

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

从线程 ID 相对于调用者更低的线程复制。

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

注意

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

参数

mask – [in] - unsigned int。仅被读取。
- 指示参与调用的线程。
- 必须为每个参与线程设置一个位（表示线程的 lane ID），以确保在硬件执行 intrinsic 之前它们已正确收敛。
- 每个调用线程都必须在 mask 中设置自己的位，并且 mask 中命名的所有非退出线程都必须使用相同的 mask 执行相同的 intrinsic，否则结果是未定义的。
var – [in] - half。仅被读取。
delta – [in] - unsigned int。仅被读取。
width – [in] - int。仅被读取。

返回值

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

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

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

基于自身线程 ID 的按位异或，从线程复制。

通过对调用者的线程 ID 与 laneMask: 执行按位异或来计算源线程 ID，返回结果线程 ID 所持有的 var 值。如果 width 小于 warpSize，则 width 个连续线程的每个组都能够访问来自较早线程组的元素，但是，如果他们尝试访问来自较晚线程组的元素，则将返回他们自己的 var 值。此模式实现了一种蝶形寻址模式，例如在树归约和广播中使用。线程可能只从另一个线程读取数据，该线程正在积极参与 __shfl_*sync() 命令。如果目标线程不活动，则检索到的值是未定义的。

注意

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

参数

mask – [in] - unsigned int。仅被读取。
- 指示参与调用的线程。
- 必须为每个参与线程设置一个位（表示线程的 lane ID），以确保在硬件执行 intrinsic 之前它们已正确收敛。
- 每个调用线程都必须在 mask 中设置自己的位，并且 mask 中命名的所有非退出线程都必须使用相同的 mask 执行相同的 intrinsic，否则结果是未定义的。
var – [in] - half2。仅被读取。
laneMask – [in] - int。仅被读取。
width – [in] - int。仅被读取。

返回值

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

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

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

基于自身线程 ID 的按位异或，从线程复制。

通过对调用者的线程 ID 与 laneMask: 执行按位异或来计算源线程 ID，返回结果线程 ID 所持有的 var 值。如果 width 小于 warpSize，则 width 个连续线程的每个组都能够访问来自较早线程组的元素，但是，如果他们尝试访问来自较晚线程组的元素，则将返回他们自己的 var 值。此模式实现了一种蝶形寻址模式，例如在树归约和广播中使用。线程可能只从另一个线程读取数据，该线程正在积极参与 __shfl_*sync() 命令。如果目标线程不活动，则检索到的值是未定义的。

注意

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

参数

mask – [in] - unsigned int。仅被读取。
- 指示参与调用的线程。
- 必须为每个参与线程设置一个位（表示线程的 lane ID），以确保在硬件执行 intrinsic 之前它们已正确收敛。
- 每个调用线程都必须在 mask 中设置自己的位，并且 mask 中命名的所有非退出线程都必须使用相同的 mask 执行相同的 intrinsic，否则结果是未定义的。
var – [in] - half。仅被读取。
laneMask – [in] - int。仅被读取。
width – [in] - int。仅被读取。

返回值

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

__host__ __device__ __half __short2half_rd(const short int i)

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

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

参数

i – [in] - short int。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __short2half_rn(const short int i)

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

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

参数

i – [in] - short int。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __short2half_ru(const short int i)

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

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

参数

i – [in] - short int。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __short2half_rz(const short int i)

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

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

参数

i – [in] - short int。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __short_as_half(const short int i)

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

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

参数

i – [in] - short int。仅被读取。

返回值

half

重新解释后的值。

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

__host__ __device__ __half __uint2half_rd(const unsigned int i)

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

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

参数

i – [in] - 无符号整数。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __uint2half_rn(const unsigned int i)

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

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

参数

i – [in] - 无符号整数。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __uint2half_ru(const unsigned int i)

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

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

参数

i – [in] - 无符号整数。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

__host__ __device__ __half __uint2half_rz(const unsigned int i)

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

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

参数

i – [in] - 无符号整数。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - 无符号长长整型。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - 无符号长长整型。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - 无符号长长整型。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - 无符号长长整型。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - 无符号短整型。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - 无符号短整型。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - 无符号短整型。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - 无符号短整型。仅被读取。

返回值

half

返回 i 转换成的 half 类型数值。

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

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

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

参数

i – [in] - 无符号短整型。仅被读取。

返回值

half

重新解释后的值。

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

向量函数，将两个 __half 数字组合成一个 __half2 数字。

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

参数

x – [in] - half。仅被读取。
y – [in] - half。仅被读取。

返回值

__half2

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