Merged
支持 hifloat4 与 hifloat4_scale 数据类型 #1002
ren-botaoAdd on Oct 10
支持 hifloat4 与 hifloat4_scale 数据类型 #1002
Merged
Merged fromren-botao/opbasesupport_hifloat4_scaleintocann/opbasemaster
Total: 11 files changed+265-106
| @@ -100,8 +100,8 @@ The input pointer cannot be null. | |||
| 100 | 100 | ||
| 101 | | Parameter| Data Type| | 101 | | Parameter| Data Type| |
| 102 | | --- | --- | | 102 | | --- | --- | |
| 103 | -| value | `aclScalar`: DT_BOOL, DT_INT8, DT_UINT8, DT_INT16, DT_UINT16, DT_INT32, DT_UINT32, DT_INT64, DT_UINT64, DT_FLOAT, DT_DOUBLE, DT_FLOAT16, DT_BF16, DT_COMPLEX64, DT_COMPLEX128, DT_FLOAT8_E5M2, DT_FLOAT8_E4M3FN, DT_FLOAT8_E8M0, DT_FLOAT6_E3M2, DT_FLOAT6_E2M3, DT_FLOAT4_E2M1, DT_FLOAT4_E1M2, and DT_HIFLOAT8| | 103 | +| value | `aclScalar`: DT_BOOL, DT_INT8, DT_UINT8, DT_INT16, DT_UINT16, DT_INT32, DT_UINT32, DT_INT64, DT_UINT64, DT_FLOAT, DT_DOUBLE, DT_FLOAT16, DT_BF16, DT_COMPLEX64, DT_COMPLEX128, DT_FLOAT8_E5M2, DT_FLOAT8_E4M3FN, DT_FLOAT8_E8M0, DT_FLOAT6_E3M2, DT_FLOAT6_E2M3, DT_FLOAT4_E2M1, DT_FLOAT4_E1M2, DT_HIFLOAT8, and DT_HIFLOAT4| |
| 104 | -| dataType | DT_BOOL, DT_INT8, DT_UINT8, DT_INT16, DT_UINT16, DT_INT32, DT_UINT32, DT_INT64, DT_UINT64, DT_FLOAT, DT_DOUBLE, DT_FLOAT16, DT_BF16, DT_COMPLEX64, DT_COMPLEX128, DT_FLOAT8_E5M2, DT_FLOAT8_E4M3FN, DT_FLOAT8_E8M0, DT_FLOAT6_E3M2, DT_FLOAT6_E2M3, DT_FLOAT4_E2M1, DT_FLOAT4_E1M2, and DT_HIFLOAT8.| | 104 | +| dataType | DT_BOOL, DT_INT8, DT_UINT8, DT_INT16, DT_UINT16, DT_INT32, DT_UINT32, DT_INT64, DT_UINT64, DT_FLOAT, DT_DOUBLE, DT_FLOAT16, DT_BF16, DT_COMPLEX64, DT_COMPLEX128, DT_FLOAT8_E5M2, DT_FLOAT8_E4M3FN, DT_FLOAT8_E8M0, DT_FLOAT6_E3M2, DT_FLOAT6_E2M3, DT_FLOAT4_E2M1, DT_FLOAT4_E1M2, DT_HIFLOAT8, and DT_HIFLOAT4.| |
| 105 | 105 | ||
| 106 | ## Examples | 106 | ## Examples |
| 107 | 107 | ||
| @@ -11,7 +11,7 @@ Operator %s does not support data type %s. The supported data type range is %s. | |||
| 11 | Error example: | 11 | Error example: |
| 12 | 12 | ||
| 13 | ```text | 13 | ```text |
| 14 | -Operator aclnnAdd_0_AddAiCore does not support data type DT_DUAL(25). The supported data type range is [DT_FLOAT(0), DT_FLOAT16(1), DT_INT8(2), DT_INT32(3), DT_UINT8(4), DT_INT16(6), DT_UINT16(7), DT_UINT32(8), DT_INT64(9), DT_UINT64(10), DT_DOUBLE(11), DT_BOOL(12), DT_COMPLEX64(16), DT_COMPLEX128(17), DT_BF16(27), DT_HIFLOAT8(34), DT_FLOAT8_E5M2(35), DT_FLOAT8_E4M3FN(36), DT_FLOAT8_E8M0(37), DT_FLOAT6_E3M2(38), DT_FLOAT6_E2M3(39), DT_FLOAT4_E2M1(40), DT_FLOAT4_E1M2(41)]. | 14 | +Operator aclnnAdd_0_AddAiCore does not support data type DT_DUAL(25). The supported data type range is [DT_FLOAT(0), DT_FLOAT16(1), DT_INT8(2), DT_INT32(3), DT_UINT8(4), DT_INT16(6), DT_UINT16(7), DT_UINT32(8), DT_INT64(9), DT_UINT64(10), DT_DOUBLE(11), DT_BOOL(12), DT_COMPLEX64(16), DT_COMPLEX128(17), DT_BF16(27), DT_HIFLOAT8(34), DT_FLOAT8_E5M2(35), DT_FLOAT8_E4M3FN(36), DT_FLOAT8_E8M0(37), DT_FLOAT6_E3M2(38), DT_FLOAT6_E2M3(39), DT_FLOAT4_E2M1(40), DT_FLOAT4_E1M2(41), DT_HIFLOAT4(42)]. |
| 15 | ``` | 15 | ``` |
| 16 | 16 | ||
| 17 | ## Solution | 17 | ## Solution |
| @@ -92,8 +92,8 @@ const aclTensor *ConvertToTensor(const T *value, uint64_t size, DataType dataTyp | |||
| 92 | 92 | ||
| 93 | | 参数 | 数据类型约束 | | 93 | | 参数 | 数据类型约束 | |
| 94 | | --- | --- | | 94 | | --- | --- | |
| 95 | -| value | aclScalar类型,支持的数据类型包括:DT_BOOL、DT_INT8、DT_UINT8、DT_INT16、DT_UINT16、DT_INT32、DT_UINT32、DT_INT64、DT_UINT64、DT_FLOAT、DT_DOUBLE、DT_FLOAT16、DT_BF16、DT_COMPLEX64、DT_COMPLEX128、DT_FLOAT8_E5M2、DT_FLOAT8_E4M3FN、DT_FLOAT8_E8M0、DT_FLOAT6_E3M2、DT_FLOAT6_E2M3、DT_FLOAT4_E2M1、DT_FLOAT4_E1M2、DT_HIFLOAT8 | | 95 | +| value | aclScalar类型,支持的数据类型包括:DT_BOOL、DT_INT8、DT_UINT8、DT_INT16、DT_UINT16、DT_INT32、DT_UINT32、DT_INT64、DT_UINT64、DT_FLOAT、DT_DOUBLE、DT_FLOAT16、DT_BF16、DT_COMPLEX64、DT_COMPLEX128、DT_FLOAT8_E5M2、DT_FLOAT8_E4M3FN、DT_FLOAT8_E8M0、DT_FLOAT6_E3M2、DT_FLOAT6_E2M3、DT_FLOAT4_E2M1、DT_FLOAT4_E1M2、DT_HIFLOAT8、DT_HIFLOAT4 | |
| 96 | -| dataType | 支持的数据类型:DT_BOOL、DT_INT8、DT_UINT8、DT_INT16、DT_UINT16、DT_INT32、DT_UINT32、DT_INT64、DT_UINT64、DT_FLOAT、DT_DOUBLE、DT_FLOAT16、DT_BF16、DT_COMPLEX64、DT_COMPLEX128、DT_FLOAT8_E5M2、DT_FLOAT8_E4M3FN、DT_FLOAT8_E8M0、DT_FLOAT6_E3M2、DT_FLOAT6_E2M3、DT_FLOAT4_E2M1、DT_FLOAT4_E1M2、DT_HIFLOAT8 | | 96 | +| dataType | 支持的数据类型:DT_BOOL、DT_INT8、DT_UINT8、DT_INT16、DT_UINT16、DT_INT32、DT_UINT32、DT_INT64、DT_UINT64、DT_FLOAT、DT_DOUBLE、DT_FLOAT16、DT_BF16、DT_COMPLEX64、DT_COMPLEX128、DT_FLOAT8_E5M2、DT_FLOAT8_E4M3FN、DT_FLOAT8_E8M0、DT_FLOAT6_E3M2、DT_FLOAT6_E2M3、DT_FLOAT4_E2M1、DT_FLOAT4_E1M2、DT_HIFLOAT8、DT_HIFLOAT4 | |
| 97 | 97 | ||
| 98 | #### 接口7: `ConvertToTensor(const T *value, uint64_t size, DataType dataType)` | 98 | #### 接口7: `ConvertToTensor(const T *value, uint64_t size, DataType dataType)` |
| 99 | 99 | ||
| @@ -11,7 +11,7 @@ Operator %s does not support data type %s. The supported data type range is %s. | |||
| 11 | 报错示例如下: | 11 | 报错示例如下: |
| 12 | 12 | ||
| 13 | ```text | 13 | ```text |
| 14 | -Operator aclnnAdd_0_AddAiCore does not support data type DT_DUAL(25). The supported data type range is [DT_FLOAT(0), DT_FLOAT16(1), DT_INT8(2), DT_INT32(3), DT_UINT8(4), DT_INT16(6), DT_UINT16(7), DT_UINT32(8), DT_INT64(9), DT_UINT64(10), DT_DOUBLE(11), DT_BOOL(12), DT_COMPLEX64(16), DT_COMPLEX128(17), DT_BF16(27), DT_HIFLOAT8(34), DT_FLOAT8_E5M2(35), DT_FLOAT8_E4M3FN(36), DT_FLOAT8_E8M0(37), DT_FLOAT6_E3M2(38), DT_FLOAT6_E2M3(39), DT_FLOAT4_E2M1(40), DT_FLOAT4_E1M2(41)]. | 14 | +Operator aclnnAdd_0_AddAiCore does not support data type DT_DUAL(25). The supported data type range is [DT_FLOAT(0), DT_FLOAT16(1), DT_INT8(2), DT_INT32(3), DT_UINT8(4), DT_INT16(6), DT_UINT16(7), DT_UINT32(8), DT_INT64(9), DT_UINT64(10), DT_DOUBLE(11), DT_BOOL(12), DT_COMPLEX64(16), DT_COMPLEX128(17), DT_BF16(27), DT_HIFLOAT8(34), DT_FLOAT8_E5M2(35), DT_FLOAT8_E4M3FN(36), DT_FLOAT8_E8M0(37), DT_FLOAT6_E3M2(38), DT_FLOAT6_E2M3(39), DT_FLOAT4_E2M1(40), DT_FLOAT4_E1M2(41), DT_HIFLOAT4(42)]. |
| 15 | ``` | 15 | ``` |
| 16 | 16 | ||
| 17 | ## 解决方法 | 17 | ## 解决方法 |
| @@ -18,10 +18,27 @@ | |||
| 18 | #include <vector> | 18 | #include <vector> |
| 19 | 19 | ||
| 20 | #include "acl/acl_base.h" | 20 | #include "acl/acl_base.h" |
| 21 | -#include "common_types.h" | ||
| 22 | #include "graph/types.h" | 21 | #include "graph/types.h" |
| 23 | 22 | ||
| 23 | +#include "common_types.h" | ||
| 24 | +#include "op_log.h" | ||
| 25 | + | ||
| 24 | namespace op { | 26 | namespace op { |
| 27 | +namespace internal { | ||
| 28 | +/* | ||
| 29 | + * aclDataType定义在runtime仓、ge::DataType定义在metadef仓,两者随版本迭代会新增枚举项。 | ||
| 30 | + * 为使基于旧版本metadef/runtime包(头文件不含新增枚举项,如:ACL_HIFLOAT4_SCALE)也能编译,此处按同名同值补充常量定义。 | ||
| 31 | + * 仅供框架内部使用,外部请勿使用。 | ||
| 32 | + */ | ||
| 33 | +constexpr ::aclDataType ACL_HIFLOAT4 = static_cast<::aclDataType>(42); | ||
| 34 | +constexpr ::aclDataType ACL_HIFLOAT4_SCALE = static_cast<::aclDataType>(43); | ||
| 35 | + | ||
| 36 | +constexpr ::ge::DataType DT_HIFLOAT4 = static_cast<::ge::DataType>(42); | ||
| 37 | +constexpr ::ge::DataType DT_HIFLOAT4_SCALE = static_cast<::ge::DataType>(43); | ||
| 38 | +// 数据类型上界(本文件支持的最大枚举项的后一位),使数组长度与范围校验在高低版本头文件下一致 | ||
| 39 | +constexpr ::ge::DataType DT_MAX = static_cast<::ge::DataType>(44); | ||
| 40 | +} // namespace internal | ||
| 41 | + | ||
| 25 | static constexpr auto u1 = ge::DataType::DT_UINT8; | 42 | static constexpr auto u1 = ge::DataType::DT_UINT8; |
| 26 | static constexpr auto i1 = ge::DataType::DT_INT8; | 43 | static constexpr auto i1 = ge::DataType::DT_INT8; |
| 27 | static constexpr auto i2 = ge::DataType::DT_INT16; | 44 | static constexpr auto i2 = ge::DataType::DT_INT16; |
| @@ -68,77 +85,86 @@ inline bool IsNumberType(const DataType dtype) | |||
| 68 | { | 85 | { |
| 69 | return CheckType( | 86 | return CheckType( |
| 70 | dtype, | 87 | dtype, |
| 71 | - {DataType::DT_COMPLEX128, DataType::DT_COMPLEX64, DataType::DT_DOUBLE, DataType::DT_FLOAT, | 88 | + {DataType::DT_COMPLEX128, DataType::DT_COMPLEX64, DataType::DT_DOUBLE, DataType::DT_FLOAT, |
| 72 | - DataType::DT_FLOAT16, DataType::DT_INT16, DataType::DT_INT32, DataType::DT_INT64, | 89 | + DataType::DT_FLOAT16, DataType::DT_INT16, DataType::DT_INT32, DataType::DT_INT64, |
| 73 | - DataType::DT_INT8, DataType::DT_QINT32, DataType::DT_QINT8, DataType::DT_QUINT8, | 90 | + DataType::DT_INT8, DataType::DT_QINT32, DataType::DT_QINT8, DataType::DT_QUINT8, |
| 74 | - DataType::DT_UINT16, DataType::DT_UINT32, DataType::DT_UINT64, DataType::DT_UINT8, | 91 | + DataType::DT_UINT16, DataType::DT_UINT32, DataType::DT_UINT64, DataType::DT_UINT8, |
| 75 | - DataType::DT_BF16, DataType::DT_HIFLOAT8, DataType::DT_FLOAT8_E5M2, DataType::DT_FLOAT8_E4M3FN, | 92 | + DataType::DT_BF16, DataType::DT_HIFLOAT8, DataType::DT_FLOAT8_E5M2, DataType::DT_FLOAT8_E4M3FN, |
| 76 | - DataType::DT_FLOAT8_E8M0, DataType::DT_FLOAT6_E3M2, DataType::DT_FLOAT6_E2M3, DataType::DT_FLOAT4_E2M1, | 93 | + DataType::DT_FLOAT8_E8M0, DataType::DT_FLOAT6_E3M2, DataType::DT_FLOAT6_E2M3, DataType::DT_FLOAT4_E2M1, |
| 77 | - DataType::DT_FLOAT4_E1M2}); | 94 | + DataType::DT_FLOAT4_E1M2, internal::DT_HIFLOAT4, internal::DT_HIFLOAT4_SCALE}); |
| 78 | } | 95 | } |
| 79 | 96 | ||
| 80 | inline bool IsRealNumberType(const DataType dtype) | 97 | inline bool IsRealNumberType(const DataType dtype) |
| 81 | { | 98 | { |
| 82 | return CheckType( | 99 | return CheckType( |
| 83 | dtype, | 100 | dtype, |
| 84 | - {DataType::DT_DOUBLE, DataType::DT_FLOAT, DataType::DT_FLOAT16, DataType::DT_INT16, | 101 | + {DataType::DT_DOUBLE, DataType::DT_FLOAT, DataType::DT_FLOAT16, DataType::DT_INT16, |
| 85 | - DataType::DT_INT32, DataType::DT_INT64, DataType::DT_INT8, DataType::DT_UINT16, | 102 | + DataType::DT_INT32, DataType::DT_INT64, DataType::DT_INT8, DataType::DT_UINT16, |
| 86 | - DataType::DT_UINT32, DataType::DT_UINT64, DataType::DT_UINT8, DataType::DT_BF16, | 103 | + DataType::DT_UINT32, DataType::DT_UINT64, DataType::DT_UINT8, DataType::DT_BF16, |
| 87 | - DataType::DT_HIFLOAT8, DataType::DT_FLOAT8_E5M2, DataType::DT_FLOAT8_E4M3FN, DataType::DT_FLOAT8_E8M0, | 104 | + DataType::DT_HIFLOAT8, DataType::DT_FLOAT8_E5M2, DataType::DT_FLOAT8_E4M3FN, DataType::DT_FLOAT8_E8M0, |
| 88 | - DataType::DT_FLOAT6_E3M2, DataType::DT_FLOAT6_E2M3, DataType::DT_FLOAT4_E2M1, DataType::DT_FLOAT4_E1M2}); | 105 | + DataType::DT_FLOAT6_E3M2, DataType::DT_FLOAT6_E2M3, DataType::DT_FLOAT4_E2M1, DataType::DT_FLOAT4_E1M2, |
| 106 | + internal::DT_HIFLOAT4, internal::DT_HIFLOAT4_SCALE}); | ||
| 89 | } | 107 | } |
| 90 | 108 | ||
| 109 | +static constexpr int g_dataTypeSize[internal::DT_MAX] = { | ||
| 110 | + 4, // DT_FLOAT = 0, float type | ||
| 111 | + 2, // DT_FLOAT16 = 1, fp16 type | ||
| 112 | + 1, // DT_INT8 = 2, int8 type | ||
| 113 | + 4, // DT_INT32 = 3, | ||
| 114 | + 1, // DT_UINT8 = 4, uint8 type | ||
| 115 | + -1, | ||
| 116 | + 2, // DT_INT16 = 6, int16 type | ||
| 117 | + 2, // DT_UINT16 = 7, uint16 type | ||
| 118 | + 4, // DT_UINT32 = 8, unsigned int32 | ||
| 119 | + 8, // DT_INT64 = 9, int64 type | ||
| 120 | + 8, // DT_UINT64 = 10, unsigned int64 | ||
| 121 | + 8, // DT_DOUBLE = 11, double type | ||
| 122 | + 1, // DT_BOOL = 12, bool type | ||
| 123 | + -1, // DT_STRING = 13, string type | ||
| 124 | + 1, // DT_DUAL_SUB_INT8 = 14, dual output int8 type | ||
| 125 | + 1, // DT_DUAL_SUB_UINT8 = 15, dual output uint8 type | ||
| 126 | + 8, // DT_COMPLEX64 = 16, complex64 type | ||
| 127 | + 16, // DT_COMPLEX128 = 17, complex128 type | ||
| 128 | + 1, // DT_QINT8 = 18, qint8 type | ||
| 129 | + 2, // DT_QINT16 = 19, qint16 type | ||
| 130 | + 4, // DT_QINT32 = 20, qint32 type | ||
| 131 | + 1, // DT_QUINT8 = 21, quint8 type | ||
| 132 | + 2, // DT_QUINT16 = 22, quint16 type | ||
| 133 | + 8, // DT_RESOURCE = 23, resource type | ||
| 134 | + -1, // DT_STRING_REF = 24, string ref type | ||
| 135 | + 5, // DT_DUAL = 25, dual output type (float + int8) | ||
| 136 | + 8, // DT_VARIANT variant type | ||
| 137 | + 2, // DT_BF16 = 27, bf16 type | ||
| 138 | + -1, // DT_UNDEFINED = 28 Used to indicate a DataType field has not been set. | ||
| 139 | + kDataTypeSizeBitOffset + 4, // DT_INT4 = 29, int4 type | ||
| 140 | + kDataTypeSizeBitOffset + 1, // DT_UINT1 = 30, uint1 type | ||
| 141 | + kDataTypeSizeBitOffset + 2, // DT_INT2 = 31, int2 type | ||
| 142 | + kDataTypeSizeBitOffset + 2, // DT_UINT2 = 32, uint2 type | ||
| 143 | + 4, // DT_COMPLEXT = 33, complex32 type | ||
| 144 | + 1, // DT_HIFLOAT8 = 34 hifloat8 type | ||
| 145 | + 1, // DT_FLOAT8_E5M2 = 35 float8_e5m2 type | ||
| 146 | + 1, // DT_FLOAT8_E4M3FN = 36 float8_e4m3fn type | ||
| 147 | + 1, // DT_FLOAT8_E8M0 = 37 float8_e8m0 type | ||
| 148 | + kDataTypeSizeBitOffset + 6, // DT_FLOAT6_E3M2 = 38 float8 e3m2 type | ||
| 149 | + kDataTypeSizeBitOffset + 6, // DT_FLOAT6_E2M3 = 39 float8 e2m3 type | ||
| 150 | + kDataTypeSizeBitOffset + 4, // DT_FLOAT4_E2M1 = 40 float8 e2m1 type | ||
| 151 | + kDataTypeSizeBitOffset + 4, // DT_FLOAT4_E1M2 = 41 float8 e1m2 type | ||
| 152 | + kDataTypeSizeBitOffset + 4, // DT_HIFLOAT4 = 42 hifloat4 type | ||
| 153 | + 4, // DT_HIFLOAT4_SCALE = 43 hifloat4_scale type | ||
| 154 | + // DT_MAX | ||
| 155 | +}; | ||
| 156 | + | ||
| 91 | inline size_t TypeSize(DataType dataType) | 157 | inline size_t TypeSize(DataType dataType) |
| 92 | { | 158 | { |
| 93 | - static int data_type_size[DataType::DT_MAX] = { | 159 | + if (dataType < DataType::DT_FLOAT || dataType >= internal::DT_MAX) { |
| 94 | - 4, // DT_FLOAT = 0, float type | 160 | + OP_LOGW("Data type %d is out of the valid range [DT_FLOAT(%d), DT_MAX(%d)).", static_cast<int32_t>(dataType), |
| 95 | - 2, // DT_FLOAT16 = 1, fp16 type | 161 | + static_cast<int32_t>(DataType::DT_FLOAT), static_cast<int32_t>(internal::DT_MAX)); |
| 96 | - 1, // DT_INT8 = 2, int8 type | ||
| 97 | - 4, // DT_INT32 = 3, | ||
| 98 | - 1, // DT_UINT8 = 4, uint8 type | ||
| 99 | - -1, | ||
| 100 | - 2, // DT_INT16 = 6, int16 type | ||
| 101 | - 2, // DT_UINT16 = 7, uint16 type | ||
| 102 | - 4, // DT_UINT32 = 8, unsigned int32 | ||
| 103 | - 8, // DT_INT64 = 9, int64 type | ||
| 104 | - 8, // DT_UINT64 = 10, unsigned int64 | ||
| 105 | - 8, // DT_DOUBLE = 11, double type | ||
| 106 | - 1, // DT_BOOL = 12, bool type | ||
| 107 | - -1, // DT_STRING = 13, string type | ||
| 108 | - 1, // DT_DUAL_SUB_INT8 = 14, dual output int8 type | ||
| 109 | - 1, // DT_DUAL_SUB_UINT8 = 15, dual output uint8 type | ||
| 110 | - 8, // DT_COMPLEX64 = 16, complex64 type | ||
| 111 | - 16, // DT_COMPLEX128 = 17, complex128 type | ||
| 112 | - 1, // DT_QINT8 = 18, qint8 type | ||
| 113 | - 2, // DT_QINT16 = 19, qint16 type | ||
| 114 | - 4, // DT_QINT32 = 20, qint32 type | ||
| 115 | - 1, // DT_QUINT8 = 21, quint8 type | ||
| 116 | - 2, // DT_QUINT16 = 22, quint16 type | ||
| 117 | - 8, // DT_RESOURCE = 23, resource type | ||
| 118 | - -1, // DT_STRING_REF = 24, string ref type | ||
| 119 | - 5, // DT_DUAL = 25, dual output type (float + int8) | ||
| 120 | - 8, // DT_VARIANT variant type | ||
| 121 | - 2, // DT_BF16 = 27, bf16 type | ||
| 122 | - -1, // DT_UNDEFINED = 28 Used to indicate a DataType field has not been set. | ||
| 123 | - kDataTypeSizeBitOffset + 4, // DT_INT4 = 29, int4 type | ||
| 124 | - kDataTypeSizeBitOffset + 1, // DT_UINT1 = 30, uint1 type | ||
| 125 | - kDataTypeSizeBitOffset + 2, // DT_INT2 = 31, int2 type | ||
| 126 | - kDataTypeSizeBitOffset + 2, // DT_UINT2 = 32, uint2 type | ||
| 127 | - 4, // DT_COMPLEXT = 33, complex32 type | ||
| 128 | - 1, // DT_HIFLOAT8 = 34 hifloat8 type | ||
| 129 | - 1, // DT_FLOAT8_E5M2 = 35 float8_e5m2 type | ||
| 130 | - 1, // DT_FLOAT8_E4M3FN = 36 float8_e4m3fn type | ||
| 131 | - 1, // DT_FLOAT8_E8M0 = 37 float8_e8m0 type | ||
| 132 | - kDataTypeSizeBitOffset + 6, // DT_FLOAT6_E3M2 = 38 float8 e3m2 type | ||
| 133 | - kDataTypeSizeBitOffset + 6, // DT_FLOAT6_E2M3 = 39 float8 e2m3 type | ||
| 134 | - kDataTypeSizeBitOffset + 4, // DT_FLOAT4_E2M1 = 40 float8 e2m1 type | ||
| 135 | - kDataTypeSizeBitOffset + 4, // DT_FLOAT4_E1M2 = 41 float8 e1m2 type | ||
| 136 | - // DT_MAX | ||
| 137 | - }; | ||
| 138 | - if (dataType < DataType::DT_FLOAT || dataType >= DataType::DT_MAX || data_type_size[dataType] <= 0) { | ||
| 139 | return sizeof(complex128); | 162 | return sizeof(complex128); |
| 140 | } | 163 | } |
| 141 | - return static_cast<size_t>(data_type_size[dataType]); | 164 | + if (g_dataTypeSize[dataType] <= 0) { |
| 165 | + return sizeof(complex128); | ||
| 166 | + } | ||
| 167 | + return static_cast<size_t>(g_dataTypeSize[dataType]); | ||
| 142 | } | 168 | } |
| 143 | 169 | ||
| 144 | DataType ToDataType(const std::string& dataTypeStr); | 170 | DataType ToDataType(const std::string& dataTypeStr); |
| @@ -154,13 +180,14 @@ constexpr inline DataType ToOpDataType(aclDataType type) | |||
| 154 | inline aclDataType ToAclDataType(DataType type) | 180 | inline aclDataType ToAclDataType(DataType type) |
| 155 | { | 181 | { |
| 156 | static const std::vector<DataType> CAN_CONVERT_TO_ACL_DataType_LIST = { | 182 | static const std::vector<DataType> CAN_CONVERT_TO_ACL_DataType_LIST = { |
| 157 | - DataType::DT_FLOAT, DataType::DT_FLOAT16, DataType::DT_INT8, DataType::DT_INT32, | 183 | + DataType::DT_FLOAT, DataType::DT_FLOAT16, DataType::DT_INT8, DataType::DT_INT32, |
| 158 | - DataType::DT_UINT8, DataType::DT_INT16, DataType::DT_UINT16, DataType::DT_UINT32, | 184 | + DataType::DT_UINT8, DataType::DT_INT16, DataType::DT_UINT16, DataType::DT_UINT32, |
| 159 | - DataType::DT_INT64, DataType::DT_DOUBLE, DataType::DT_BOOL, DataType::DT_STRING, | 185 | + DataType::DT_INT64, DataType::DT_DOUBLE, DataType::DT_BOOL, DataType::DT_STRING, |
| 160 | - DataType::DT_COMPLEX64, DataType::DT_COMPLEX128, DataType::DT_BF16, DataType::DT_UINT64, | 186 | + DataType::DT_COMPLEX64, DataType::DT_COMPLEX128, DataType::DT_BF16, DataType::DT_UINT64, |
| 161 | - DataType::DT_INT4, DataType::DT_UINT1, DataType::DT_COMPLEX32, DataType::DT_HIFLOAT8, | 187 | + DataType::DT_INT4, DataType::DT_UINT1, DataType::DT_COMPLEX32, DataType::DT_HIFLOAT8, |
| 162 | - DataType::DT_FLOAT8_E5M2, DataType::DT_FLOAT8_E4M3FN, DataType::DT_FLOAT8_E8M0, DataType::DT_FLOAT6_E3M2, | 188 | + DataType::DT_FLOAT8_E5M2, DataType::DT_FLOAT8_E4M3FN, DataType::DT_FLOAT8_E8M0, DataType::DT_FLOAT6_E3M2, |
| 163 | - DataType::DT_FLOAT6_E2M3, DataType::DT_FLOAT4_E2M1, DataType::DT_FLOAT4_E1M2}; | 189 | + DataType::DT_FLOAT6_E2M3, DataType::DT_FLOAT4_E2M1, DataType::DT_FLOAT4_E1M2, internal::DT_HIFLOAT4, |
| 190 | + internal::DT_HIFLOAT4_SCALE}; | ||
| 164 | auto iter = std::find(CAN_CONVERT_TO_ACL_DataType_LIST.begin(), CAN_CONVERT_TO_ACL_DataType_LIST.end(), type); | 191 | auto iter = std::find(CAN_CONVERT_TO_ACL_DataType_LIST.begin(), CAN_CONVERT_TO_ACL_DataType_LIST.end(), type); |
| 165 | if (iter == CAN_CONVERT_TO_ACL_DataType_LIST.end()) { | 192 | if (iter == CAN_CONVERT_TO_ACL_DataType_LIST.end()) { |
| 166 | return aclDataType::ACL_DT_UNDEFINED; | 193 | return aclDataType::ACL_DT_UNDEFINED; |
| @@ -193,7 +220,7 @@ int64_t CalcShapeBytes(int64_t size, DataType dataType, bool ceil = false); | |||
| 193 | 220 | ||
| 194 | // @formatter:off | 221 | // @formatter:off |
| 195 | static constexpr ge::DataType | 222 | static constexpr ge::DataType |
| 196 | - kPromoteTypesLookup[static_cast<int>(ge::DataType::DT_MAX)][static_cast<int>(ge::DataType::DT_MAX)] = { | 223 | + kPromoteTypesLookup[static_cast<int>(internal::DT_MAX)][static_cast<int>(internal::DT_MAX)] = { |
| 197 | /* f4 f2 i1 i4 u1 xx i2 u2 u4 i8 u8 f8 b1 sv d1 D1 c4 c8 q1 q2 q4 Q1 Q2 rs sr | 224 | /* f4 f2 i1 i4 u1 xx i2 u2 u4 i8 u8 f8 b1 sv d1 D1 c4 c8 q1 q2 q4 Q1 Q2 rs sr |
| 198 | du va bf, ud t4 T1 t2 T2 c2*/ | 225 | du va bf, ud t4 T1 t2 T2 c2*/ |
| 199 | /* f4 0 */ {f4, f4, f4, f4, f4, ud, f4, ud, ud, f4, ud, f8, f4, ud, ud, ud, c4, | 226 | /* f4 0 */ {f4, f4, f4, f4, f4, ud, f4, ud, ud, f4, ud, f8, f4, ud, ud, ud, c4, |
| @@ -279,7 +306,8 @@ inline bool IsFloatingType(const ge::DataType type) | |||
| 279 | type == ge::DataType::DT_FLOAT8_E5M2 || type == ge::DataType::DT_FLOAT8_E4M3FN || | 306 | type == ge::DataType::DT_FLOAT8_E5M2 || type == ge::DataType::DT_FLOAT8_E4M3FN || |
| 280 | type == ge::DataType::DT_FLOAT8_E8M0 || type == ge::DataType::DT_FLOAT6_E3M2 || | 307 | type == ge::DataType::DT_FLOAT8_E8M0 || type == ge::DataType::DT_FLOAT6_E3M2 || |
| 281 | type == ge::DataType::DT_FLOAT6_E2M3 || type == ge::DataType::DT_FLOAT4_E2M1 || | 308 | type == ge::DataType::DT_FLOAT6_E2M3 || type == ge::DataType::DT_FLOAT4_E2M1 || |
| 282 | - type == ge::DataType::DT_FLOAT4_E1M2); | 309 | + type == ge::DataType::DT_FLOAT4_E1M2 || type == internal::DT_HIFLOAT4 || |
| 310 | + type == internal::DT_HIFLOAT4_SCALE); | ||
| 283 | } | 311 | } |
| 284 | 312 | ||
| 285 | inline bool IsIntegralType(const ge::DataType type) | 313 | inline bool IsIntegralType(const ge::DataType type) |
| @@ -314,9 +342,11 @@ inline bool CanCast(const ge::DataType from, const ge::DataType to) | |||
| 314 | 342 | ||
| 315 | inline ge::DataType PromoteType(ge::DataType type_a, ge::DataType type_b) | 343 | inline ge::DataType PromoteType(ge::DataType type_a, ge::DataType type_b) |
| 316 | { | 344 | { |
| 317 | - if (static_cast<int>(type_a) < 0 || static_cast<int>(type_b) < 0 || | 345 | + if (type_a < ge::DataType::DT_FLOAT || type_a >= internal::DT_MAX || type_b < ge::DataType::DT_FLOAT || |
| 318 | - static_cast<int>(type_a) >= static_cast<int>(ge::DataType::DT_MAX) || | 346 | + type_b >= internal::DT_MAX) { |
| 319 | - static_cast<int>(type_b) >= static_cast<int>(ge::DataType::DT_MAX)) { | 347 | + OP_LOGW("Data type type_a(%d) or type_b(%d) is out of the valid range [DT_FLOAT(%d), DT_MAX(%d)).", |
| 348 | + static_cast<int32_t>(type_a), static_cast<int32_t>(type_b), | ||
| 349 | + static_cast<int32_t>(ge::DataType::DT_FLOAT), static_cast<int32_t>(internal::DT_MAX)); | ||
| 320 | return ge::DataType::DT_UNDEFINED; | 350 | return ge::DataType::DT_UNDEFINED; |
| 321 | } | 351 | } |
| 322 | 352 | ||
| @@ -19,8 +19,9 @@ get_filename_component(OPS_BASE_PATH "${OPS_BASE_PATH}" ABSOLUTE) | |||
| 19 | 19 | ||
| 20 | add_library(nnopbase_headers INTERFACE) | 20 | add_library(nnopbase_headers INTERFACE) |
| 21 | target_include_directories(nnopbase_headers INTERFACE | 21 | target_include_directories(nnopbase_headers INTERFACE |
| 22 | + ${OPS_BASE_PATH}/include/ | ||
| 22 | ${OPS_BASE_PATH}/include/nnopbase/ | 23 | ${OPS_BASE_PATH}/include/nnopbase/ |
| 23 | - ${OPS_BASE_PATH}/include/nnopbase/opdev | 24 | + ${OPS_BASE_PATH}/include/nnopbase/opdev/ |
| 24 | ) | 25 | ) |
| 25 | 26 | ||
| 26 | # local headers target | 27 | # local headers target |
| @@ -10,9 +10,11 @@ | |||
| 10 | 10 | ||
| 11 | #include <sstream> | 11 | #include <sstream> |
| 12 | #include <cmath> | 12 | #include <cmath> |
| 13 | -#include <securec.h> | ||
| 14 | -#include <graph/utils/type_utils.h> | ||
| 15 | #include <stdexcept> | 13 | #include <stdexcept> |
| 14 | + | ||
| 15 | +#include "securec.h" | ||
| 16 | +#include "graph/utils/type_utils.h" | ||
| 17 | + | ||
| 16 | #include "opdev/data_type_utils.h" | 18 | #include "opdev/data_type_utils.h" |
| 17 | #include "opdev/format_utils.h" | 19 | #include "opdev/format_utils.h" |
| 18 | #include "bridge_graph.h" | 20 | #include "bridge_graph.h" |
| @@ -22,6 +24,7 @@ | |||
| 22 | #include "opdev/op_arg_def.h" | 24 | #include "opdev/op_arg_def.h" |
| 23 | #include "opdev/common_types.h" | 25 | #include "opdev/common_types.h" |
| 24 | #include "nnopbase_error_msg.h" | 26 | #include "nnopbase_error_msg.h" |
| 27 | + | ||
| 25 | using namespace std; | 28 | using namespace std; |
| 26 | 29 | ||
| 27 | aclStorage::aclStorage(void* addr) : addr_(addr) {} | 30 | aclStorage::aclStorage(void* addr) : addr_(addr) {} |
| @@ -367,6 +370,9 @@ aclTensor::aclTensor(const aclScalar* value, op::DataType dataType) | |||
| 367 | case op::DataType::DT_HIFLOAT8: | 370 | case op::DataType::DT_HIFLOAT8: |
| 368 | *static_cast<uint8_t*>(dataAddr) = value->ToHiFloat8().value; | 371 | *static_cast<uint8_t*>(dataAddr) = value->ToHiFloat8().value; |
| 369 | break; | 372 | break; |
| 373 | + case op::internal::DT_HIFLOAT4: | ||
| 374 | + *static_cast<uint8_t*>(dataAddr) = value->ToHiFloat4().value; | ||
| 375 | + break; | ||
| 370 | default: | 376 | default: |
| 371 | OP_CHECK(memset_s(dataAddr, typeSize, 0, typeSize) == EOK, | 377 | OP_CHECK(memset_s(dataAddr, typeSize, 0, typeSize) == EOK, |
| 372 | OP_LOGE_WITHOUT_REPORT(ACLNN_ERR_INNER, "memset_s failed."), return); | 378 | OP_LOGE_WITHOUT_REPORT(ACLNN_ERR_INNER, "memset_s failed."), return); |
| @@ -374,7 +380,8 @@ aclTensor::aclTensor(const aclScalar* value, op::DataType dataType) | |||
| 374 | "DT_INT16(6), DT_UINT16(7), DT_UINT32(8), DT_INT64(9), DT_UINT64(10), " | 380 | "DT_INT16(6), DT_UINT16(7), DT_UINT32(8), DT_INT64(9), DT_UINT64(10), " |
| 375 | "DT_DOUBLE(11), DT_BOOL(12), DT_COMPLEX64(16), DT_COMPLEX128(17), DT_BF16(27), " | 381 | "DT_DOUBLE(11), DT_BOOL(12), DT_COMPLEX64(16), DT_COMPLEX128(17), DT_BF16(27), " |
| 376 | "DT_HIFLOAT8(34), DT_FLOAT8_E5M2(35), DT_FLOAT8_E4M3FN(36), DT_FLOAT8_E8M0(37), " | 382 | "DT_HIFLOAT8(34), DT_FLOAT8_E5M2(35), DT_FLOAT8_E4M3FN(36), DT_FLOAT8_E8M0(37), " |
| 377 | - "DT_FLOAT6_E3M2(38), DT_FLOAT6_E2M3(39), DT_FLOAT4_E2M1(40), DT_FLOAT4_E1M2(41)]"; | 383 | + "DT_FLOAT6_E3M2(38), DT_FLOAT6_E2M3(39), DT_FLOAT4_E2M1(40), DT_FLOAT4_E1M2(41), " |
| 384 | + "DT_HIFLOAT4(42)]"; | ||
| 378 | std::string dataTypeStr = std::string(op::ToString(dataType).GetString()) + "(" + | 385 | std::string dataTypeStr = std::string(op::ToString(dataType).GetString()) + "(" + |
| 379 | std::to_string(static_cast<int32_t>(dataType)) + ")"; | 386 | std::to_string(static_cast<int32_t>(dataType)) + ")"; |
| 380 | OP_LOGE_FOR_NOT_SUPPORTED_DATA_TYPE(dataTypeStr.c_str(), dtypeRange.c_str()); | 387 | OP_LOGE_FOR_NOT_SUPPORTED_DATA_TYPE(dataTypeStr.c_str(), dtypeRange.c_str()); |
| @@ -434,7 +441,7 @@ op::DataType aclTensor::GetDataType() const | |||
| 434 | OP_LOGE(ACLNN_ERR_PARAM_NULLPTR, | 441 | OP_LOGE(ACLNN_ERR_PARAM_NULLPTR, |
| 435 | "the aclTensor(%p)'s tensor_ address is %p. please check the memory usage in your code.", this, | 442 | "the aclTensor(%p)'s tensor_ address is %p. please check the memory usage in your code.", this, |
| 436 | tensor_); | 443 | tensor_); |
| 437 | - return op::DataType::DT_MAX; | 444 | + return op::internal::DT_MAX; |
| 438 | } | 445 | } |
| 439 | } | 446 | } |
| 440 | 447 | ||
| @@ -951,6 +958,15 @@ T aclScalar::To() const | |||
| 951 | } else { | 958 | } else { |
| 952 | return static_cast<T>(v.f); | 959 | return static_cast<T>(v.f); |
| 953 | } | 960 | } |
| 961 | + case op::DataType::DT_DOUBLE: | ||
| 962 | + if constexpr (std::is_same<bool, typename std::decay<T>::type>::value) { | ||
| 963 | + if (std::isnan(v.d)) { | ||
| 964 | + return static_cast<bool>(v.d); | ||
| 965 | + } | ||
| 966 | + return std::abs(v.d) >= std::numeric_limits<double>::epsilon(); | ||
| 967 | + } else { | ||
| 968 | + return static_cast<T>(v.d); | ||
| 969 | + } | ||
| 954 | case op::DataType::DT_FLOAT16: | 970 | case op::DataType::DT_FLOAT16: |
| 955 | if constexpr (std::is_same<bool, typename std::decay<T>::type>::value) { | 971 | if constexpr (std::is_same<bool, typename std::decay<T>::type>::value) { |
| 956 | if (FP16_IS_NAN(v.ui16)) { | 972 | if (FP16_IS_NAN(v.ui16)) { |
| @@ -985,6 +1001,8 @@ T aclScalar::To() const | |||
| 985 | return ConvertCustomFloatTo<T, op::Float4E1M2>(v.ui8); | 1001 | return ConvertCustomFloatTo<T, op::Float4E1M2>(v.ui8); |
| 986 | case op::DataType::DT_HIFLOAT8: | 1002 | case op::DataType::DT_HIFLOAT8: |
| 987 | return ConvertCustomFloatTo<T, op::HiFloat8>(v.ui8); | 1003 | return ConvertCustomFloatTo<T, op::HiFloat8>(v.ui8); |
| 1004 | + case op::internal::DT_HIFLOAT4: | ||
| 1005 | + return ConvertCustomFloatTo<T, op::HiFloat4>(v.ui8); | ||
| 988 | case op::DataType::DT_INT8: | 1006 | case op::DataType::DT_INT8: |
| 989 | return static_cast<T>(v.i8); | 1007 | return static_cast<T>(v.i8); |
| 990 | case op::DataType::DT_INT16: | 1008 | case op::DataType::DT_INT16: |
| @@ -1009,15 +1027,6 @@ T aclScalar::To() const | |||
| 1009 | return static_cast<T>(v.ui64); | 1027 | return static_cast<T>(v.ui64); |
| 1010 | case op::DataType::DT_BOOL: | 1028 | case op::DataType::DT_BOOL: |
| 1011 | return static_cast<T>(v.i8); | 1029 | return static_cast<T>(v.i8); |
| 1012 | - case op::DataType::DT_DOUBLE: | ||
| 1013 | - if constexpr (std::is_same<bool, typename std::decay<T>::type>::value) { | ||
| 1014 | - if (std::isnan(v.d)) { | ||
| 1015 | - return static_cast<bool>(v.d); | ||
| 1016 | - } | ||
| 1017 | - return std::abs(v.d) >= std::numeric_limits<double>::epsilon(); | ||
| 1018 | - } else { | ||
| 1019 | - return static_cast<T>(v.d); | ||
| 1020 | - } | ||
| 1021 | case op::DataType::DT_COMPLEX64: | 1030 | case op::DataType::DT_COMPLEX64: |
| 1022 | if constexpr (std::is_same<std::complex<float>, typename std::decay<T>::type>::value) { | 1031 | if constexpr (std::is_same<std::complex<float>, typename std::decay<T>::type>::value) { |
| 1023 | return v.complex64; | 1032 | return v.complex64; |
| @@ -1073,6 +1082,9 @@ ge::AscendString aclScalar::ToStr() const | |||
| 1073 | case op::DataType::DT_HIFLOAT8: | 1082 | case op::DataType::DT_HIFLOAT8: |
| 1074 | return ge::AscendString( | 1083 | return ge::AscendString( |
| 1075 | std::to_string(static_cast<float>(op::HiFloat8(v.ui8, op::HiFloat8::FromBits()))).c_str()); | 1084 | std::to_string(static_cast<float>(op::HiFloat8(v.ui8, op::HiFloat8::FromBits()))).c_str()); |
| 1085 | + case op::internal::DT_HIFLOAT4: | ||
| 1086 | + return ge::AscendString( | ||
| 1087 | + std::to_string(static_cast<float>(op::HiFloat4(v.ui8, op::HiFloat4::FromBits()))).c_str()); | ||
| 1076 | case op::DataType::DT_INT8: | 1088 | case op::DataType::DT_INT8: |
| 1077 | return ge::AscendString(std::to_string(v.i8).c_str()); | 1089 | return ge::AscendString(std::to_string(v.i8).c_str()); |
| 1078 | case op::DataType::DT_INT16: | 1090 | case op::DataType::DT_INT16: |
| @@ -1235,12 +1247,16 @@ aclScalar::aclScalar(const void* data, op::DataType dataType) | |||
| 1235 | case op::DataType::DT_HIFLOAT8: | 1247 | case op::DataType::DT_HIFLOAT8: |
| 1236 | v.ui8 = *static_cast<const uint8_t*>(data); | 1248 | v.ui8 = *static_cast<const uint8_t*>(data); |
| 1237 | break; | 1249 | break; |
| 1250 | + case op::internal::DT_HIFLOAT4: | ||
| 1251 | + v.ui8 = *static_cast<const uint8_t*>(data); | ||
| 1252 | + break; | ||
| 1238 | default: | 1253 | default: |
| 1239 | std::string dtypeRange = "[DT_FLOAT(0), DT_FLOAT16(1), DT_INT8(2), DT_INT32(3), DT_UINT8(4), " | 1254 | std::string dtypeRange = "[DT_FLOAT(0), DT_FLOAT16(1), DT_INT8(2), DT_INT32(3), DT_UINT8(4), " |
| 1240 | "DT_INT16(6), DT_UINT16(7), DT_UINT32(8), DT_INT64(9), DT_UINT64(10), " | 1255 | "DT_INT16(6), DT_UINT16(7), DT_UINT32(8), DT_INT64(9), DT_UINT64(10), " |
| 1241 | "DT_DOUBLE(11), DT_BOOL(12), DT_COMPLEX64(16), DT_COMPLEX128(17), DT_BF16(27), " | 1256 | "DT_DOUBLE(11), DT_BOOL(12), DT_COMPLEX64(16), DT_COMPLEX128(17), DT_BF16(27), " |
| 1242 | "DT_HIFLOAT8(34), DT_FLOAT8_E5M2(35), DT_FLOAT8_E4M3FN(36), DT_FLOAT8_E8M0(37), " | 1257 | "DT_HIFLOAT8(34), DT_FLOAT8_E5M2(35), DT_FLOAT8_E4M3FN(36), DT_FLOAT8_E8M0(37), " |
| 1243 | - "DT_FLOAT6_E3M2(38), DT_FLOAT6_E2M3(39), DT_FLOAT4_E2M1(40), DT_FLOAT4_E1M2(41)]"; | 1258 | + "DT_FLOAT6_E3M2(38), DT_FLOAT6_E2M3(39), DT_FLOAT4_E2M1(40), DT_FLOAT4_E1M2(41), " |
| 1259 | + "DT_HIFLOAT4(42)]"; | ||
| 1244 | std::string dataTypeStr = std::string(op::ToString(dataType_).GetString()) + "(" + | 1260 | std::string dataTypeStr = std::string(op::ToString(dataType_).GetString()) + "(" + |
| 1245 | std::to_string(static_cast<int32_t>(dataType_)) + ")"; | 1261 | std::to_string(static_cast<int32_t>(dataType_)) + ")"; |
| 1246 | OP_LOGE_FOR_NOT_SUPPORTED_DATA_TYPE(dataTypeStr.c_str(), dtypeRange.c_str()); | 1262 | OP_LOGE_FOR_NOT_SUPPORTED_DATA_TYPE(dataTypeStr.c_str(), dtypeRange.c_str()); |
| @@ -1331,11 +1347,7 @@ aclScalar::aclScalar(op::Float4E2M1 value) : dataType_(op::DataType::DT_FLOAT4_E | |||
| 1331 | 1347 | ||
| 1332 | aclScalar::aclScalar(op::Float4E1M2 value) : dataType_(op::DataType::DT_FLOAT4_E1M2) { v.ui8 = value.value; } | 1348 | aclScalar::aclScalar(op::Float4E1M2 value) : dataType_(op::DataType::DT_FLOAT4_E1M2) { v.ui8 = value.value; } |
| 1333 | 1349 | ||
| 1334 | -aclScalar::aclScalar(op::HiFloat4 value) : dataType_(op::DataType::DT_FLOAT4_E1M2) | 1350 | +aclScalar::aclScalar(op::HiFloat4 value) : dataType_(op::internal::DT_HIFLOAT4) { v.ui8 = value.value; } |
| 1335 | -{ | ||
| 1336 | - v.ui8 = value.value; | ||
| 1337 | - OP_LOGW("This is a reserved function for future, aclScalar of hifloat4 type cannot be created currently."); | ||
| 1338 | -} | ||
| 1339 | 1351 | ||
| 1340 | aclScalar::aclScalar(op::HiFloat8 value) : dataType_(op::DataType::DT_HIFLOAT8) { v.ui8 = value.value; } | 1352 | aclScalar::aclScalar(op::HiFloat8 value) : dataType_(op::DataType::DT_HIFLOAT8) { v.ui8 = value.value; } |
| 1341 | 1353 | ||
| @@ -1384,7 +1396,9 @@ ge::AscendString ToString(aclDataType dataType) | |||
| 1384 | {ACL_FLOAT6_E3M2, "float6_e3m2"}, | 1396 | {ACL_FLOAT6_E3M2, "float6_e3m2"}, |
| 1385 | {ACL_FLOAT6_E2M3, "float6_e2m3"}, | 1397 | {ACL_FLOAT6_E2M3, "float6_e2m3"}, |
| 1386 | {ACL_FLOAT4_E2M1, "float4_e2m1"}, | 1398 | {ACL_FLOAT4_E2M1, "float4_e2m1"}, |
| 1387 | - {ACL_FLOAT4_E1M2, "float4_e1m2"}}; | 1399 | + {ACL_FLOAT4_E1M2, "float4_e1m2"}, |
| 1400 | + {op::internal::ACL_HIFLOAT4, "hifloat4"}, | ||
| 1401 | + {op::internal::ACL_HIFLOAT4_SCALE, "hifloat4_scale"}}; | ||
| 1388 | auto iter = dtype.find(dataType); | 1402 | auto iter = dtype.find(dataType); |
| 1389 | if (iter != dtype.end()) { | 1403 | if (iter != dtype.end()) { |
| 1390 | return ge::AscendString((iter->second).c_str()); | 1404 | return ge::AscendString((iter->second).c_str()); |
| @@ -8,9 +8,10 @@ | |||
| 8 | * See LICENSE in the root of the software repository for the full text of the License. | 8 | * See LICENSE in the root of the software repository for the full text of the License. |
| 9 | */ | 9 | */ |
| 10 | 10 | ||
| 11 | -#include <map> | ||
| 12 | #include <string> | 11 | #include <string> |
| 13 | -#include <graph/utils/type_utils.h> | 12 | + |
| 13 | +#include "graph/utils/type_utils.h" | ||
| 14 | + | ||
| 14 | #include "opdev/common_types.h" | 15 | #include "opdev/common_types.h" |
| 15 | #include "opdev/data_type_utils.h" | 16 | #include "opdev/data_type_utils.h" |
| 16 | 17 | ||
| @@ -19,7 +20,6 @@ namespace op { | |||
| 19 | constexpr int64_t BIT_TO_BYTE_SHIFT = 3; | 20 | constexpr int64_t BIT_TO_BYTE_SHIFT = 3; |
| 20 | constexpr int64_t BIT_TO_BTYE_ALIGN = 7; | 21 | constexpr int64_t BIT_TO_BTYE_ALIGN = 7; |
| 21 | 22 | ||
| 22 | -using std::map; | ||
| 23 | using std::string; | 23 | using std::string; |
| 24 | 24 | ||
| 25 | DataType ToDataType(const string& dataTypeStr) { return ge::TypeUtils::SerialStringToDataType(dataTypeStr); } | 25 | DataType ToDataType(const string& dataTypeStr) { return ge::TypeUtils::SerialStringToDataType(dataTypeStr); } |
| @@ -124,7 +124,9 @@ const std::map<std::string, ge::DataType> STR_2_DATA_TYPE{{"float", ge::DT_FLOAT | |||
| 124 | {"float6_e3m2", DataType::DT_FLOAT6_E3M2}, | 124 | {"float6_e3m2", DataType::DT_FLOAT6_E3M2}, |
| 125 | {"float6_e2m3", DataType::DT_FLOAT6_E2M3}, | 125 | {"float6_e2m3", DataType::DT_FLOAT6_E2M3}, |
| 126 | {"float4_e2m1", DataType::DT_FLOAT4_E2M1}, | 126 | {"float4_e2m1", DataType::DT_FLOAT4_E2M1}, |
| 127 | - {"float4_e1m2", DataType::DT_FLOAT4_E1M2}}; | 127 | + {"float4_e1m2", DataType::DT_FLOAT4_E1M2}, |
| 128 | + {"hifloat4", op::internal::DT_HIFLOAT4}, | ||
| 129 | + {"hifloat4_scale", op::internal::DT_HIFLOAT4_SCALE}}; | ||
| 128 | 130 | ||
| 129 | const std::map<ge::DataType, std::string> DATA_TYPE_2_STR{{ge::DT_FLOAT, "float"}, | 131 | const std::map<ge::DataType, std::string> DATA_TYPE_2_STR{{ge::DT_FLOAT, "float"}, |
| 130 | {ge::DT_FLOAT, "float32"}, | 132 | {ge::DT_FLOAT, "float32"}, |
| @@ -155,7 +157,9 @@ const std::map<ge::DataType, std::string> DATA_TYPE_2_STR{{ge::DT_FLOAT, "float" | |||
| 155 | {DataType::DT_FLOAT6_E3M2, "float6_e3m2"}, | 157 | {DataType::DT_FLOAT6_E3M2, "float6_e3m2"}, |
| 156 | {DataType::DT_FLOAT6_E2M3, "float6_e2m3"}, | 158 | {DataType::DT_FLOAT6_E2M3, "float6_e2m3"}, |
| 157 | {DataType::DT_FLOAT4_E2M1, "float4_e2m1"}, | 159 | {DataType::DT_FLOAT4_E2M1, "float4_e2m1"}, |
| 158 | - {DataType::DT_FLOAT4_E1M2, "float4_e1m2"}}; | 160 | + {DataType::DT_FLOAT4_E1M2, "float4_e1m2"}, |
| 161 | + {op::internal::DT_HIFLOAT4, "hifloat4"}, | ||
| 162 | + {op::internal::DT_HIFLOAT4_SCALE, "hifloat4_scale"}}; | ||
| 159 | 163 | ||
| 160 | const std::map<std::string, ge::Format> STR_2_FORMAT{{"ND", ge::FORMAT_ND}, | 164 | const std::map<std::string, ge::Format> STR_2_FORMAT{{"ND", ge::FORMAT_ND}, |
| 161 | {"ALL", ge::FORMAT_ND}, | 165 | {"ALL", ge::FORMAT_ND}, |
| @@ -1009,7 +1013,7 @@ aclnnStatus OpKernel::GenerateKeyByJson(const nlohmann::json& singleBinJson, con | |||
| 1009 | void OpKernel::GetReadableFmtDtypeKey(wchar_t ele, int32_t& cnt, string& debug_str) const | 1013 | void OpKernel::GetReadableFmtDtypeKey(wchar_t ele, int32_t& cnt, string& debug_str) const |
| 1010 | { | 1014 | { |
| 1011 | if (cnt % MAX_BIN_MATCH_ARG_KEY_COUNT == 0) { | 1015 | if (cnt % MAX_BIN_MATCH_ARG_KEY_COUNT == 0) { |
| 1012 | - if (ele <= ge::DT_MAX) { | 1016 | + if (ele < op::internal::DT_MAX) { |
| 1013 | auto iter = DATA_TYPE_2_STR.find(static_cast<ge::DataType>(ele)); | 1017 | auto iter = DATA_TYPE_2_STR.find(static_cast<ge::DataType>(ele)); |
| 1014 | if (iter != DATA_TYPE_2_STR.end()) { | 1018 | if (iter != DATA_TYPE_2_STR.end()) { |
| 1015 | debug_str += (iter->second); | 1019 | debug_str += (iter->second); |
| @@ -205,6 +205,14 @@ TEST_F(CommonTypesTest, TestAclScalar_ConvertCustomFloatTo) | |||
| 205 | CHECK_CUSTOM_FLOAT_SCALAR_TO(op::Float4E1M2, 0.0f); | 205 | CHECK_CUSTOM_FLOAT_SCALAR_TO(op::Float4E1M2, 0.0f); |
| 206 | CHECK_CUSTOM_FLOAT_SCALAR_TO(op::Float4E1M2, -1.0f); | 206 | CHECK_CUSTOM_FLOAT_SCALAR_TO(op::Float4E1M2, -1.0f); |
| 207 | 207 | ||
| 208 | + // --- HiFloat4 (Huawei 4bit float, 1S1E2M, bias=1, 最大值 1.75) --- | ||
| 209 | + // 该类型同时校验 aclScalar 的 dtype 归属:aclScalar(op::HiFloat4) 应携带 DT_HIFLOAT4, | ||
| 210 | + // 否则 Branch 1 的一致性断言会因按其它 4bit 格式解析而失败 | ||
| 211 | + CHECK_CUSTOM_FLOAT_SCALAR_TO(op::HiFloat4, 1.0f); | ||
| 212 | + CHECK_CUSTOM_FLOAT_SCALAR_TO(op::HiFloat4, 0.0f); | ||
| 213 | + CHECK_CUSTOM_FLOAT_SCALAR_TO(op::HiFloat4, -1.0f); | ||
| 214 | + CHECK_CUSTOM_FLOAT_SCALAR_TO(op::HiFloat4, 1.25f); | ||
| 215 | + | ||
| 208 | // --- HiFloat8 (Huawei tapered precision format) --- | 216 | // --- HiFloat8 (Huawei tapered precision format) --- |
| 209 | CHECK_CUSTOM_FLOAT_SCALAR_TO(op::HiFloat8, 1.0f); | 217 | CHECK_CUSTOM_FLOAT_SCALAR_TO(op::HiFloat8, 1.0f); |
| 210 | CHECK_CUSTOM_FLOAT_SCALAR_TO(op::HiFloat8, 0.0f); | 218 | CHECK_CUSTOM_FLOAT_SCALAR_TO(op::HiFloat8, 0.0f); |
| @@ -213,6 +221,40 @@ TEST_F(CommonTypesTest, TestAclScalar_ConvertCustomFloatTo) | |||
| 213 | #undef CHECK_CUSTOM_FLOAT_SCALAR_TO | 221 | #undef CHECK_CUSTOM_FLOAT_SCALAR_TO |
| 214 | } | 222 | } |
| 215 | 223 | ||
| 224 | +// 按 HiFloat4 位模式(1 符号位 + 1 指数位 + 2 尾数位,bias=1)验证取值转换: | ||
| 225 | +// 次正规:值 = man / 4(0x1=0.25, 0x2=0.5, 0x3=0.75) | ||
| 226 | +// 正规: 值 = 2^(E-1) × (1 + man / 4)(0x4=1.0, 0x5=1.25, 0x6=1.5, 0x7=1.75) | ||
| 227 | +// 符号位为 1 时取负(0x8=-0.0, 0x9=-0.25, 0xF=-1.75) | ||
| 228 | +TEST_F(CommonTypesTest, TestAclScalar_HiFloat4BitPatterns) | ||
| 229 | +{ | ||
| 230 | + struct HiFloat4Case { | ||
| 231 | + uint8_t bits; | ||
| 232 | + float expected; | ||
| 233 | + }; | ||
| 234 | + const std::vector<HiFloat4Case> cases = {{0x0, 0.0f}, {0x1, 0.25f}, {0x2, 0.5f}, {0x3, 0.75f}, | ||
| 235 | + {0x4, 1.0f}, {0x5, 1.25f}, {0x6, 1.5f}, {0x7, 1.75f}, | ||
| 236 | + {0x8, -0.0f}, {0x9, -0.25f}, {0xF, -1.75f}}; | ||
| 237 | + for (const auto& testCase : cases) { | ||
| 238 | + uint8_t bits = testCase.bits; | ||
| 239 | + aclScalar scalar(&bits, op::internal::DT_HIFLOAT4); | ||
| 240 | + EXPECT_EQ(op::internal::DT_HIFLOAT4, scalar.GetDataType()); | ||
| 241 | + EXPECT_FLOAT_EQ(testCase.expected, scalar.ToFloat()); | ||
| 242 | + EXPECT_EQ(testCase.bits, scalar.To<op::HiFloat4>().value); | ||
| 243 | + EXPECT_EQ(testCase.bits, scalar.ToHiFloat4().value); | ||
| 244 | + } | ||
| 245 | + | ||
| 246 | + // 由 op::HiFloat4 值构造的 aclScalar 直接携带 DT_HIFLOAT4 类型 | ||
| 247 | + aclScalar hiFloat4Scalar(op::HiFloat4(1.25f)); | ||
| 248 | + EXPECT_EQ(op::internal::DT_HIFLOAT4, hiFloat4Scalar.GetDataType()); | ||
| 249 | + EXPECT_EQ(0x5, hiFloat4Scalar.ToHiFloat4().value); | ||
| 250 | + EXPECT_FLOAT_EQ(1.25f, hiFloat4Scalar.ToFloat()); | ||
| 251 | + | ||
| 252 | + // HiFloat4 仅 4bit 有效,高于 4bit 的位在构造时被掩掉 | ||
| 253 | + aclScalar maskedScalar(op::HiFloat4(static_cast<uint8_t>(0xF5), op::HiFloat4::FromBits())); | ||
| 254 | + EXPECT_EQ(op::internal::DT_HIFLOAT4, maskedScalar.GetDataType()); | ||
| 255 | + EXPECT_EQ(0x5, maskedScalar.ToHiFloat4().value); | ||
| 256 | +} | ||
| 257 | + | ||
| 216 | // 使用 OCP 规范定义的 bit pattern 验证 ConvertCustomFloatTo 的正确性 | 258 | // 使用 OCP 规范定义的 bit pattern 验证 ConvertCustomFloatTo 的正确性 |
| 217 | TEST_F(CommonTypesTest, TestAclScalar_ConvertCustomFloatTo_OcpBitPatterns) | 259 | TEST_F(CommonTypesTest, TestAclScalar_ConvertCustomFloatTo_OcpBitPatterns) |
| 218 | { | 260 | { |
| @@ -963,6 +1005,9 @@ TEST_F(CommonTypesTest, TestAclScalarToAclTensor) | |||
| 963 | using complex128 = std::complex<double>; | 1005 | using complex128 = std::complex<double>; |
| 964 | CHECK_SCALAR2TENSOR(complex64Scalar, complex64(3.2, 3.2), complex64, DataType::DT_COMPLEX64); | 1006 | CHECK_SCALAR2TENSOR(complex64Scalar, complex64(3.2, 3.2), complex64, DataType::DT_COMPLEX64); |
| 965 | CHECK_SCALAR2TENSOR(complex128Scalar, complex128(3.2, 3.2), complex128, DataType::DT_COMPLEX128); | 1007 | CHECK_SCALAR2TENSOR(complex128Scalar, complex128(3.2, 3.2), complex128, DataType::DT_COMPLEX128); |
| 1008 | + // HiFloat4 的 sizeof 为 1 字节,tensor 中写入的即为该 4bit 值(1.25f → 0x5) | ||
| 1009 | + using hifp4 = op::HiFloat4; | ||
| 1010 | + CHECK_SCALAR2TENSOR(hiFp4Scalar, hifp4(1.25f), hifp4, op::internal::DT_HIFLOAT4); | ||
| 966 | fp16_t fp16Value = 3.2; | 1011 | fp16_t fp16Value = 3.2; |
| 967 | try { | 1012 | try { |
| 968 | // unsupport dtype | 1013 | // unsupport dtype |
| @@ -971,6 +1016,10 @@ TEST_F(CommonTypesTest, TestAclScalarToAclTensor) | |||
| 971 | EXPECT_NE(memcmp(unsupportedDataTypeScalarTensor.GetData(), &fp16Value, sizeof(fp16Value)), 0); | 1016 | EXPECT_NE(memcmp(unsupportedDataTypeScalarTensor.GetData(), &fp16Value, sizeof(fp16Value)), 0); |
| 972 | } catch (...) { | 1017 | } catch (...) { |
| 973 | } | 1018 | } |
| 1019 | + | ||
| 1020 | + // hifloat4_scale 当前不支持构造 aclScalar,因此 ConvertToTensor 也不支持该类型 | ||
| 1021 | + uint8_t hifloat4ScaleBits = 0x5; | ||
| 1022 | + EXPECT_THROW(new aclScalar(&hifloat4ScaleBits, op::internal::DT_HIFLOAT4_SCALE), std::invalid_argument); | ||
| 974 | } | 1023 | } |
| 975 | 1024 | ||
| 976 | TEST_F(CommonTypesTest, TestAclIntArrayToAclTensor) | 1025 | TEST_F(CommonTypesTest, TestAclIntArrayToAclTensor) |
| @@ -313,7 +313,7 @@ TEST_F(TestDataTypeUtils, ToStringContainerOverloads) | |||
| 313 | 313 | ||
| 314 | TEST_F(TestDataTypeUtils, TypeSize) | 314 | TEST_F(TestDataTypeUtils, TypeSize) |
| 315 | { | 315 | { |
| 316 | - EXPECT_EQ(op::TypeSize(op::DataType::DT_MAX), sizeof(op::complex128)); | 316 | + EXPECT_EQ(op::TypeSize(op::internal::DT_MAX), sizeof(op::complex128)); |
| 317 | EXPECT_EQ(op::TypeSize(op::DataType::DT_UNDEFINED), sizeof(op::complex128)); | 317 | EXPECT_EQ(op::TypeSize(op::DataType::DT_UNDEFINED), sizeof(op::complex128)); |
| 318 | } | 318 | } |
| 319 | 319 | ||
| @@ -336,3 +336,64 @@ TEST_F(TestDataTypeUtils, ShapeBtyes) | |||
| 336 | int4Btyes = op::CalcShapeBytes(shape, op::DataType::DT_INT4); | 336 | int4Btyes = op::CalcShapeBytes(shape, op::DataType::DT_INT4); |
| 337 | EXPECT_EQ(int4Btyes, 0); | 337 | EXPECT_EQ(int4Btyes, 0); |
| 338 | } | 338 | } |
| 339 | + | ||
| 340 | +TEST_F(TestDataTypeUtils, AdditionalDataTypeConstants) | ||
| 341 | +{ | ||
| 342 | + // 补充常量的取值与 ge 的枚举一致,高低版本头文件下都由本仓常量提供 | ||
| 343 | + EXPECT_EQ(static_cast<int32_t>(op::internal::DT_HIFLOAT4), 42); | ||
| 344 | + EXPECT_EQ(static_cast<int32_t>(op::internal::DT_HIFLOAT4_SCALE), 43); | ||
| 345 | + EXPECT_EQ(static_cast<int32_t>(op::internal::DT_MAX), 44); | ||
| 346 | + EXPECT_EQ(static_cast<int32_t>(op::internal::ACL_HIFLOAT4), 42); | ||
| 347 | + EXPECT_EQ(static_cast<int32_t>(op::internal::ACL_HIFLOAT4_SCALE), 43); | ||
| 348 | + EXPECT_EQ(op::ToString(op::internal::DT_HIFLOAT4), "DT_HIFLOAT4"); | ||
| 349 | + EXPECT_EQ(op::ToString(op::internal::DT_HIFLOAT4_SCALE), "DT_HIFLOAT4_SCALE"); | ||
| 350 | + // internal::DT_MAX 不是真实类型,取不到名称 | ||
| 351 | + EXPECT_EQ(op::ToString(op::internal::DT_MAX), "UNDEFINED"); | ||
| 352 | + EXPECT_GT(static_cast<int32_t>(op::internal::DT_MAX), static_cast<int32_t>(op::internal::DT_HIFLOAT4_SCALE)); | ||
| 353 | + EXPECT_FALSE(op::IsNumberType(op::internal::DT_MAX)); | ||
| 354 | + EXPECT_FALSE(op::IsFloatingType(op::internal::DT_MAX)); | ||
| 355 | +} | ||
| 356 | + | ||
| 357 | +// internal::DT_MAX 是我们类型域的上界(不属于任何真实类型):涉及下标访问的接口必须拦住它,避免越界 | ||
| 358 | +TEST_F(TestDataTypeUtils, DataTypeTableBoundIsOutOfRange) | ||
| 359 | +{ | ||
| 360 | + EXPECT_EQ(op::TypeSize(op::internal::DT_MAX), sizeof(op::complex128)); | ||
| 361 | + EXPECT_EQ(op::PromoteType(op::internal::DT_MAX, op::internal::DT_HIFLOAT4_SCALE), op::DataType::DT_UNDEFINED); | ||
| 362 | + EXPECT_EQ(op::PromoteType(op::internal::DT_HIFLOAT4, op::internal::DT_MAX), op::DataType::DT_UNDEFINED); | ||
| 363 | +} | ||
| 364 | + | ||
| 365 | +TEST_F(TestDataTypeUtils, Hifloat4TypeSize) | ||
| 366 | +{ | ||
| 367 | + // hifloat4 为 4bit,TypeSize 以 kDataTypeSizeBitOffset 编码位宽;hifloat4_scale 每元素 4 字节 | ||
| 368 | + EXPECT_EQ(op::TypeSize(op::internal::DT_HIFLOAT4), op::kDataTypeSizeBitOffset + 4); | ||
| 369 | + EXPECT_EQ(op::TypeSize(op::internal::DT_HIFLOAT4_SCALE), 4); | ||
| 370 | +} | ||
| 371 | + | ||
| 372 | +TEST_F(TestDataTypeUtils, Hifloat4ShapeBtyes) | ||
| 373 | +{ | ||
| 374 | + // 17 个 hifloat4 = 68bit,按字节向上取整为 9 字节 | ||
| 375 | + EXPECT_EQ(op::CalcShapeBytes(17, op::internal::DT_HIFLOAT4), 9); | ||
| 376 | + EXPECT_EQ(op::CalcShapeBytes(17, op::internal::DT_HIFLOAT4_SCALE), 68); | ||
| 377 | +} | ||
| 378 | + | ||
| 379 | +TEST_F(TestDataTypeUtils, Hifloat4ToAclDataType) | ||
| 380 | +{ | ||
| 381 | + EXPECT_EQ(op::ToAclDataType(op::internal::DT_HIFLOAT4), op::internal::ACL_HIFLOAT4); | ||
| 382 | + EXPECT_EQ(op::ToAclDataType(op::internal::DT_HIFLOAT4_SCALE), op::internal::ACL_HIFLOAT4_SCALE); | ||
| 383 | + // 未纳入转换列表的类型仍返回 UNDEFINED | ||
| 384 | + EXPECT_EQ(op::ToAclDataType(op::DataType::DT_QINT8), ACL_DT_UNDEFINED); | ||
| 385 | +} | ||
| 386 | + | ||
| 387 | +TEST_F(TestDataTypeUtils, Hifloat4TypePredicates) | ||
| 388 | +{ | ||
| 389 | + EXPECT_TRUE(op::IsNumberType(op::internal::DT_HIFLOAT4)); | ||
| 390 | + EXPECT_TRUE(op::IsNumberType(op::internal::DT_HIFLOAT4_SCALE)); | ||
| 391 | + EXPECT_TRUE(op::IsRealNumberType(op::internal::DT_HIFLOAT4)); | ||
| 392 | + EXPECT_TRUE(op::IsRealNumberType(op::internal::DT_HIFLOAT4_SCALE)); | ||
| 393 | + EXPECT_TRUE(op::IsFloatingType(op::internal::DT_HIFLOAT4)); | ||
| 394 | + EXPECT_TRUE(op::IsFloatingType(op::internal::DT_HIFLOAT4_SCALE)); | ||
| 395 | + // hifloat4_scale 按浮点/数值类型对待,故允许 float 到 hifloat4_scale 的转换判定 | ||
| 396 | + EXPECT_TRUE(op::CanCast(op::DataType::DT_FLOAT, op::internal::DT_HIFLOAT4_SCALE)); | ||
| 397 | + // 浮点转整型仍不允许 | ||
| 398 | + EXPECT_FALSE(op::CanCast(op::internal::DT_HIFLOAT4, op::DataType::DT_INT32)); | ||
| 399 | +} | ||