5.5. Bfloat16 精度转换和数据移动

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

函数

__host__ __device__ float2 __bfloat1622float2(const __nv_bfloat162 a): 将 nv_bfloat162 的两个半精度部分转换为 float2 并返回结果。
__host__ __device__ __nv_bfloat162 __bfloat162bfloat162(const __nv_bfloat16 a): 返回 nv_bfloat162，其两个半精度部分都等于输入值。
__host__ __device__ signed char __bfloat162char_rz(const __nv_bfloat16 h): 以向零舍入模式将 nv_bfloat16 转换为有符号 char。
__host__ __device__ float __bfloat162float(const __nv_bfloat16 a): 将 nv_bfloat16 数转换为 float。
__device__ int __bfloat162int_rd(const __nv_bfloat16 h): 以向下舍入模式将 nv_bfloat16 转换为有符号整数。
__device__ int __bfloat162int_rn(const __nv_bfloat16 h): 以四舍五入到最接近的偶数模式将 nv_bfloat16 转换为有符号整数。
__device__ int __bfloat162int_ru(const __nv_bfloat16 h): 以向上舍入模式将 nv_bfloat16 转换为有符号整数。
__host__ __device__ int __bfloat162int_rz(const __nv_bfloat16 h): 以向零舍入模式将 nv_bfloat16 转换为有符号整数。
__device__ long long int __bfloat162ll_rd(const __nv_bfloat16 h): 以向下舍入模式将 nv_bfloat16 转换为有符号 64 位整数。
__device__ long long int __bfloat162ll_rn(const __nv_bfloat16 h): 以四舍五入到最接近的偶数模式将 nv_bfloat16 转换为有符号 64 位整数。
__device__ long long int __bfloat162ll_ru(const __nv_bfloat16 h): 以向上舍入模式将 nv_bfloat16 转换为有符号 64 位整数。
__host__ __device__ long long int __bfloat162ll_rz(const __nv_bfloat16 h): 以向零舍入模式将 nv_bfloat16 转换为有符号 64 位整数。
__device__ short int __bfloat162short_rd(const __nv_bfloat16 h): 以向下舍入模式将 nv_bfloat16 转换为有符号 short 整数。
__device__ short int __bfloat162short_rn(const __nv_bfloat16 h): 以四舍五入到最接近的偶数模式将 nv_bfloat16 转换为有符号 short 整数。
__device__ short int __bfloat162short_ru(const __nv_bfloat16 h): 以向上舍入模式将 nv_bfloat16 转换为有符号 short 整数。
__host__ __device__ short int __bfloat162short_rz(const __nv_bfloat16 h): 以向零舍入模式将 nv_bfloat16 转换为有符号 short 整数。
__host__ __device__ unsigned char __bfloat162uchar_rz(const __nv_bfloat16 h): 以向零舍入模式将 nv_bfloat16 转换为无符号 char。
__device__ unsigned int __bfloat162uint_rd(const __nv_bfloat16 h): 以向下舍入模式将 nv_bfloat16 转换为无符号整数。
__device__ unsigned int __bfloat162uint_rn(const __nv_bfloat16 h): 以四舍五入到最接近的偶数模式将 nv_bfloat16 转换为无符号整数。
__device__ unsigned int __bfloat162uint_ru(const __nv_bfloat16 h): 以向上舍入模式将 nv_bfloat16 转换为无符号整数。
__host__ __device__ unsigned int __bfloat162uint_rz(const __nv_bfloat16 h): 以向零舍入模式将 nv_bfloat16 转换为无符号整数。
__device__ unsigned long long int __bfloat162ull_rd(const __nv_bfloat16 h): 以向下舍入模式将 nv_bfloat16 转换为无符号 64 位整数。
__device__ unsigned long long int __bfloat162ull_rn(const __nv_bfloat16 h): 以四舍五入到最接近的偶数模式将 nv_bfloat16 转换为无符号 64 位整数。
__device__ unsigned long long int __bfloat162ull_ru(const __nv_bfloat16 h): 以向上舍入模式将 nv_bfloat16 转换为无符号 64 位整数。
__host__ __device__ unsigned long long int __bfloat162ull_rz(const __nv_bfloat16 h): 以向零舍入模式将 nv_bfloat16 转换为无符号 64 位整数。
__device__ unsigned short int __bfloat162ushort_rd(const __nv_bfloat16 h): 以向下舍入模式将 nv_bfloat16 转换为无符号 short 整数。
__device__ unsigned short int __bfloat162ushort_rn(const __nv_bfloat16 h): 以四舍五入到最接近的偶数模式将 nv_bfloat16 转换为无符号 short 整数。
__device__ unsigned short int __bfloat162ushort_ru(const __nv_bfloat16 h): 以向上舍入模式将 nv_bfloat16 转换为无符号 short 整数。
__host__ __device__ unsigned short int __bfloat162ushort_rz(const __nv_bfloat16 h): 以向零舍入模式将 nv_bfloat16 转换为无符号 short 整数。
__host__ __device__ short int __bfloat16_as_short(const __nv_bfloat16 h): 将 nv_bfloat16 中的位重新解释为有符号 short 整数。
__host__ __device__ unsigned short int __bfloat16_as_ushort(const __nv_bfloat16 h): 将 nv_bfloat16 中的位重新解释为无符号 short 整数。
__host__ __device__ __nv_bfloat16 __double2bfloat16(const double a): 以四舍五入到最接近的偶数模式将 double 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。
__host__ __device__ __nv_bfloat162 __float22bfloat162_rn(const float2 a): 以四舍五入到最接近的偶数模式将 float2 数的两个分量转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat162。
__host__ __device__ __nv_bfloat16 __float2bfloat16(const float a): 以四舍五入到最接近的偶数模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。
__host__ __device__ __nv_bfloat162 __float2bfloat162_rn(const float a): 以四舍五入到最接近的偶数模式将输入转换为 nv_bfloat16 精度，并使用转换值填充 nv_bfloat162 的两个半精度部分。
__host__ __device__ __nv_bfloat16 __float2bfloat16_rd(const float a): 以向下舍入模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __float2bfloat16_rn(const float a): 以四舍五入到最接近的偶数模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __float2bfloat16_ru(const float a): 以向上舍入模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __float2bfloat16_rz(const float a): 以向零舍入模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。
__host__ __device__ __nv_bfloat162 __floats2bfloat162_rn(const float a, const float b): 以四舍五入到最接近的偶数模式将两个输入 float 转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat162。
__host__ __device__ __nv_bfloat162 __halves2bfloat162(const __nv_bfloat16 a, const __nv_bfloat16 b): 将两个 nv_bfloat16 数组合成一个 nv_bfloat162 数。
__host__ __device__ __nv_bfloat16 __high2bfloat16(const __nv_bfloat162 a): 返回 nv_bfloat162 输入的高 16 位。
__host__ __device__ __nv_bfloat162 __high2bfloat162(const __nv_bfloat162 a): 从 nv_bfloat162 输入中提取高 16 位。
__host__ __device__ float __high2float(const __nv_bfloat162 a): 将 nv_bfloat162 的高 16 位转换为 float 并返回结果。
__host__ __device__ __nv_bfloat162 __highs2bfloat162(const __nv_bfloat162 a, const __nv_bfloat162 b): 从两个 nv_bfloat162 输入中的每一个提取高 16 位，并组合成一个 nv_bfloat162 数。
__device__ __nv_bfloat16 __int2bfloat16_rd(const int i): 以向下舍入模式将有符号整数转换为 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __int2bfloat16_rn(const int i): 以四舍五入到最接近的偶数模式将有符号整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __int2bfloat16_ru(const int i): 以向上舍入模式将有符号整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __int2bfloat16_rz(const int i): 以向零舍入模式将有符号整数转换为 nv_bfloat16。
__device__ __nv_bfloat162 __ldca(const __nv_bfloat162 *const ptr): 生成 ld.global.ca 加载指令。
__device__ __nv_bfloat16 __ldca(const __nv_bfloat16 *const ptr): 生成 ld.global.ca 加载指令。
__device__ __nv_bfloat16 __ldcg(const __nv_bfloat16 *const ptr): 生成 ld.global.cg 加载指令。
__device__ __nv_bfloat162 __ldcg(const __nv_bfloat162 *const ptr): 生成 ld.global.cg 加载指令。
__device__ __nv_bfloat162 __ldcs(const __nv_bfloat162 *const ptr): 生成 ld.global.cs 加载指令。
__device__ __nv_bfloat16 __ldcs(const __nv_bfloat16 *const ptr): 生成 ld.global.cs 加载指令。
__device__ __nv_bfloat16 __ldcv(const __nv_bfloat16 *const ptr): 生成 ld.global.cv 加载指令。
__device__ __nv_bfloat162 __ldcv(const __nv_bfloat162 *const ptr): 生成 ld.global.cv 加载指令。
__device__ __nv_bfloat162 __ldg(const __nv_bfloat162 *const ptr): 生成 ld.global.nc 加载指令。
__device__ __nv_bfloat16 __ldg(const __nv_bfloat16 *const ptr): 生成 ld.global.nc 加载指令。
__device__ __nv_bfloat162 __ldlu(const __nv_bfloat162 *const ptr): 生成 ld.global.lu 加载指令。
__device__ __nv_bfloat16 __ldlu(const __nv_bfloat16 *const ptr): 生成 ld.global.lu 加载指令。
__device__ __nv_bfloat16 __ll2bfloat16_rd(const long long int i): 以向下舍入模式将有符号 64 位整数转换为 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __ll2bfloat16_rn(const long long int i): 以四舍五入到最接近的偶数模式将有符号 64 位整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __ll2bfloat16_ru(const long long int i): 以向上舍入模式将有符号 64 位整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __ll2bfloat16_rz(const long long int i): 以向零舍入模式将有符号 64 位整数转换为 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __low2bfloat16(const __nv_bfloat162 a): 返回 nv_bfloat162 输入的低 16 位。
__host__ __device__ __nv_bfloat162 __low2bfloat162(const __nv_bfloat162 a): 从 nv_bfloat162 输入中提取低 16 位。
__host__ __device__ float __low2float(const __nv_bfloat162 a): 将 nv_bfloat162 的低 16 位转换为 float 并返回结果。
__host__ __device__ __nv_bfloat162 __lowhigh2highlow(const __nv_bfloat162 a): 交换 nv_bfloat162 输入的两个半精度部分。
__host__ __device__ __nv_bfloat162 __lows2bfloat162(const __nv_bfloat162 a, const __nv_bfloat162 b): 从两个 nv_bfloat162 输入中的每一个提取低 16 位，并组合成一个 nv_bfloat162 数。
__nv_bfloat162::__nv_bfloat162()=default: 默认构造函数。
__host__ __device__ constexpr __nv_bfloat162::__nv_bfloat162(const __nv_bfloat16 &a, const __nv_bfloat16 &b): 从两个 __nv_bfloat16 变量构造。
__host__ __device__ __nv_bfloat162::__nv_bfloat162(__nv_bfloat162 &&src): 移动构造函数，适用于 C++11 及更高版本。
__host__ __device__ __nv_bfloat162::__nv_bfloat162(const __nv_bfloat162_raw &h2r): 从 __nv_bfloat162_raw 构造。
__host__ __device__ __nv_bfloat162::__nv_bfloat162(const __nv_bfloat162 &src): 复制构造函数。
__host__ __device__ __nv_bfloat162::operator __nv_bfloat162_raw() const: 转换为 __nv_bfloat162_raw 的转换运算符。
__host__ __device__ __nv_bfloat162 & __nv_bfloat162::operator=(const __nv_bfloat162 &src): 复制赋值运算符。
__host__ __device__ __nv_bfloat162 & __nv_bfloat162::operator=(const __nv_bfloat162_raw &h2r): 从 __nv_bfloat162_raw 赋值运算符。
__host__ __device__ __nv_bfloat162 & __nv_bfloat162::operator=(__nv_bfloat162 &&src): 移动赋值运算符，适用于 C++11 及更高版本。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(const double f): 使用默认的四舍五入到最接近的偶数模式，从 double 输入构造 __nv_bfloat16。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(const float f): 使用默认的四舍五入到最接近的偶数模式，从 float 输入构造 __nv_bfloat16。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(long long val): 使用默认的四舍五入到最接近的偶数模式，从 long long 输入构造 __nv_bfloat16。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(unsigned short val): 使用默认的四舍五入到最接近的偶数模式，从 unsigned short 整数输入构造 __nv_bfloat16。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(unsigned int val): 使用默认的四舍五入到最接近的偶数模式，从 unsigned int 输入构造 __nv_bfloat16。
__nv_bfloat16::__nv_bfloat16()=default: 默认构造函数。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(const __half f): 使用默认的四舍五入到最接近的偶数模式，从 __half 输入构造 __nv_bfloat16。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(short val): 使用默认的四舍五入到最接近的偶数模式，从 short 整数输入构造 __nv_bfloat16。
__host__ __device__ constexpr __nv_bfloat16::__nv_bfloat16(const __nv_bfloat16_raw &hr): 从 __nv_bfloat16_raw 构造。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(unsigned long long val): 使用默认的四舍五入到最接近的偶数模式，从 unsigned long long 输入构造 __nv_bfloat16。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(int val): 使用默认的四舍五入到最接近的偶数模式，从 int 输入构造 __nv_bfloat16。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(const unsigned long val): 使用默认的四舍五入到最接近的偶数模式，从 unsigned long 输入构造 __nv_bfloat16。
__host__ __device__ __nv_bfloat16::__nv_bfloat16(const long val): 使用默认的四舍五入到最接近的偶数模式，从 long 输入构造 __nv_bfloat16。
__host__ __device__ __nv_bfloat16::operator __nv_bfloat16_raw() const: 到 __nv_bfloat16_raw 的类型转换运算符。
__host__ __device__ __nv_bfloat16::operator __nv_bfloat16_raw() const volatile: 到 __nv_bfloat16_raw 的类型转换运算符，带有 volatile 输入。
__host__ __device__ constexpr __nv_bfloat16::operator bool() const: 转换为 bool 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator char() const: 转换为实现定义的 char 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator float() const: 到 float 的类型转换运算符。
__host__ __device__ __nv_bfloat16::operator int() const: 转换为 int 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator long() const: 转换为 long 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator long long() const: 转换为 long long 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator short() const: 转换为 short 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator signed char() const: 转换为 signed char 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator unsigned char() const: 转换为 unsigned char 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator unsigned int() const: 转换为 unsigned int 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator unsigned long() const: 转换为 unsigned long 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator unsigned long long() const: 转换为 unsigned long long 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16::operator unsigned short() const: 转换为 unsigned short 数据类型的转换运算符。
__host__ __device__ __nv_bfloat16 & __nv_bfloat16::operator=(const __nv_bfloat16_raw &hr): 从 __nv_bfloat16_raw 的赋值运算符。
__host__ __device__ __nv_bfloat16 & __nv_bfloat16::operator=(unsigned int val): 从 unsigned int 类型转换的赋值运算符，使用默认的舍入到最近的偶数舍入模式。
__host__ __device__ __nv_bfloat16 & __nv_bfloat16::operator=(int val): 从 int 类型转换的赋值运算符，使用默认的舍入到最近的偶数舍入模式。
__host__ __device__ __nv_bfloat16 & __nv_bfloat16::operator=(long long val): 从 long long 类型转换的赋值运算符，使用默认的舍入到最近的偶数舍入模式。
__host__ __device__ __nv_bfloat16 & __nv_bfloat16::operator=(unsigned long long val): 从 unsigned long long 类型转换的赋值运算符，使用默认的舍入到最近的偶数舍入模式。
__host__ __device__ __nv_bfloat16 & __nv_bfloat16::operator=(unsigned short val): 从 unsigned short 类型转换的赋值运算符，使用默认的舍入到最近的偶数舍入模式。
__host__ __device__ volatile __nv_bfloat16 & __nv_bfloat16::operator=(const __nv_bfloat16_raw &hr) volatile: 从 __nv_bfloat16_raw 到 volatile __nv_bfloat16 的赋值运算符。
__host__ __device__ __nv_bfloat16 & __nv_bfloat16::operator=(const double f): 从 double 输入类型转换到 __nv_bfloat16 的赋值运算符，使用默认的舍入到最近的偶数舍入模式。
__host__ __device__ __nv_bfloat16 & __nv_bfloat16::operator=(const float f): 从 float 输入类型转换到 __nv_bfloat16 的赋值运算符，使用默认的舍入到最近的偶数舍入模式。
__host__ __device__ volatile __nv_bfloat16 & __nv_bfloat16::operator=(const volatile __nv_bfloat16_raw &hr) volatile: 从 volatile __nv_bfloat16_raw 到 volatile __nv_bfloat16 的赋值运算符。
__host__ __device__ __nv_bfloat16 & __nv_bfloat16::operator=(short val): 从 short 类型转换的赋值运算符，使用默认的舍入到最近的偶数舍入模式。
__device__ __nv_bfloat162 __shfl_down_sync(const unsigned int mask, const __nv_bfloat162 var, const unsigned int delta, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __nv_bfloat16 __shfl_down_sync(const unsigned int mask, const __nv_bfloat16 var, const unsigned int delta, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __nv_bfloat162 __shfl_sync(const unsigned int mask, const __nv_bfloat162 var, const int srcLane, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __nv_bfloat16 __shfl_sync(const unsigned int mask, const __nv_bfloat16 var, const int srcLane, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __nv_bfloat16 __shfl_up_sync(const unsigned int mask, const __nv_bfloat16 var, const unsigned int delta, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __nv_bfloat162 __shfl_up_sync(const unsigned int mask, const __nv_bfloat162 var, const unsigned int delta, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __nv_bfloat16 __shfl_xor_sync(const unsigned int mask, const __nv_bfloat16 var, const int laneMask, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __nv_bfloat162 __shfl_xor_sync(const unsigned int mask, const __nv_bfloat162 var, const int laneMask, const int width=warpSize): 在 warp 内的线程之间交换变量。
__device__ __nv_bfloat16 __short2bfloat16_rd(const short int i): 以向下舍入模式将有符号 short 整数转换为 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __short2bfloat16_rn(const short int i): 以舍入到最近的偶数模式将有符号 short 整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __short2bfloat16_ru(const short int i): 以向上舍入模式将有符号 short 整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __short2bfloat16_rz(const short int i): 以向零舍入模式将有符号 short 整数转换为 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __short_as_bfloat16(const short int i): 将有符号 short 整数中的位重新解释为 nv_bfloat16 。
__device__ void __stcg(__nv_bfloat16 *const ptr, const __nv_bfloat16 value): 生成 st.global.cg 存储指令。
__device__ void __stcg(__nv_bfloat162 *const ptr, const __nv_bfloat162 value): 生成 st.global.cg 存储指令。
__device__ void __stcs(__nv_bfloat16 *const ptr, const __nv_bfloat16 value): 生成 st.global.cs 存储指令。
__device__ void __stcs(__nv_bfloat162 *const ptr, const __nv_bfloat162 value): 生成 st.global.cs 存储指令。
__device__ void __stwb(__nv_bfloat16 *const ptr, const __nv_bfloat16 value): 生成 st.global.wb 存储指令。
__device__ void __stwb(__nv_bfloat162 *const ptr, const __nv_bfloat162 value): 生成 st.global.wb 存储指令。
__device__ void __stwt(__nv_bfloat162 *const ptr, const __nv_bfloat162 value): 生成 st.global.wt 存储指令。
__device__ void __stwt(__nv_bfloat16 *const ptr, const __nv_bfloat16 value): 生成 st.global.wt 存储指令。
__device__ __nv_bfloat16 __uint2bfloat16_rd(const unsigned int i): 以向下舍入模式将无符号整数转换为 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __uint2bfloat16_rn(const unsigned int i): 以舍入到最近的偶数模式将无符号整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __uint2bfloat16_ru(const unsigned int i): 以向上舍入模式将无符号整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __uint2bfloat16_rz(const unsigned int i): 以向零舍入模式将无符号整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __ull2bfloat16_rd(const unsigned long long int i): 以向下舍入模式将无符号 64 位整数转换为 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __ull2bfloat16_rn(const unsigned long long int i): 以舍入到最近的偶数模式将无符号 64 位整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __ull2bfloat16_ru(const unsigned long long int i): 以向上舍入模式将无符号 64 位整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __ull2bfloat16_rz(const unsigned long long int i): 以向零舍入模式将无符号 64 位整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __ushort2bfloat16_rd(const unsigned short int i): 以向下舍入模式将无符号 short 整数转换为 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __ushort2bfloat16_rn(const unsigned short int i): 以舍入到最近的偶数模式将无符号 short 整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __ushort2bfloat16_ru(const unsigned short int i): 以向上舍入模式将无符号 short 整数转换为 nv_bfloat16。
__device__ __nv_bfloat16 __ushort2bfloat16_rz(const unsigned short int i): 以向零舍入模式将无符号 short 整数转换为 nv_bfloat16。
__host__ __device__ __nv_bfloat16 __ushort_as_bfloat16(const unsigned short int i): 将无符号 short 整数中的位重新解释为 nv_bfloat16 。
__host__ __device__ __nv_bfloat162 make_bfloat162(const __nv_bfloat16 x, const __nv_bfloat16 y): 向量函数，将两个 nv_bfloat16 数字组合成一个 nv_bfloat162 数字。

5.5.1. 函数

__host__ __device__ float2 __bfloat1622float2(const __nv_bfloat162 a)

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

将 nv_bfloat162 输入 a 的两半都转换为 float，并将结果作为打包的 float2 值返回。

另请参阅

__bfloat162float(__nv_bfloat16) 获取更多详细信息。

参数

a – [in] - nv_bfloat162。仅被读取。

返回值

float2

转换为 float2 的 a。

__host__ __device__ __nv_bfloat162 __bfloat162bfloat162(const __nv_bfloat16 a)

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

返回 nv_bfloat162 数字，其两半都等于输入 a nv_bfloat16 数字。

参数

a – [in] - nv_bfloat16。仅被读取。

返回值

nv_bfloat162

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

__host__ __device__ signed char __bfloat162char_rz(const __nv_bfloat16 h)

以向零舍入模式将 nv_bfloat16 转换为有符号 char。

以向零舍入模式将 nv_bfloat16 浮点值 h 转换为有符号 char。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

signed char

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

__host__ __device__ float __bfloat162float(const __nv_bfloat16 a)

将 nv_bfloat16 数转换为 float。

将 nv_bfloat16 数字 a 转换为 float。

参数

a – [in] - float。仅被读取。

返回值

float

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

__device__ int __bfloat162int_rd(const __nv_bfloat16 h)

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

以向下舍入模式将 nv_bfloat16 浮点值 h 转换为有符号整数。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

int

使用向下舍入模式转换为有符号整数的 h。
__bfloat162int_rd \( (\pm 0)\) 返回 0。
__bfloat162int_rd \( (x), x > INT_MAX\) 返回 INT_MAX = 0x7FFFFFFF。
__bfloat162int_rd \( (x), x < INT_MIN\) 返回 INT_MIN = 0x80000000。
__bfloat162int_rd(NaN) 返回 0.*

__device__ int __bfloat162int_rn(const __nv_bfloat16 h)

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

以舍入到最近的偶数模式将 nv_bfloat16 浮点值 h 转换为有符号整数。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

int

h 使用舍入到最近的偶数模式转换为有符号整数。
__bfloat162int_rn \( (\pm 0)\) 返回 0。
__bfloat162int_rn \( (x), x > INT_MAX\) 返回 INT_MAX = 0x7FFFFFFF。
__bfloat162int_rn \( (x), x < INT_MIN\) 返回 INT_MIN = 0x80000000。
__bfloat162int_rn(NaN) 返回 0。

__device__ int __bfloat162int_ru(const __nv_bfloat16 h)

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

以向上舍入模式将 nv_bfloat16 浮点值 h 转换为有符号整数。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

int

h 使用向上舍入模式转换为有符号整数。
__bfloat162int_ru \( (\pm 0)\) 返回 0。
__bfloat162int_ru \( (x), x > INT_MAX\) 返回 INT_MAX = 0x7FFFFFFF。
__bfloat162int_ru \( (x), x < INT_MIN\) 返回 INT_MIN = 0x80000000。
__bfloat162int_ru(NaN) 返回 0。

__host__ __device__ int __bfloat162int_rz(const __nv_bfloat16 h)

以向零舍入模式将 nv_bfloat16 转换为有符号整数。

以向零舍入模式将 nv_bfloat16 浮点值 h 转换为有符号整数。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

int

h 使用向零舍入模式转换为有符号整数。
__bfloat162int_rz \( (\pm 0)\) 返回 0。
__bfloat162int_rz \( (x), x > INT_MAX\) 返回 INT_MAX = 0x7FFFFFFF。
__bfloat162int_rz \( (x), x < INT_MIN\) 返回 INT_MIN = 0x80000000。
__bfloat162int_rz(NaN) 返回 0。

__device__ long long int __bfloat162ll_rd(const __nv_bfloat16 h)

以向下舍入模式将 nv_bfloat16 转换为有符号 64 位整数。

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

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

long long int

转换为有符号 64 位整数的 h。

__device__ long long int __bfloat162ll_rn(const __nv_bfloat16 h)

以四舍五入到最接近的偶数模式将 nv_bfloat16 转换为有符号 64 位整数。

以舍入到最近的偶数模式将 nv_bfloat16 浮点值 h 转换为有符号 64 位整数。NaN 输入返回十六进制值为 0x8000000000000000 的 long long int。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

long long int

转换为有符号 64 位整数的 h。

__device__ long long int __bfloat162ll_ru(const __nv_bfloat16 h)

以向上舍入模式将 nv_bfloat16 转换为有符号 64 位整数。

以向上舍入模式将 nv_bfloat16 浮点值 h 转换为有符号 64 位整数。NaN 输入返回十六进制值为 0x8000000000000000 的 long long int。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

long long int

转换为有符号 64 位整数的 h。

__host__ __device__ long long int __bfloat162ll_rz(const __nv_bfloat16 h)

以向零舍入模式将 nv_bfloat16 转换为有符号 64 位整数。

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

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

long long int

转换为有符号 64 位整数的 h。

__device__ short int __bfloat162short_rd(const __nv_bfloat16 h)

以向下舍入模式将 nv_bfloat16 转换为有符号 short 整数。

将 nv_bfloat16 浮点值 h 转换为有符号 short 整数，采用向下舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

short int

h 转换为有符号 short 整数，采用向下舍入模式。
__bfloat162short_rd \( (\pm 0)\) 返回 0。
__bfloat162short_rd \( (x), x > 32767\) 返回 SHRT_MAX = 0x7FFF。
__bfloat162short_rd \( (x), x < -32768\) 返回 SHRT_MIN = 0x8000。
__bfloat162short_rd(NaN) 返回 0。

__device__ short int __bfloat162short_rn(const __nv_bfloat16 h)

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

将 nv_bfloat16 浮点值 h 转换为有符号 short 整数，采用向最近偶数舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

short int

h 转换为有符号 short 整数，采用向最近偶数舍入模式。
__bfloat162short_rn \( (\pm 0)\) 返回 0。
__bfloat162short_rn \( (x), x > 32767\) 返回 SHRT_MAX = 0x7FFF。
__bfloat162short_rn \( (x), x < -32768\) 返回 SHRT_MIN = 0x8000。
__bfloat162short_rn(NaN) 返回 0。

__device__ short int __bfloat162short_ru(const __nv_bfloat16 h)

以向上舍入模式将 nv_bfloat16 转换为有符号 short 整数。

将 nv_bfloat16 浮点值 h 转换为有符号 short 整数，采用向上舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

short int

h 转换为有符号 short 整数，采用向上舍入模式。
__bfloat162short_ru \( (\pm 0)\) 返回 0。
__bfloat162short_ru \( (x), x > 32767\) 返回 SHRT_MAX = 0x7FFF。
__bfloat162short_ru \( (x), x < -32768\) 返回 SHRT_MIN = 0x8000。
__bfloat162short_ru(NaN) 返回 0。

__host__ __device__ short int __bfloat162short_rz(const __nv_bfloat16 h)

以向零舍入模式将 nv_bfloat16 转换为有符号 short 整数。

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

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

short int

h 转换为有符号 short 整数，采用向零舍入模式。
__bfloat162short_rz \( (\pm 0)\) 返回 0。
__bfloat162short_rz \( (x), x > 32767\) 返回 SHRT_MAX = 0x7FFF。
__bfloat162short_rz \( (x), x < -32768\) 返回 SHRT_MIN = 0x8000。
__bfloat162short_rz(NaN) 返回 0。

__host__ __device__ unsigned char __bfloat162uchar_rz(const __nv_bfloat16 h)

以向零舍入模式将 nv_bfloat16 转换为无符号 char。

将 nv_bfloat16 浮点值 h 转换为 unsigned char，采用向零舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned char

h 转换为 unsigned char，采用向零舍入模式。
__bfloat162uchar_rz \( (\pm 0)\) 返回 0。
__bfloat162uchar_rz \( (x), x > 255\) 返回 UCHAR_MAX = 0xFF。
__bfloat162uchar_rz \( (x), x < 0.0\) 返回 0。
__bfloat162uchar_rz(NaN) 返回 0。

__device__ unsigned int __bfloat162uint_rd(const __nv_bfloat16 h)

以向下舍入模式将 nv_bfloat16 转换为无符号整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned integer，采用向下舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned int

h 转换为 unsigned integer。

__device__ unsigned int __bfloat162uint_rn(const __nv_bfloat16 h)

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

将 nv_bfloat16 浮点值 h 转换为 unsigned integer，采用向最近偶数舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned int

h 转换为 unsigned integer。

__device__ unsigned int __bfloat162uint_ru(const __nv_bfloat16 h)

以向上舍入模式将 nv_bfloat16 转换为无符号整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned integer，采用向上舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned int

h 转换为 unsigned integer。

__host__ __device__ unsigned int __bfloat162uint_rz(const __nv_bfloat16 h)

以向零舍入模式将 nv_bfloat16 转换为无符号整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned integer，采用向零舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned int

h 转换为 unsigned integer。

__device__ unsigned long long int __bfloat162ull_rd(const __nv_bfloat16 h)

以向下舍入模式将 nv_bfloat16 转换为无符号 64 位整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned 64 位整数，采用向下舍入模式。NaN 输入返回 0x8000000000000000。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned long long int

h 转换为 unsigned 64 位整数。

__device__ unsigned long long int __bfloat162ull_rn(const __nv_bfloat16 h)

以四舍五入到最接近的偶数模式将 nv_bfloat16 转换为无符号 64 位整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned 64 位整数，采用向最近偶数舍入模式。NaN 输入返回 0x8000000000000000。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned long long int

h 转换为 unsigned 64 位整数。

__device__ unsigned long long int __bfloat162ull_ru(const __nv_bfloat16 h)

以向上舍入模式将 nv_bfloat16 转换为无符号 64 位整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned 64 位整数，采用向上舍入模式。NaN 输入返回 0x8000000000000000。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned long long int

h 转换为 unsigned 64 位整数。

__host__ __device__ unsigned long long int __bfloat162ull_rz(const __nv_bfloat16 h)

以向零舍入模式将 nv_bfloat16 转换为无符号 64 位整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned 64 位整数，采用向零舍入模式。NaN 输入返回 0x8000000000000000。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned long long int

h 转换为 unsigned 64 位整数。

__device__ unsigned short int __bfloat162ushort_rd(const __nv_bfloat16 h)

以向下舍入模式将 nv_bfloat16 转换为无符号 short 整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned short 整数，采用向下舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned short int

h 转换为 unsigned short 整数。

__device__ unsigned short int __bfloat162ushort_rn(const __nv_bfloat16 h)

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

将 nv_bfloat16 浮点值 h 转换为 unsigned short 整数，采用向最近偶数舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned short int

h 转换为 unsigned short 整数。

__device__ unsigned short int __bfloat162ushort_ru(const __nv_bfloat16 h)

以向上舍入模式将 nv_bfloat16 转换为无符号 short 整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned short 整数，采用向上舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned short int

h 转换为 unsigned short 整数。

__host__ __device__ unsigned short int __bfloat162ushort_rz(const __nv_bfloat16 h)

以向零舍入模式将 nv_bfloat16 转换为无符号 short 整数。

将 nv_bfloat16 浮点值 h 转换为 unsigned short 整数，采用向零舍入模式。NaN 输入被转换为 0。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned short int

h 转换为 unsigned short 整数。

__host__ __device__ short int __bfloat16_as_short(const __nv_bfloat16 h)

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

将 nv_bfloat16 浮点数 h 中的位重新解释为有符号 short 整数。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

short int

重新解释后的值。

__host__ __device__ unsigned short int __bfloat16_as_ushort(const __nv_bfloat16 h)

将 nv_bfloat16 中的位重新解释为无符号 short 整数。

将 nv_bfloat16 浮点数 h 中的位重新解释为 unsigned short 数字。

参数

h – [in] - nv_bfloat16。仅被读取。

返回值

unsigned short int

重新解释后的值。

__host__ __device__ __nv_bfloat16 __double2bfloat16(const double a)

以四舍五入到最接近的偶数模式将 double 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。

将 double 类型数字 a 转换为 nv_bfloat16 精度，采用向最近偶数舍入模式。

参数

a – [in] - double。仅为读取。

返回值

nv_bfloat16

a 转换为 nv_bfloat16，采用向最近偶数舍入模式。
__double2bfloat16 \( (\pm 0)\) 返回 \( \pm 0 \)。
__double2bfloat16 \( (\pm \infty)\) 返回 \( \pm \infty \)。
__double2bfloat16(NaN) 返回 NaN。

__host__ __device__ __nv_bfloat162 __float22bfloat162_rn(const float2 a)

以四舍五入到最接近的偶数模式将 float2 数的两个分量转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat162。

将 float2 的两个分量都转换为 nv_bfloat16 精度，采用向最近偶数舍入模式，并将结果组合成一个 nv_bfloat162 数字。返回值的低 16 位对应于 a.x，高 16 位对应于 a.y。

另请参阅

有关更多详细信息，请参阅 __float2bfloat16_rn(float)。

参数

a – [in] - float2。仅为读取。

返回值

nv_bfloat162

nv_bfloat162，其对应的半部分等于转换后的 float2 分量。

__host__ __device__ __nv_bfloat16 __float2bfloat16(const float a)

以四舍五入到最接近的偶数模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。

将 float 类型数字 a 转换为 nv_bfloat16 精度，采用向最近偶数舍入模式。

另请参阅

有关更多详细信息，请参阅 __float2bfloat16_rn(float)。

参数

a – [in] - float。仅被读取。

返回值

nv_bfloat16

a 转换为 nv_bfloat16，采用向最近偶数舍入模式。

__host__ __device__ __nv_bfloat162 __float2bfloat162_rn(const float a)

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

将输入 a 转换为 nv_bfloat16 精度，采用向最近偶数舍入模式，并用转换后的值填充 nv_bfloat162 的两个半部分。

另请参阅

有关更多详细信息，请参阅 __float2bfloat16_rn(float)。

参数

a – [in] - float。仅被读取。

返回值

nv_bfloat162

nv_bfloat162 值，其两个半部分都等于转换后的 nv_bfloat16 精度数字。

__host__ __device__ __nv_bfloat16 __float2bfloat16_rd(const float a)

以向下舍入模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。

将 float 类型数字 a 转换为 nv_bfloat16 精度，采用向下舍入模式。

参数

a – [in] - float。仅被读取。

返回值

nv_bfloat16

a 转换为 nv_bfloat16，采用向下舍入模式。
__float2bfloat16_rd \( (\pm 0)\) 返回 \( \pm 0 \)。
__float2bfloat16_rd \( (\pm \infty)\) 返回 \( \pm \infty \)。
__float2bfloat16_rd(NaN) 返回 NaN。

__host__ __device__ __nv_bfloat16 __float2bfloat16_rn(const float a)

以四舍五入到最接近的偶数模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。

将 float 类型数字 a 转换为 nv_bfloat16 精度，采用向最近偶数舍入模式。

参数

a – [in] - float。仅被读取。

返回值

nv_bfloat16

a 转换为 nv_bfloat16，采用向最近偶数舍入模式。
__float2bfloat16_rn \( (\pm 0)\) 返回 \( \pm 0 \)。
__float2bfloat16_rn \( (\pm \infty)\) 返回 \( \pm \infty \)。
__float2bfloat16_rn(NaN) 返回 NaN。

__host__ __device__ __nv_bfloat16 __float2bfloat16_ru(const float a)

以向上舍入模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。

将 float 类型数字 a 转换为 nv_bfloat16 精度，采用向上舍入模式。

参数

a – [in] - float。仅被读取。

返回值

nv_bfloat16

a 转换为 nv_bfloat16，采用向上舍入模式。
__float2bfloat16_ru \( (\pm 0)\) 返回 \( \pm 0 \)。
__float2bfloat16_ru \( (\pm \infty)\) 返回 \( \pm \infty \)。
__float2bfloat16_ru(NaN) 返回 NaN。

__host__ __device__ __nv_bfloat16 __float2bfloat16_rz(const float a)

以向零舍入模式将 float 数转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat16。

将 float 类型数字 a 转换为 nv_bfloat16 精度，采用向零舍入模式。

参数

a – [in] - float。仅被读取。

返回值

nv_bfloat16

a 转换为 nv_bfloat16，采用向零舍入模式。
__float2bfloat16_rz \( (\pm 0)\) 返回 \( \pm 0 \)。
__float2bfloat16_rz \( (\pm \infty)\) 返回 \( \pm \infty \)。
__float2bfloat16_rz(NaN) 返回 NaN。

__host__ __device__ __nv_bfloat162 __floats2bfloat162_rn(const float a, const float b)

以四舍五入到最接近的偶数模式将两个输入 float 转换为 nv_bfloat16 精度，并返回包含转换值的 nv_bfloat162。

以就近舍入到偶数模式将两个输入浮点数转换为 nv_bfloat16 精度，并将结果合并为一个 nv_bfloat162 数。返回值中的低 16 位对应于输入 a，高 16 位对应于输入 b。

另请参阅

有关更多详细信息，请参阅 __float2bfloat16_rn(float)。

参数

a – [in] - float。仅被读取。
b – [in] - float。仅被读取。

返回值

nv_bfloat162

nv_bfloat162 值，其对应的半部分等于转换后的输入浮点数。

__host__ __device__ __nv_bfloat162 __halves2bfloat162(const __nv_bfloat16 a, const __nv_bfloat16 b)

将两个 nv_bfloat16 数组合成一个 nv_bfloat162 数。

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

参数

a – [in] - nv_bfloat16。仅被读取。
b – [in] - nv_bfloat16。仅被读取。

返回值

nv_bfloat162

nv_bfloat162，其中一个 nv_bfloat16 等于 a，另一个等于 b。

__host__ __device__ __nv_bfloat16 __high2bfloat16(const __nv_bfloat162 a)

返回 nv_bfloat162 输入的高 16 位。

返回 nv_bfloat162 输入 a 的高 16 位。

参数

a – [in] - nv_bfloat162。仅被读取。

返回值

nv_bfloat16

输入值的高 16 位。

__host__ __device__ __nv_bfloat162 __high2bfloat162(const __nv_bfloat162 a)

从 nv_bfloat162 输入中提取高 16 位。

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

参数

a – [in] - nv_bfloat162。仅被读取。

返回值

nv_bfloat162

nv_bfloat162，其两个半部分都等于输入值的高 16 位。

__host__ __device__ float __high2float(const __nv_bfloat162 a)

将 nv_bfloat162 的高 16 位转换为 float 并返回结果。

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

另请参阅

__bfloat162float(__nv_bfloat16) 获取更多详细信息。

参数

a – [in] - nv_bfloat162。仅被读取。

返回值

float

a 的高 16 位转换为 float。

__host__ __device__ __nv_bfloat162 __highs2bfloat162(const __nv_bfloat162 a, const __nv_bfloat162 b)

从两个 nv_bfloat162 输入中的每一个提取高 16 位，并组合成一个 nv_bfloat162 数。

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

参数

a – [in] - nv_bfloat162。仅被读取。
b – [in] - nv_bfloat162。仅被读取。

返回值

nv_bfloat162

a 和 b 的高 16 位。

__device__ __nv_bfloat16 __int2bfloat16_rd(const int i)

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

以向下舍入模式将有符号整数值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__host__ __device__ __nv_bfloat16 __int2bfloat16_rn(const int i)

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

以就近舍入到偶数模式将有符号整数值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __int2bfloat16_ru(const int i)

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

以向上舍入模式将有符号整数值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __int2bfloat16_rz(const int i)

以向零舍入模式将有符号整数转换为 nv_bfloat16。

以向零舍入模式将有符号整数值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat162 __ldca(const __nv_bfloat162 *const ptr)

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

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

__device__ __nv_bfloat16 __ldca(const __nv_bfloat16 *const ptr)

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

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

__device__ __nv_bfloat16 __ldcg(const __nv_bfloat16 *const ptr)

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

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

__device__ __nv_bfloat162 __ldcg(const __nv_bfloat162 *const ptr)

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

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

__device__ __nv_bfloat162 __ldcs(const __nv_bfloat162 *const ptr)

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

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

__device__ __nv_bfloat16 __ldcs(const __nv_bfloat16 *const ptr)

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

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

__device__ __nv_bfloat16 __ldcv(const __nv_bfloat16 *const ptr)

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

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

__device__ __nv_bfloat162 __ldcv(const __nv_bfloat162 *const ptr)

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

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

__device__ __nv_bfloat162 __ldg(const __nv_bfloat162 *const ptr)

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

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

__device__ __nv_bfloat16 __ldg(const __nv_bfloat16 *const ptr)

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

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

__device__ __nv_bfloat162 __ldlu(const __nv_bfloat162 *const ptr)

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

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

__device__ __nv_bfloat16 __ldlu(const __nv_bfloat16 *const ptr)

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

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

__device__ __nv_bfloat16 __ll2bfloat16_rd(const long long int i)

以向下舍入模式将有符号 64 位整数转换为 nv_bfloat16。

以向下舍入模式将有符号 64 位整数值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__host__ __device__ __nv_bfloat16 __ll2bfloat16_rn(const long long int i)

以四舍五入到最接近的偶数模式将有符号 64 位整数转换为 nv_bfloat16。

以就近舍入到偶数模式将有符号 64 位整数值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __ll2bfloat16_ru(const long long int i)

以向上舍入模式将有符号 64 位整数转换为 nv_bfloat16。

以向上舍入模式将有符号 64 位整数值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __ll2bfloat16_rz(const long long int i)

以向零舍入模式将有符号 64 位整数转换为 nv_bfloat16。

以向零舍入模式将有符号 64 位整数值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__host__ __device__ __nv_bfloat16 __low2bfloat16(const __nv_bfloat162 a)

返回 nv_bfloat162 输入的低 16 位。

返回 nv_bfloat162 输入 a 的低 16 位。

参数

a – [in] - nv_bfloat162。仅被读取。

返回值

nv_bfloat16

返回 nv_bfloat16，其中包含输入 a 的低 16 位。

__host__ __device__ __nv_bfloat162 __low2bfloat162(const __nv_bfloat162 a)

从 nv_bfloat162 输入中提取低 16 位。

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

参数

a – [in] - nv_bfloat162。仅被读取。

返回值

nv_bfloat162

nv_bfloat162，其两个半部分都等于输入值的低 16 位。

__host__ __device__ float __low2float(const __nv_bfloat162 a)

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

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

另请参阅

__bfloat162float(__nv_bfloat16) 获取更多详细信息。

参数

a – [in] - nv_bfloat162。仅被读取。

返回值

float

a 的低 16 位转换为 float。

__host__ __device__ __nv_bfloat162 __lowhigh2highlow(const __nv_bfloat162 a)

交换 nv_bfloat162 输入的两个半精度部分。

交换 nv_bfloat162 输入的两个半部分，并返回一个新的 nv_bfloat162 数，其半部分已交换。

参数

a – [in] - nv_bfloat162。仅被读取。

返回值

nv_bfloat162

a，其半部分已被交换。

__host__ __device__ __nv_bfloat162 __lows2bfloat162(const __nv_bfloat162 a, const __nv_bfloat162 b)

从两个 nv_bfloat162 输入中的每一个提取低 16 位，并组合成一个 nv_bfloat162 数。

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

参数

a – [in] - nv_bfloat162。仅被读取。
b – [in] - nv_bfloat162。仅被读取。

返回值

nv_bfloat162

a 和 b 的低 16 位。

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

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

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

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

注意

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

参数

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

返回值

以 nv_bfloat162 形式返回源线程 ID 中由 var 引用的 4 字节字。

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

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

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

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

注意

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

参数

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

返回值

以 nv_bfloat16 形式返回源线程 ID 中由 var 引用的 2 字节字。

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

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

从索引线程直接复制。

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

注意

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

参数

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

返回值

以 nv_bfloat162 形式返回源线程 ID 中由 var 引用的 4 字节字。

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

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

从索引线程直接复制。

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

注意

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

参数

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

返回值

以 nv_bfloat16 形式返回源线程 ID 中由 var 引用的 2 字节字。

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

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

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

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

注意

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

参数

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

返回值

以 nv_bfloat16 形式返回源线程 ID 中由 var 引用的 2 字节字。

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

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

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

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

注意

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

参数

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

返回值

以 nv_bfloat162 形式返回源线程 ID 中由 var 引用的 4 字节字。

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

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

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

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

注意

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

参数

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

返回值

以 nv_bfloat16 形式返回源线程 ID 中由 var 引用的 2 字节字。

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

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

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

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

注意

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

参数

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

返回值

以 nv_bfloat162 形式返回源线程 ID 中由 var 引用的 4 字节字。

__device__ __nv_bfloat16 __short2bfloat16_rd(const short int i)

以向下舍入模式将有符号 short 整数转换为 nv_bfloat16。

以向下舍入模式将有符号短整型值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__host__ __device__ __nv_bfloat16 __short2bfloat16_rn(const short int i)

以舍入到最近的偶数模式将有符号 short 整数转换为 nv_bfloat16。

以舍入到最近的偶数模式将有符号短整型值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __short2bfloat16_ru(const short int i)

以向上舍入模式将有符号 short 整数转换为 nv_bfloat16。

以向上舍入模式将有符号短整型值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __short2bfloat16_rz(const short int i)

以向零舍入模式将有符号 short 整数转换为 nv_bfloat16。

以向零舍入模式将有符号短整型值 i 转换为 nv_bfloat16 浮点值。

参数

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

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__host__ __device__ __nv_bfloat16 __short_as_bfloat16(const short int i)

将有符号短整型中的位重新解释为 nv_bfloat16。

将有符号短整型 i 中的位重新解释为 nv_bfloat16 浮点数。

参数

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

返回值

nv_bfloat16

重新解释后的值。

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

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

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

参数

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

__device__ __nv_bfloat16 __uint2bfloat16_rd(const unsigned int i)

以向下舍入模式将无符号整数转换为 nv_bfloat16。

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

参数

i – [in] - unsigned int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__host__ __device__ __nv_bfloat16 __uint2bfloat16_rn(const unsigned int i)

以舍入到最近的偶数模式将无符号整数转换为 nv_bfloat16。

将无符号整数值 i 转换为舍入到最接近偶数模式的 nv_bfloat16 浮点值。

参数

i – [in] - unsigned int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __uint2bfloat16_ru(const unsigned int i)

以向上舍入模式将无符号整数转换为 nv_bfloat16。

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

参数

i – [in] - unsigned int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __uint2bfloat16_rz(const unsigned int i)

以向零舍入模式将无符号整数转换为 nv_bfloat16。

将无符号整数值 i 转换为向零舍入模式的 nv_bfloat16 浮点值。

参数

i – [in] - unsigned int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __ull2bfloat16_rd(const unsigned long long int i)

以向下舍入模式将无符号 64 位整数转换为 nv_bfloat16。

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

参数

i – [in] - unsigned long long int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__host__ __device__ __nv_bfloat16 __ull2bfloat16_rn(const unsigned long long int i)

以舍入到最近的偶数模式将无符号 64 位整数转换为 nv_bfloat16。

将无符号 64 位整数值 i 转换为舍入到最接近偶数模式的 nv_bfloat16 浮点值。

参数

i – [in] - unsigned long long int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __ull2bfloat16_ru(const unsigned long long int i)

以向上舍入模式将无符号 64 位整数转换为 nv_bfloat16。

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

参数

i – [in] - unsigned long long int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __ull2bfloat16_rz(const unsigned long long int i)

以向零舍入模式将无符号 64 位整数转换为 nv_bfloat16。

将无符号 64 位整数值 i 转换为向零舍入模式的 nv_bfloat16 浮点值。

参数

i – [in] - unsigned long long int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __ushort2bfloat16_rd(const unsigned short int i)

以向下舍入模式将无符号 short 整数转换为 nv_bfloat16。

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

参数

i – [in] - unsigned short int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__host__ __device__ __nv_bfloat16 __ushort2bfloat16_rn(const unsigned short int i)

以舍入到最近的偶数模式将无符号 short 整数转换为 nv_bfloat16。

将无符号短整数值 i 转换为舍入到最接近偶数模式的 nv_bfloat16 浮点值。

参数

i – [in] - unsigned short int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __ushort2bfloat16_ru(const unsigned short int i)

以向上舍入模式将无符号 short 整数转换为 nv_bfloat16。

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

参数

i – [in] - unsigned short int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__device__ __nv_bfloat16 __ushort2bfloat16_rz(const unsigned short int i)

以向零舍入模式将无符号 short 整数转换为 nv_bfloat16。

将无符号短整数值 i 转换为向零舍入模式的 nv_bfloat16 浮点值。

参数

i – [in] - unsigned short int. 仅为读取。

返回值

nv_bfloat16

转换为 nv_bfloat16 的 i。

__host__ __device__ __nv_bfloat16 __ushort_as_bfloat16(const unsigned short int i)

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

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

参数

i – [in] - unsigned short int. 仅为读取。

返回值

nv_bfloat16

重新解释后的值。

__host__ __device__ __nv_bfloat162 make_bfloat162(const __nv_bfloat16 x, const __nv_bfloat16 y)

向量函数，将两个 nv_bfloat16 数字组合成一个 nv_bfloat162 数字。

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

参数

x – [in] - nv_bfloat16. 仅为读取。
y – [in] - nv_bfloat16. 仅为读取。

返回值

__nv_bfloat162

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