Libdevice 开发者手册

SIMT 编译示例

使用 SIMT 编译的 triton kernel 示例

# Enable libdevice SIMT compilation
import os
os.environ['TRITON_ENABLE_LIBDEVICE_SIMT'] = '1'

import triton
import triton.language as tl
import triton.language.extra.cann.libdevice as libdevice
import torch

@triton.jit
def triton_kernel(input, output, XBLOCK: tl.constexpr, XBLOCK_SUB: tl.constexpr):
    offset = tl.program_id(0) * XBLOCK
    base = tl.arange(0, XBLOCK_SUB)
    loops: tl.constexpr = XBLOCK // XBLOCK_SUB
    for loop in range(loops):
        x0 = offset + (loop * XBLOCK_SUB) + base
        x = tl.load(input + (x0), None)
        y = libdevice.abs(x)
        tl.store(output + (x0), y, None)

dtype, shape, ncore, xblock, xblock_sub = ['int32', (128, 4096), 512, 1024, 1024]
input = torch.randn(shape, dtype=dtype).npu()
output = torch.randn(shape, dtype=dtype).npu()
triton_kernel[ncore, 1, 1](input, output, xblock, xblock_sub, force_simt_only=True)

1. triton.language.extra.cann.libdevice.abs

OP概述

计算输入参数的绝对值。

原型:

triton.language.extra.cann.libdevice.abs(x, _builder=None)

输入类型：

x: int32, float32

返回值: tl.tensor, 返回输入参数的绝对值。

返回类型：int32, float32

支持编译模式：SIMT

2. triton.language.extra.cann.libdevice.acos

OP概述

计算输入参数的反余弦值。

原型:

triton.language.extra.cann.libdevice.acos(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的反余弦值，取值范围 [0, π] 弧度。

返回类型：float32

支持编译模式：SIMT, SIMD

3. triton.language.extra.cann.libdevice.acosh

OP概述

计算输入参数的反双曲余弦值。

原型:

triton.language.extra.cann.libdevice.acosh(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的反双曲余弦值，取值范围 [0, +∞]。

返回类型：float32

支持编译模式：SIMT

4. triton.language.extra.cann.libdevice.add_rd

OP概述

向下舍入浮点数加法。

原型:

triton.language.extra.cann.libdevice.add_rd(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回向下舍入的加法结果。

返回类型：float32

支持编译模式：SIMT

5. triton.language.extra.cann.libdevice.add_rn

OP概述

最近偶数舍入浮点数加法。

原型:

triton.language.extra.cann.libdevice.add_rn(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回最近偶数舍入的加法结果。

返回类型：float32

支持编译模式：SIMT

6. triton.language.extra.cann.libdevice.add_ru

OP概述

向上舍入浮点数加法。

原型:

triton.language.extra.cann.libdevice.add_ru(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回向上舍入的加法结果。

返回类型：float32

支持编译模式：SIMT

7. triton.language.extra.cann.libdevice.add_rz

OP概述

向零舍入浮点数加法。

原型:

triton.language.extra.cann.libdevice.add_rz(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回向零舍入的加法结果。

返回类型：float32

支持编译模式：SIMT

8. triton.language.extra.cann.libdevice.asin

OP概述

计算输入参数的反正弦值。

原型:

triton.language.extra.cann.libdevice.asin(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的反正弦值，取值范围 [-π/2, π/2] 弧度。

返回类型：float32

支持编译模式：SIMT

9. triton.language.extra.cann.libdevice.asinh

OP概述

计算输入参数的反双曲正弦值。

原型:

triton.language.extra.cann.libdevice.asinh(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的反双曲正弦值。

返回类型：float32

支持编译模式：SIMT

10. triton.language.extra.cann.libdevice.atan

OP概述

计算输入参数的反正切值。

原型:

triton.language.extra.cann.libdevice.atan(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的反正切值，取值范围 [-π/2, π/2] 弧度。

返回类型：float32

支持编译模式：SIMT, SIMD

11. triton.language.extra.cann.libdevice.atan2

OP概述

反正切函数，计算 x / y 的反正切值。

原型:

triton.language.extra.cann.libdevice.atan2(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回 x / y 的反正切值，取值范围 [-π, π] 弧度。

返回类型：float32

支持编译模式：SIMT, SIMD

12. triton.language.extra.cann.libdevice.atanh

OP概述

反双曲正切函数，计算输入参数的反双曲正切值。

原型:

triton.language.extra.cann.libdevice.atanh(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的反双曲正切值，取值范围 [-1, 1]。

返回类型：float32

支持编译模式：SIMT

13. triton.language.extra.cann.libdevice.brev

OP概述

位反转函数，反转32位整数的位顺序。

原型:

triton.language.extra.cann.libdevice.brev(x, _builder=None)

输入类型：

x: int32

返回值: tl.tensor, 返回位反转后的32位整数。

返回类型：int32

支持编译模式：SIMT

14. triton.language.extra.cann.libdevice.byte_perm

OP概述

字节排列操作，从两个32位整数中选择字节组成新整数。输入整数 x 和 y 的字节顺序如下。

input[0] = x<7:0>     input[1] = x<15:8>
input[2] = x<23:16>   input[3] = x<31:24>
input[4] = y<7:0>     input[5] = y<15:8>
input[6] = y<23:16>   input[7] = y<31:24>

字节选择参数 s 为32位整数，各比特位与字节选择对应关系如下。

selector[0] = s<2:0>    selector[1] = s<6:4>
selector[2] = s<10:8>   selector[3] = s<14:12>

原型:

triton.language.extra.cann.libdevice.byte_perm(x, y, s, _builder=None)

输入类型：

x: int32
y: int32
s: int32

返回值: tl.tensor, 返回值 return[n] := input[selector[n]]，n 表示输出整数的第 n 个字节。

返回类型：int32

支持编译模式：SIMT

15. triton.language.extra.cann.libdevice.cbrt

OP概述

计算输入参数的立方根值。

原型:

triton.language.extra.cann.libdevice.cbrt(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的立方根值。

返回类型：float32

支持编译模式：SIMT

16. triton.language.extra.cann.libdevice.ceil

OP概述

向上取整，返回大于或等于 x 的最小整数。

原型:

triton.language.extra.cann.libdevice.ceil(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回向上取整的结果。

返回类型：float32

支持编译模式：SIMT

17. triton.language.extra.cann.libdevice.clz

OP概述

计算32位整数的前导零数量。

原型:

triton.language.extra.cann.libdevice.clz(x, _builder=None)

输入类型：

x: int32

返回值: tl.tensor, 返回输入参数的前导零数量。范围 [0, 32]。

返回类型：int32

支持编译模式：SIMT

18. triton.language.extra.cann.libdevice.copysign

OP概述

生成一个浮点数，其绝对值等于 x 的绝对值，符号与 y 相同。

原型:

triton.language.extra.cann.libdevice.copysign(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回一个浮点数，其绝对值等于 x 的绝对值，符号与 y 相同。

返回类型：float32

支持编译模式：SIMT

19. triton.language.extra.cann.libdevice.cos

OP概述

计算输入参数（弧度）的余弦值。

原型:

triton.language.extra.cann.libdevice.cos(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的余弦值。

返回类型：float32

支持编译模式：SIMT

20. triton.language.extra.cann.libdevice.cosh

OP概述

计算输入参数的双曲余弦值。

原型:

triton.language.extra.cann.libdevice.cosh(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的双曲余弦值。

返回类型：float32

支持编译模式：SIMT

21. triton.language.extra.cann.libdevice.cospi

OP概述

计算 cos(π × x) 的值。

原型:

triton.language.extra.cann.libdevice.cospi(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 cos(π × x) 的值。

返回类型：float32

支持编译模式：SIMT

22. triton.language.extra.cann.libdevice.cyl_bessel_i0

OP概述

计算输入参数的修正零阶贝塞尔函数值。

原型:

triton.language.extra.cann.libdevice.cyl_bessel_i0(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的修正零阶贝塞尔函数值。

返回类型：float32

支持编译模式：SIMT

23. triton.language.extra.cann.libdevice.cyl_bessel_i1

OP概述

计算输入参数的修正一阶贝塞尔函数值。

原型:

triton.language.extra.cann.libdevice.cyl_bessel_i1(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的修正一阶贝塞尔函数值。

返回类型：float32

支持编译模式：SIMT

24. triton.language.extra.cann.libdevice.div_rd

OP概述

向下舍入浮点数除法。

原型:

triton.language.extra.cann.libdevice.div_rd(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回除法结果。

返回类型：float32

支持编译模式：SIMT

25. triton.language.extra.cann.libdevice.div_rn

OP概述

最近偶数舍入浮点数除法。

原型:

triton.language.extra.cann.libdevice.div_rn(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回除法结果。

返回类型：float32

支持编译模式：SIMT

26. triton.language.extra.cann.libdevice.div_ru

OP概述

向上舍入浮点数除法。

原型:

triton.language.extra.cann.libdevice.div_ru(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回除法结果。

返回类型：float32

支持编译模式：SIMT

27. triton.language.extra.cann.libdevice.div_rz

OP概述

向零舍入浮点数除法。

原型:

triton.language.extra.cann.libdevice.div_rz(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回除法结果。

返回类型：float32

支持编译模式：SIMT, SIMD

28. triton.language.extra.cann.libdevice.erf

OP概述

计算输入参数的误差函数值。

原型:

triton.language.extra.cann.libdevice.erf(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的误差函数值。

返回类型：float32

支持编译模式：SIMT

29. triton.language.extra.cann.libdevice.erfc

OP概述

计算输入参数的互补误差函数值，即 1 - erf(x)。

原型:

triton.language.extra.cann.libdevice.erfc(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的互补误差函数值。

返回类型：float32

支持编译模式：SIMT

30. triton.language.extra.cann.libdevice.erfcinv

OP概述

逆互补误差函数，找到满足 x = erfc(y) 的值 y。

原型:

triton.language.extra.cann.libdevice.erfcinv(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的逆互补误差函数值。

返回类型：float32

支持编译模式：SIMT

31. triton.language.extra.cann.libdevice.erfcx

OP概述

计算输入参数的缩放互补误差函数值，即 exp(x²) × erfc(x)。

原型:

triton.language.extra.cann.libdevice.erfcx(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的缩放互补误差函数值。

返回类型：float32

支持编译模式：SIMT

32. triton.language.extra.cann.libdevice.erfinv

OP概述

逆误差函数，找到满足 x = erf(y) 的值 y。

原型:

triton.language.extra.cann.libdevice.erfinv(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的逆误差函数值。

返回类型：float32

支持编译模式：SIMT

33. triton.language.extra.cann.libdevice.exp

OP概述

指数函数，计算 e 的 x 次方。

原型:

triton.language.extra.cann.libdevice.exp(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 e 的 x 次方的计算结果。

返回类型：float32

支持编译模式：SIMT

34. triton.language.extra.cann.libdevice.exp10

OP概述

以 10 为底的指数函数，计算 10 的 x 次方。

原型:

triton.language.extra.cann.libdevice.exp10(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 10 的 x 次方的计算结果。

返回类型：float32

支持编译模式：SIMT

35. triton.language.extra.cann.libdevice.exp2

OP概述

以 2 为底的指数函数，计算 2 的 x 次方。

原型:

triton.language.extra.cann.libdevice.exp2(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 2 的 x 次方的计算结果。

返回类型：float32

支持编译模式：SIMT

36. triton.language.extra.cann.libdevice.expm1

OP概述

计算 e 的 x 次方减 1 的结果。

原型:

triton.language.extra.cann.libdevice.expm1(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 e 的 x 次方减 1 的计算结果。

返回类型：float32

支持编译模式：SIMT

37. triton.language.extra.cann.libdevice.fast_cosf

OP概述

快速近似余弦函数。

原型:

triton.language.extra.cann.libdevice.fast_cosf(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回快速近似余弦函数的结果。

返回类型：float32

支持编译模式：SIMT

38. triton.language.extra.cann.libdevice.fast_dividef

OP概述

快速近似除法。

原型:

triton.language.extra.cann.libdevice.fast_dividef(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回快速近似除法的结果。

返回类型：float32

支持编译模式：SIMT, SIMD

39. triton.language.extra.cann.libdevice.fast_exp10f

OP概述

快速近似以 10 为底的指数函数。

原型:

triton.language.extra.cann.libdevice.fast_exp10f(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回快速近似以 10 为底的指数函数的结果。

返回类型：float32

支持编译模式：SIMT

40. triton.language.extra.cann.libdevice.fast_expf

OP概述

快速近似指数函数。

原型:

triton.language.extra.cann.libdevice.fast_expf(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回快速近似指数函数的结果。

返回类型：float32

支持编译模式：SIMT, SIMD

41. triton.language.extra.cann.libdevice.fast_log10f

OP概述

快速近似以 10 为底的对数函数。

原型:

triton.language.extra.cann.libdevice.fast_log10f(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回快速近似以 10 为底的对数函数的结果。

返回类型：float32

支持编译模式：SIMT

42. triton.language.extra.cann.libdevice.fast_log2f

OP概述

快速近似以 2 为底的对数函数。

原型:

triton.language.extra.cann.libdevice.fast_log2f(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回快速近似以 2 为底的对数函数的结果。

返回类型：float32

支持编译模式：SIMT

43. triton.language.extra.cann.libdevice.fast_logf

OP概述

快速近似自然对数函数。

原型:

triton.language.extra.cann.libdevice.fast_logf(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回快速近似自然对数函数的结果。

返回类型：float32

支持编译模式：SIMT

44. triton.language.extra.cann.libdevice.fast_powf

OP概述

快速近似幂函数。

原型:

triton.language.extra.cann.libdevice.fast_powf(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回快速近似幂函数的结果。

返回类型：float32

支持编译模式：SIMT

45. triton.language.extra.cann.libdevice.fast_sinf

OP概述

快速近似正弦函数。

原型:

triton.language.extra.cann.libdevice.fast_sinf(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回快速近似正弦函数的结果。

返回类型：float32

支持编译模式：SIMT

46. triton.language.extra.cann.libdevice.fast_tanf

OP概述

快速近似正切函数。

原型:

triton.language.extra.cann.libdevice.fast_tanf(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回快速近似正切函数的结果。

返回类型：float32

支持编译模式：SIMT

47. triton.language.extra.cann.libdevice.fdim

OP概述

计算 x 与 y 的正差。当 x > y 时，返回 x - y，否则返回 0。

原型:

triton.language.extra.cann.libdevice.fdim(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回 x 与 y 之间的正差。

返回类型：float32

支持编译模式：SIMT

48. triton.language.extra.cann.libdevice.fdiv

OP概述

浮点数除法。

原型:

triton.language.extra.cann.libdevice.fdiv(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回浮点数除法结果。

返回类型：float32

支持编译模式：SIMT

49. triton.language.extra.cann.libdevice.ffs

OP概述

查找第一个被置为1的位，返回最低被置为1的位的索引。

原型:

triton.language.extra.cann.libdevice.ffs(x, _builder=None)

输入类型：

x: int32

返回值: tl.tensor, 返回最低被置为1的位的索引，取值范围 [0, 32]。

返回类型：int32

支持编译模式：SIMT

50. triton.language.extra.cann.libdevice.finitef

OP概述

判断输入是否为有限浮点数。

原型:

triton.language.extra.cann.libdevice.finitef(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 若输入为有限值返回 True，否则返回 False。

返回类型：bool

支持编译模式：SIMT

51. triton.language.extra.cann.libdevice.flip

OP概述

沿指定维度反转张量元素顺序。

输入类型：

ptr: tensor
dim: int32

返回值: tl.tensor, 返回沿指定维度反转后的张量。

返回类型：tensor

支持编译模式：SIMT

52. triton.language.extra.cann.libdevice.float2int_rd

OP概述

向下舍入模式将浮点数转换为32位整数。

原型:

triton.language.extra.cann.libdevice.float2int_rd(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的32位整数。

返回类型：int32

支持编译模式：SIMT

53. triton.language.extra.cann.libdevice.float2int_rn

OP概述

最近偶数舍入模式将浮点数转换为32位整数。

原型:

triton.language.extra.cann.libdevice.float2int_rn(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的32位整数。

返回类型：int32

支持编译模式：SIMT

54. triton.language.extra.cann.libdevice.float2int_ru

OP概述

向上舍入模式将浮点数转换为32位整数。

原型:

triton.language.extra.cann.libdevice.float2int_ru(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的32位整数。

返回类型：int32

支持编译模式：SIMT

55. triton.language.extra.cann.libdevice.float2int_rz

OP概述

向零舍入模式将浮点数转换为32位整数。

原型:

triton.language.extra.cann.libdevice.float2int_rz(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的32位整数。

返回类型：int32

支持编译模式：SIMT

56. triton.language.extra.cann.libdevice.float2ll_rd

OP概述

向下舍入模式将浮点数转换为64位整数。

原型:

triton.language.extra.cann.libdevice.float2ll_rd(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的64位整数。

返回类型：int64

支持编译模式：SIMT

57. triton.language.extra.cann.libdevice.float2ll_rn

OP概述

最近偶数舍入模式将浮点数转换为64位整数。

原型:

triton.language.extra.cann.libdevice.float2ll_rn(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的64位整数。

返回类型：int64

支持编译模式：SIMT

58. triton.language.extra.cann.libdevice.float2ll_ru

OP概述

向上舍入模式将浮点数转换为64位整数。

原型:

triton.language.extra.cann.libdevice.float2ll_ru(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的64位整数。

返回类型：int64

支持编译模式：SIMT

59. triton.language.extra.cann.libdevice.float2ll_rz

OP概述

向零舍入模式将浮点数转换为64位整数。

原型:

triton.language.extra.cann.libdevice.float2ll_rz(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的64位整数。

返回类型：int64

支持编译模式：SIMT

60. triton.language.extra.cann.libdevice.float2uint_rd

OP概述

向下舍入模式将浮点数转换为32位无符号整数。

原型:

triton.language.extra.cann.libdevice.float2uint_rd(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的32位无符号整数。

返回类型：uint32

支持编译模式：SIMT

61. triton.language.extra.cann.libdevice.float2uint_rn

OP概述

最近偶数舍入模式将浮点数转换为32位无符号整数。

原型:

triton.language.extra.cann.libdevice.float2uint_rn(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的32位无符号整数。

返回类型：uint32

支持编译模式：SIMT

62. triton.language.extra.cann.libdevice.float2uint_ru

OP概述

向上舍入模式将浮点数转换为32位无符号整数。

原型:

triton.language.extra.cann.libdevice.float2uint_ru(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的32位无符号整数。

返回类型：uint32

支持编译模式：SIMT

63. triton.language.extra.cann.libdevice.float2uint_rz

OP概述

向零舍入模式将浮点数转换为32位无符号整数。

原型:

triton.language.extra.cann.libdevice.float2uint_rz(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的32位无符号整数。

返回类型：uint32

支持编译模式：SIMT

64. triton.language.extra.cann.libdevice.float2ull_rd

OP概述

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

原型:

triton.language.extra.cann.libdevice.float2ull_rd(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的64位无符号整数。

返回类型：uint64

支持编译模式：SIMT

65. triton.language.extra.cann.libdevice.float2ull_rn

OP概述

最近偶数舍入模式将浮点数转换为64位无符号整数。

原型:

triton.language.extra.cann.libdevice.float2ull_rn(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的64位无符号整数。

返回类型：uint64

支持编译模式：SIMT

66. triton.language.extra.cann.libdevice.float2ull_ru

OP概述

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

原型:

triton.language.extra.cann.libdevice.float2ull_ru(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的64位无符号整数。

返回类型：uint64

支持编译模式：SIMT

67. triton.language.extra.cann.libdevice.float2ull_rz

OP概述

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

原型:

triton.language.extra.cann.libdevice.float2ull_rz(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回转换后的64位无符号整数。

返回类型：uint64

支持编译模式：SIMT

68. triton.language.extra.cann.libdevice.float_as_int

OP概述

将浮点数的比特位重新解释为32位整数。不进行数值转换。

原型:

triton.language.extra.cann.libdevice.float_as_int(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回将浮点数的比特位重新解释为32位整数的结果。

返回类型：int32

支持编译模式：SIMT, SIMD

69. triton.language.extra.cann.libdevice.float_as_uint

OP概述

将浮点数的比特位重新解释为32位无符号整数。不进行数值转换。

原型:

triton.language.extra.cann.libdevice.float_as_uint(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回将浮点数的比特位重新解释为32位无符号整数的结果。

返回类型：uint32

支持编译模式：SIMT

70. triton.language.extra.cann.libdevice.floor

OP概述

向下取整，返回小于或等于 x 的最大整数。

原型:

triton.language.extra.cann.libdevice.floor(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回向下取整的结果。

返回类型：float32

支持编译模式：SIMT

71. triton.language.extra.cann.libdevice.fma

OP概述

融合乘加，计算 x × y + z。

原型:

triton.language.extra.cann.libdevice.fma(x, y, z, _builder=None)

输入类型：

x: float32
y: float32
z: float32

返回值: tl.tensor, 返回融合乘加的结果。

返回类型：float32

支持编译模式：SIMT

72. triton.language.extra.cann.libdevice.fma_rd

OP概述

向下舍入模式下的融合乘加操作。

原型:

triton.language.extra.cann.libdevice.fma_rd(x, y, z, _builder=None)

输入类型：

x: float32
y: float32
z: float32

返回值: tl.tensor, 返回融合乘加的结果。

返回类型：float32

支持编译模式：SIMT

73. triton.language.extra.cann.libdevice.fma_rn

OP概述

最近偶数舍入模式下的融合乘加操作。

原型:

triton.language.extra.cann.libdevice.fma_rn(x, y, z, _builder=None)

输入类型：

x: float32
y: float32
z: float32

返回值: tl.tensor, 返回融合乘加的结果。

返回类型：float32

支持编译模式：SIMT

74. triton.language.extra.cann.libdevice.fma_ru

OP概述

向上舍入模式下的融合乘加操作。

原型:

triton.language.extra.cann.libdevice.fma_ru(x, y, z, _builder=None)

输入类型：

x: float32
y: float32
z: float32

返回值: tl.tensor, 返回融合乘加的结果。

返回类型：float32

支持编译模式：SIMT

75. triton.language.extra.cann.libdevice.fma_rz

OP概述

向零舍入模式下的融合乘加操作。

原型:

triton.language.extra.cann.libdevice.fma_rz(x, y, z, _builder=None)

输入类型：

x: float32
y: float32
z: float32

返回值: tl.tensor, 返回融合乘加的结果。

返回类型：float32

支持编译模式：SIMT

76. triton.language.extra.cann.libdevice.fmod

OP概述

浮点数取模，计算 x / y 的余数，结果与 x 同号。

原型:

triton.language.extra.cann.libdevice.fmod(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回浮点数取模的结果。

返回类型：float32

支持编译模式：SIMT, SIMD

77. triton.language.extra.cann.libdevice.gamma

OP概述

计算输入参数的伽马函数值。

原型:

triton.language.extra.cann.libdevice.gamma(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的伽马函数值。

返回类型：float32

支持编译模式：SIMT

78. triton.language.extra.cann.libdevice.hadd

OP概述

计算 x 和 y 的平均值。

原型:

triton.language.extra.cann.libdevice.hadd(x, y, _builder=None)

输入类型：

x: int32
y: int32

返回值: tl.tensor, 返回 x 和 y 的平均值。

返回类型：int32

支持编译模式：SIMT

79. triton.language.extra.cann.libdevice.hypot

OP概述

计算 x 和 y 之间的欧几里得距离。

原型:

triton.language.extra.cann.libdevice.hypot(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回 x 和 y 之间的欧几里得距离。

返回类型：float32

支持编译模式：SIMT

80. triton.language.extra.cann.libdevice.ilogb

OP概述

提取浮点数的无偏指数（以2为底的整数对数）。

原型:

triton.language.extra.cann.libdevice.ilogb(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的无偏指数值。

返回类型：float32

支持编译模式：SIMT, SIMD

81. triton.language.extra.cann.libdevice.int2float_rd

OP概述

向下舍入模式将32位整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.int2float_rd(x, _builder=None)

输入类型：

x: int32

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

82. triton.language.extra.cann.libdevice.int2float_rn

OP概述

最近偶数舍入模式将32位整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.int2float_rn(x, _builder=None)

输入类型：

x: int32

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

83. triton.language.extra.cann.libdevice.int2float_ru

OP概述

向上舍入模式将32位整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.int2float_ru(x, _builder=None)

输入类型：

x: int32

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

84. triton.language.extra.cann.libdevice.int2float_rz

OP概述

向零舍入模式将32位整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.int2float_rz(x, _builder=None)

输入类型：

x: int32

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

85. triton.language.extra.cann.libdevice.int_as_float

OP概述

将32位整数的比特位重新解释为浮点数。不进行数值转换。

原型:

triton.language.extra.cann.libdevice.int_as_float(x, _builder=None)

输入类型：

x: int32

返回值: tl.tensor, 返回将32位整数的比特位重新解释为浮点数的结果。

返回类型：float32

支持编译模式：SIMT

86. triton.language.extra.cann.libdevice.isfinited

OP概述

判断输入是否为有限值。

原型:

triton.language.extra.cann.libdevice.isfinited(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 若输入为有限值返回 True，否则返回 False。

返回类型：bool

支持编译模式：SIMT

87. triton.language.extra.cann.libdevice.isinf

OP概述

判断输入是否为无穷大。

原型:

triton.language.extra.cann.libdevice.isinf(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 若输入为无穷大返回 True，否则返回 False。

返回类型：bool

支持编译模式：SIMT, SIMD

88. triton.language.extra.cann.libdevice.isnan

OP概述

判断输入是否为 NaN（非数值）。

原型:

triton.language.extra.cann.libdevice.isnan(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 若输入为 NaN 返回 True，否则返回 False。

返回类型：bool

支持编译模式：SIMT, SIMD

89. triton.language.extra.cann.libdevice.j0

OP概述

计算输入参数的零阶第一类贝塞尔函数值。

原型:

triton.language.extra.cann.libdevice.j0(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的零阶第一类贝塞尔函数值。

返回类型：float32

支持编译模式：SIMT

90. triton.language.extra.cann.libdevice.j1

OP概述

计算输入参数的一阶第一类贝塞尔函数值。

原型:

triton.language.extra.cann.libdevice.j1(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的一阶第一类贝塞尔函数值。

返回类型：float32

支持编译模式：SIMT

91. triton.language.extra.cann.libdevice.jn

OP概述

计算输入参数的 n 阶第一类贝塞尔函数值。

原型:

triton.language.extra.cann.libdevice.jn(n, x, _builder=None)

输入类型：

n: int32
x: float32

返回值: tl.tensor, 返回输入参数的 n 阶第一类贝塞尔函数值。

返回类型：float32

支持编译模式：SIMT

92. triton.language.extra.cann.libdevice.ldexp

OP概述

计算 x × 2^exp 的值。

原型:

triton.language.extra.cann.libdevice.ldexp(x, exp, _builder=None)

输入类型：

x: float32
exp: int32

返回值: tl.tensor, 返回 x × 2^exp 的计算结果。

返回类型：float32

支持编译模式：SIMT, SIMD

93. triton.language.extra.cann.libdevice.lgamma

OP概述

计算输入为 x 的伽马函数绝对值的自然对数。

原型:

triton.language.extra.cann.libdevice.lgamma(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入为 x 的伽马函数绝对值的自然对数。

返回类型：float32

支持编译模式：SIMT

94. triton.language.extra.cann.libdevice.ll2float_rd

OP概述

向下舍入模式将64位整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.ll2float_rd(x, _builder=None)

输入类型：

x: int64

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

95. triton.language.extra.cann.libdevice.ll2float_rn

OP概述

最近偶数舍入模式将64位整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.ll2float_rn(x, _builder=None)

输入类型：

x: int64

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

96. triton.language.extra.cann.libdevice.ll2float_ru

OP概述

向上舍入模式将64位整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.ll2float_ru(x, _builder=None)

输入类型：

x: int64

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

97. triton.language.extra.cann.libdevice.ll2float_rz

OP概述

向零舍入模式将64位整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.ll2float_rz(x, _builder=None)

输入类型：

x: int64

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

98. triton.language.extra.cann.libdevice.llrint

OP概述

将浮点数舍入为最接近的64位整数值。

原型:

triton.language.extra.cann.libdevice.llrint(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回舍入后的64位整数。

返回类型：int64

支持编译模式：SIMT

99. triton.language.extra.cann.libdevice.llround

OP概述

将浮点数四舍五入为最接近的64位整数值。

原型:

triton.language.extra.cann.libdevice.llround(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回舍入后的64位整数。

返回类型：int64

支持编译模式：SIMT

100. triton.language.extra.cann.libdevice.log

OP概述

计算输入为 x 的以 e 为底的对数。

原型:

triton.language.extra.cann.libdevice.log(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入为 x 的以 e 为底的对数。

返回类型：float32

支持编译模式：SIMT

101. triton.language.extra.cann.libdevice.log10

OP概述

计算输入为 x 的以 10 为底的对数。

原型:

triton.language.extra.cann.libdevice.log10(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入为 x 的以 10 为底的对数。

返回类型：float32

支持编译模式：SIMT

102. triton.language.extra.cann.libdevice.log1p

OP概述

计算 log(1 + x) 的值。

原型:

triton.language.extra.cann.libdevice.log1p(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 log(1 + x) 的计算结果。

返回类型：float32

支持编译模式：SIMT, SIMD

103. triton.language.extra.cann.libdevice.log2

OP概述

计算输入为 x 的以 2 为底的对数。

原型:

triton.language.extra.cann.libdevice.log2(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入为 x 的以 2 为底的对数。

返回类型：float32

支持编译模式：SIMT

104. triton.language.extra.cann.libdevice.logb

OP概述

提取浮点数的指数值。

原型:

triton.language.extra.cann.libdevice.logb(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的指数值。

返回类型：float32

支持编译模式：SIMT

105. triton.language.extra.cann.libdevice.mul24

OP概述

计算 x 和 y 的低24位乘法结果。

原型:

triton.language.extra.cann.libdevice.mul24(x, y, _builder=None)

输入类型：

x: int32
y: int32

返回值: tl.tensor, 返回 x 和 y 的低24位乘法结果。

返回类型：int32

支持编译模式：SIMT

106. triton.language.extra.cann.libdevice.mul_rd

OP概述

向下舍入浮点数乘法。

原型:

triton.language.extra.cann.libdevice.mul_rd(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回浮点数乘法的结果。

返回类型：float32

支持编译模式：SIMT

107. triton.language.extra.cann.libdevice.mul_rn

OP概述

最近偶数舍入浮点数乘法。

原型:

triton.language.extra.cann.libdevice.mul_rn(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回浮点数乘法的结果。

返回类型：float32

支持编译模式：SIMT

108. triton.language.extra.cann.libdevice.mul_ru

OP概述

向上舍入浮点数乘法。

原型:

triton.language.extra.cann.libdevice.mul_ru(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回浮点数乘法的结果。

返回类型：float32

支持编译模式：SIMT

109. triton.language.extra.cann.libdevice.mul_rz

OP概述

向零舍入浮点数乘法。

原型:

triton.language.extra.cann.libdevice.mul_rz(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回浮点数乘法的结果。

返回类型：float32

支持编译模式：SIMT

110. triton.language.extra.cann.libdevice.mulhi

OP概述

计算 x 和 y 的乘法结果的高 32 位。

原型:

triton.language.extra.cann.libdevice.mulhi(x, y, _builder=None)

输入类型：

x: int32
y: int32

返回值: tl.tensor, 返回 x 和 y 的乘法结果的高 32 位。

返回类型：int32

支持编译模式：SIMT

111. triton.language.extra.cann.libdevice.nearbyint

OP概述

将 x 转换为最近邻整数。

原型:

triton.language.extra.cann.libdevice.nearbyint(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回最近邻整数。

返回类型：float32

支持编译模式：SIMT

112. triton.language.extra.cann.libdevice.nextafter

OP概述

计算从 x 方向朝 y 的下一个可表示浮点数。

原型:

triton.language.extra.cann.libdevice.nextafter(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回下一个可表示浮点数。

返回类型：float32

支持编译模式：SIMT

113. triton.language.extra.cann.libdevice.norm3d

OP概述

计算三维向量的欧几里得范数，即 sqrt(x² + y² + z²)。

原型:

triton.language.extra.cann.libdevice.norm3d(x, y, z, _builder=None)

输入类型：

x: float32
y: float32
z: float32

返回值: tl.tensor, 返回三维向量的欧几里得范数。

返回类型：float32

支持编译模式：SIMT

114. triton.language.extra.cann.libdevice.norm4d

OP概述

计算四维向量的欧几里得范数，即 sqrt(x² + y² + z² + w²)。

原型:

triton.language.extra.cann.libdevice.norm4d(x, y, z, w, _builder=None)

输入类型：

x: float32
y: float32
z: float32
w: float32

返回值: tl.tensor, 返回四维向量的欧几里得范数。

返回类型：float32

支持编译模式：SIMT

115. triton.language.extra.cann.libdevice.normcdf

OP概述

计算标准正态分布的累积分布函数值。

原型:

triton.language.extra.cann.libdevice.normcdf(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回标准正态分布的累积分布函数值。

返回类型：float32

支持编译模式：SIMT

116. triton.language.extra.cann.libdevice.normcdfinv

OP概述

计算标准正态分布累积分布函数的逆函数值。

原型:

triton.language.extra.cann.libdevice.normcdfinv(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回标准正态分布累积分布函数的逆函数值。

返回类型：float32

支持编译模式：SIMT

117. triton.language.extra.cann.libdevice.popc

OP概述

计算 x 中置位为 1 的数量。

原型:

triton.language.extra.cann.libdevice.popc(x, _builder=None)

输入类型：

x: int32

返回值: tl.tensor, 返回 x 中置位为 1 的数量，取值范围 [0, 32]。

返回类型：int32

支持编译模式：SIMT

118. triton.language.extra.cann.libdevice.pow

OP概述

幂函数，计算 x 的 y 次方。

原型:

triton.language.extra.cann.libdevice.pow(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回 x 的 y 次方。

返回类型：float32

支持编译模式：SIMT, SIMD

119. triton.language.extra.cann.libdevice.rcbrt

OP概述

计算 x 的立方根倒数。

原型:

triton.language.extra.cann.libdevice.rcbrt(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的立方根倒数。

返回类型：float32

支持编译模式：SIMT

120. triton.language.extra.cann.libdevice.rcp_rd

OP概述

向下舍入浮点数倒数运算。

原型:

triton.language.extra.cann.libdevice.rcp_rd(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 1 / x。

返回类型：float32

支持编译模式：SIMT

121. triton.language.extra.cann.libdevice.rcp_rn

OP概述

最近偶数舍入浮点数倒数运算。

原型:

triton.language.extra.cann.libdevice.rcp_rn(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 1 / x。

返回类型：float32

支持编译模式：SIMT

122. triton.language.extra.cann.libdevice.rcp_ru

OP概述

向上舍入浮点数倒数运算。

原型:

triton.language.extra.cann.libdevice.rcp_ru(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 1 / x。

返回类型：float32

支持编译模式：SIMT

123. triton.language.extra.cann.libdevice.rcp_rz

OP概述

向零舍入浮点数倒数运算。

原型:

triton.language.extra.cann.libdevice.rcp_rz(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 1 / x。

返回类型：float32

支持编译模式：SIMT

124. triton.language.extra.cann.libdevice.reciprocal

OP概述

计算 1 / x 的倒数运算。

原型:

triton.language.extra.cann.libdevice.reciprocal(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 1 / x。

返回类型：float32

支持编译模式：SIMT, SIMD

125. triton.language.extra.cann.libdevice.relu

OP概述

修正线性单元函数，当 x > 0 时返回 x，否则返回 0。

原型:

triton.language.extra.cann.libdevice.relu(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回修正线性单元的结果。

返回类型：float32

支持编译模式：SIMT, SIMD

126. triton.language.extra.cann.libdevice.remainder

OP概述

计算 x 对 y 的余数，满足 r = x - ny，其中 n 是 x / y 的最近邻整数。

原型:

triton.language.extra.cann.libdevice.remainder(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回 x 对 y 的余数。

返回类型：float32

支持编译模式：SIMT

127. triton.language.extra.cann.libdevice.rhadd

OP概述

计算 x 和 y 平均值的取整结果。

原型:

triton.language.extra.cann.libdevice.rhadd(x, y, _builder=None)

输入类型：

x: int32
y: int32

返回值: tl.tensor, 返回 x 和 y 平均值的取整结果。

返回类型：int32

支持编译模式：SIMT

128. triton.language.extra.cann.libdevice.rhypot

OP概述

计算 x 和 y 之间的欧几里得距离的倒数。

原型:

triton.language.extra.cann.libdevice.rhypot(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回 x 和 y 之间的欧几里得距离的倒数。

返回类型：float32

支持编译模式：SIMT

129. triton.language.extra.cann.libdevice.rint

OP概述

按最近偶数舍入模式计算 x 的最近邻整数。

原型:

triton.language.extra.cann.libdevice.rint(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的最近邻整数。

返回类型：float32

支持编译模式：SIMT

130. triton.language.extra.cann.libdevice.rnorm3d

OP概述

计算三维向量的欧几里得范数的倒数。

原型:

triton.language.extra.cann.libdevice.rnorm3d(x, y, z, _builder=None)

输入类型：

x: float32
y: float32
z: float32

返回值: tl.tensor, 返回三维向量的欧几里得范数的倒数。

返回类型：float32

支持编译模式：SIMT

131. triton.language.extra.cann.libdevice.rnorm4d

OP概述

计算四维向量的欧几里得范数的倒数。

原型:

triton.language.extra.cann.libdevice.rnorm4d(x, y, z, w, _builder=None)

输入类型：

x: float32
y: float32
z: float32
w: float32

返回值: tl.tensor, 返回四维向量的欧几里得范数的倒数。

返回类型：float32

支持编译模式：SIMT

132. triton.language.extra.cann.libdevice.round

OP概述

按最近偶数舍入模式计算 x 的最近邻整数。

原型:

triton.language.extra.cann.libdevice.round(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的最近邻整数。

返回类型：float32

支持编译模式：SIMT, SIMD

133. triton.language.extra.cann.libdevice.rsqrt

OP概述

计算 x 的平方根倒数。

原型:

triton.language.extra.cann.libdevice.rsqrt(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的平方根倒数。

返回类型：float32

支持编译模式：SIMT

134. triton.language.extra.cann.libdevice.rsqrt_rn

OP概述

按最近偶数舍入模式计算 x 的平方根倒数。

原型:

triton.language.extra.cann.libdevice.rsqrt_rn(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的平方根倒数。

返回类型：float32

支持编译模式：SIMT

135. triton.language.extra.cann.libdevice.sad

OP概述

计算 |x-y|+z，其中 x 和 y 是有符号整数，z 是无符号整数。

原型:

triton.language.extra.cann.libdevice.sad(x, y, z, _builder=None)

输入类型：

x: int32
y: int32
z: int32

返回值: tl.tensor, 返回 |x-y|+z。

返回类型：int32

支持编译模式：SIMT

136. triton.language.extra.cann.libdevice.saturatef

OP概述

将 x 限制在 [+0.0, 1.0] 范围内。

原型:

triton.language.extra.cann.libdevice.saturatef(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的饱和值，取值范围 [+0.0, 1.0]。

返回类型：float32

支持编译模式：SIMT

137. triton.language.extra.cann.libdevice.scalbn

OP概述

计算 x × 2^n 的值。

原型:

triton.language.extra.cann.libdevice.scalbn(x, n, _builder=None)

输入类型：

x: float32
n: int32

返回值: tl.tensor, 返回 x × 2^n 的计算结果。

返回类型：float32

支持编译模式：SIMT

138. triton.language.extra.cann.libdevice.signbit

OP概述

获取 x 的符号位。

原型:

triton.language.extra.cann.libdevice.signbit(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的符号位。

返回类型：int32

支持编译模式：SIMT

139. triton.language.extra.cann.libdevice.sin

OP概述

计算输入参数 x （弧度）的正弦值。

原型:

triton.language.extra.cann.libdevice.sin(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入 x 的正弦值。

返回类型：float32

支持编译模式：SIMT

140. triton.language.extra.cann.libdevice.sinh

OP概述

计算输入参数 x 的双曲正弦值。

原型:

triton.language.extra.cann.libdevice.sinh(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入 x 的双曲正弦值。

返回类型：float32

支持编译模式：SIMT

141. triton.language.extra.cann.libdevice.sinpi

OP概述

计算 sin(π × x) 的值。

原型:

triton.language.extra.cann.libdevice.sinpi(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 sin(π × x) 的值。

返回类型：float32

支持编译模式：SIMT

142. triton.language.extra.cann.libdevice.sqrt

OP概述

计算 x 的平方根值。

原型:

triton.language.extra.cann.libdevice.sqrt(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的平方根值。

返回类型：float32

支持编译模式：SIMT

143. triton.language.extra.cann.libdevice.sqrt_rd

OP概述

向下舍入模式计算 x 的平方根值。

原型:

triton.language.extra.cann.libdevice.sqrt_rd(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的平方根值。

返回类型：float32

支持编译模式：SIMT

144. triton.language.extra.cann.libdevice.sqrt_rn

OP概述

最近偶数舍入模式计算 x 的平方根值。

原型:

triton.language.extra.cann.libdevice.sqrt_rn(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的平方根值。

返回类型：float32

支持编译模式：SIMT

145. triton.language.extra.cann.libdevice.sqrt_ru

OP概述

向上舍入模式计算 x 的平方根值。

原型:

triton.language.extra.cann.libdevice.sqrt_ru(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的平方根值。

返回类型：float32

支持编译模式：SIMT

146. triton.language.extra.cann.libdevice.sqrt_rz

OP概述

向零舍入模式计算 x 的平方根值。

原型:

triton.language.extra.cann.libdevice.sqrt_rz(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回 x 的平方根值。

返回类型：float32

支持编译模式：SIMT

147. triton.language.extra.cann.libdevice.sub_rd

OP概述

向下舍入浮点数减法。

原型:

triton.language.extra.cann.libdevice.sub_rd(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回向下舍入的减法结果。

返回类型：float32

支持编译模式：SIMT

148. triton.language.extra.cann.libdevice.sub_rn

OP概述

最近偶数舍入浮点数减法。

原型:

triton.language.extra.cann.libdevice.sub_rn(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回最近偶数舍入的减法结果。

返回类型：float32

支持编译模式：SIMT

149. triton.language.extra.cann.libdevice.sub_ru

OP概述

向上舍入浮点数减法。

原型:

triton.language.extra.cann.libdevice.sub_ru(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回向上舍入的减法结果。

返回类型：float32

支持编译模式：SIMT

150. triton.language.extra.cann.libdevice.sub_rz

OP概述

向零舍入浮点数减法。

原型:

triton.language.extra.cann.libdevice.sub_rz(x, y, _builder=None)

输入类型：

x: float32
y: float32

返回值: tl.tensor, 返回向零舍入的减法结果。

返回类型：float32

支持编译模式：SIMT

151. triton.language.extra.cann.libdevice.tan

OP概述

计算输入参数 x （弧度）的正切值。

原型:

triton.language.extra.cann.libdevice.tan(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入 x 的正切值。

返回类型：float32

支持编译模式：SIMT, SIMD

152. triton.language.extra.cann.libdevice.tanh

OP概述

计算输入参数 x 的双曲正切值。

原型:

triton.language.extra.cann.libdevice.tanh(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入 x 的双曲正切值。

返回类型：float32

支持编译模式：SIMT, SIMD

153. triton.language.extra.cann.libdevice.tgamma

OP概述

计算输入参数的伽马函数值。

原型:

triton.language.extra.cann.libdevice.tgamma(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的伽马函数值。

返回类型：float32

支持编译模式：SIMT

154. triton.language.extra.cann.libdevice.trunc

OP概述

截断取整，向零舍入到最近邻整数。

原型:

triton.language.extra.cann.libdevice.trunc(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回取整结果。

返回类型：float32

支持编译模式：SIMT, SIMD

155. triton.language.extra.cann.libdevice.uint2float_rd

OP概述

向下舍入模式将32位无符号整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.uint2float_rd(x, _builder=None)

输入类型：

x: uint32

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

156. triton.language.extra.cann.libdevice.uint2float_rn

OP概述

最近偶数舍入模式将32位无符号整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.uint2float_rn(x, _builder=None)

输入类型：

x: uint32

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

157. triton.language.extra.cann.libdevice.uint2float_ru

OP概述

向上舍入模式将32位无符号整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.uint2float_ru(x, _builder=None)

输入类型：

x: uint32

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

158. triton.language.extra.cann.libdevice.uint2float_rz

OP概述

向零舍入模式将32位无符号整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.uint2float_rz(x, _builder=None)

输入类型：

x: uint32

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

159. triton.language.extra.cann.libdevice.uint_as_float

OP概述

将32位无符号整数的比特位重新解释为浮点数。不进行数值转换。

原型:

triton.language.extra.cann.libdevice.uint_as_float(x, _builder=None)

输入类型：

x: uint32

返回值: tl.tensor, 返回将32位无符号整数的比特位重新解释为浮点数的结果。

返回类型：float32

支持编译模式：SIMT

160. triton.language.extra.cann.libdevice.ull2float_rd

OP概述

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

原型:

triton.language.extra.cann.libdevice.ull2float_rd(x, _builder=None)

输入类型：

x: uint64

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

161. triton.language.extra.cann.libdevice.ull2float_rn

OP概述

最近偶数舍入模式将64位无符号整数转换为浮点数。

原型:

triton.language.extra.cann.libdevice.ull2float_rn(x, _builder=None)

输入类型：

x: uint64

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

162. triton.language.extra.cann.libdevice.ull2float_ru

OP概述

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

原型:

triton.language.extra.cann.libdevice.ull2float_ru(x, _builder=None)

输入类型：

x: uint64

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

163. triton.language.extra.cann.libdevice.ull2float_rz

OP概述

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

原型:

triton.language.extra.cann.libdevice.ull2float_rz(x, _builder=None)

输入类型：

x: uint64

返回值: tl.tensor, 返回转换后的浮点数。

返回类型：float32

支持编译模式：SIMT

164. triton.language.extra.cann.libdevice.umulhi

OP概述

计算 x 和 y 的无符号乘法结果的高 32 位。

原型:

triton.language.extra.cann.libdevice.umulhi(x, y, _builder=None)

输入类型：

x: int32
y: int32

返回值: tl.tensor, 返回 x 和 y 的无符号乘法结果的高 32 位。

返回类型：int32

支持编译模式：SIMT

165. triton.language.extra.cann.libdevice.y0

OP概述

计算输入参数的零阶第二类贝塞尔函数值。

原型:

triton.language.extra.cann.libdevice.y0(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的零阶第二类贝塞尔函数值。

返回类型：float32

支持编译模式：SIMT

166. triton.language.extra.cann.libdevice.y1

OP概述

计算输入参数的一阶第二类贝塞尔函数值。

原型:

triton.language.extra.cann.libdevice.y1(x, _builder=None)

输入类型：

x: float32

返回值: tl.tensor, 返回输入参数的一阶第二类贝塞尔函数值。

返回类型：float32

支持编译模式：SIMT

167. triton.language.extra.cann.libdevice.yn

OP概述

计算输入参数的 n 阶第二类贝塞尔函数值。

原型:

triton.language.extra.cann.libdevice.yn(n, x, _builder=None)

输入类型：

n: int32
x: float32

返回值: tl.tensor, 返回输入参数的 n 阶第二类贝塞尔函数值。

返回类型：float32

支持编译模式：SIMT