Line data Source code
1 : /**
2 : * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 :
11 : #ifndef HCCLV2_DATA_TYPE_H
12 : #define HCCLV2_DATA_TYPE_H
13 :
14 : #include <map>
15 : #include <unordered_map>
16 : #include <string>
17 : #include <cstdint>
18 : #include "types.h"
19 : #include "../utils/enum_factory_legacy.h"
20 : #include "hccl_res.h"
21 : #include "log.h"
22 : #include "string_util.h"
23 : #include <hccl/hccl_types.h>
24 : #include "../utils/exception_util.h"
25 : #include "../exception/invalid_params_exception.h"
26 :
27 : namespace Hccl {
28 :
29 523039 : MAKE_ENUM(
30 : DataType, INT8, INT16, INT32, FP16, FP32, INT64, UINT64, UINT8, UINT16, UINT32, FP64, BFP16, INT128, BF16_SAT, HIF8,
31 : FP8E4M3, FP8E5M2, FP8E8M0)
32 :
33 : const std::unordered_map<DataType, u32, std::EnumClassHash> DATA_TYPE_SIZE_MAP
34 : = {{DataType::INT8, sizeof(s8)},
35 : {DataType::INT16, sizeof(s16)},
36 : {DataType::INT32, sizeof(s32)},
37 : {DataType::FP16, 2},
38 : {DataType::FP32, sizeof(float)},
39 : {DataType::INT64, sizeof(s64)},
40 : {DataType::UINT64, sizeof(u64)},
41 : {DataType::UINT8, sizeof(u8)},
42 : {DataType::UINT16, sizeof(u16)},
43 : {DataType::UINT32, sizeof(u32)},
44 : {DataType::FP64, 8},
45 : {DataType::BFP16, 2},
46 : {DataType::INT128, 16},
47 : {DataType::BF16_SAT, 2},
48 : {DataType::HIF8, 1},
49 : {DataType::FP8E4M3, 1},
50 : {DataType::FP8E5M2, 1},
51 : {DataType::FP8E8M0, 1}};
52 :
53 : const std::unordered_map<DataType, HcclDataType, std::EnumClassHash> HCCL_DATA_TYPE_MAP = {
54 : {DataType::INT8, HCCL_DATA_TYPE_INT8}, {DataType::INT16, HCCL_DATA_TYPE_INT16},
55 : {DataType::INT32, HCCL_DATA_TYPE_INT32}, {DataType::FP16, HCCL_DATA_TYPE_FP16},
56 : {DataType::FP32, HCCL_DATA_TYPE_FP32}, {DataType::INT64, HCCL_DATA_TYPE_INT64},
57 : {DataType::UINT64, HCCL_DATA_TYPE_UINT64}, {DataType::UINT8, HCCL_DATA_TYPE_UINT8},
58 : {DataType::UINT16, HCCL_DATA_TYPE_UINT16}, {DataType::UINT32, HCCL_DATA_TYPE_UINT32},
59 : {DataType::FP64, HCCL_DATA_TYPE_FP64}, {DataType::BFP16, HCCL_DATA_TYPE_BFP16},
60 : {DataType::INT128, HCCL_DATA_TYPE_INT128}, {DataType::HIF8, HCCL_DATA_TYPE_HIF8},
61 : {DataType::FP8E4M3, HCCL_DATA_TYPE_FP8E4M3}, {DataType::FP8E5M2, HCCL_DATA_TYPE_FP8E5M2},
62 : {DataType::FP8E8M0, HCCL_DATA_TYPE_FP8E8M0},
63 : };
64 :
65 : const std::unordered_map<HcclDataType, DataType, std::EnumClassHash> DATA_TYPE_MAP = {
66 : {HCCL_DATA_TYPE_INT8, DataType::INT8}, {HCCL_DATA_TYPE_INT16, DataType::INT16},
67 : {HCCL_DATA_TYPE_INT32, DataType::INT32}, {HCCL_DATA_TYPE_FP16, DataType::FP16},
68 : {HCCL_DATA_TYPE_FP32, DataType::FP32}, {HCCL_DATA_TYPE_INT64, DataType::INT64},
69 : {HCCL_DATA_TYPE_UINT64, DataType::UINT64}, {HCCL_DATA_TYPE_UINT8, DataType::UINT8},
70 : {HCCL_DATA_TYPE_UINT16, DataType::UINT16}, {HCCL_DATA_TYPE_UINT32, DataType::UINT32},
71 : {HCCL_DATA_TYPE_FP64, DataType::FP64}, {HCCL_DATA_TYPE_BFP16, DataType::BFP16},
72 : {HCCL_DATA_TYPE_INT128, DataType::INT128}, {HCCL_DATA_TYPE_HIF8, DataType::HIF8},
73 : {HCCL_DATA_TYPE_FP8E4M3, DataType::FP8E4M3}, {HCCL_DATA_TYPE_FP8E5M2, DataType::FP8E5M2},
74 : {HCCL_DATA_TYPE_FP8E8M0, DataType::FP8E8M0},
75 : };
76 :
77 : const std::unordered_map<uint32_t, std::string> DATA_TYPE_TO_STRING_MAP = {
78 : {0, "INT8"}, {1, "INT16"}, {2, "INT32"}, {3, "FP16"}, {4, "FP32"}, {5, "INT64"},
79 : {6, "UINT64"}, {7, "UINT8"}, {8, "UINT16"}, {9, "UINT32"}, {10, "FP64"}, {11, "BFP16"},
80 : {12, "INT128"}, {14, "HIF8"}, {15, "FP8E4M3"}, {16, "FP8E5M2"}, {17, "FP8E8M0"},
81 : };
82 :
83 : const std::unordered_map<uint32_t, std::string> OP_TYPE_TO_STRING_MAP
84 : = {{0, "sum"}, {1, "mul"}, {2, "max"}, {3, "PROD"}};
85 :
86 133 : inline u32 DataTypeSizeGet(DataType type)
87 : {
88 133 : if (UNLIKELY(DATA_TYPE_SIZE_MAP.find(type) == DATA_TYPE_SIZE_MAP.end())) {
89 0 : THROW<InvalidParamsException>(StringFormat("%s type[%s] is not supported.", __func__, type.Describe().c_str()));
90 : }
91 133 : return DATA_TYPE_SIZE_MAP.at(type);
92 : }
93 :
94 6 : inline HcclDataType DataTypeToHcclDataType(const DataType dataType)
95 : {
96 6 : if (UNLIKELY(HCCL_DATA_TYPE_MAP.find(dataType) == HCCL_DATA_TYPE_MAP.end())) {
97 0 : THROW<InvalidParamsException>(
98 0 : StringFormat("%s type[%s] is not supported.", __func__, dataType.Describe().c_str()));
99 : }
100 6 : return HCCL_DATA_TYPE_MAP.at(dataType);
101 : }
102 :
103 204 : inline DataType HcclDataTypeToDataType(const HcclDataType hcclDataType)
104 : {
105 204 : if (UNLIKELY(DATA_TYPE_MAP.find(hcclDataType) == DATA_TYPE_MAP.end())) {
106 3 : HCCL_ERROR("%s hcclDataType[%d] is not supported.", __func__, hcclDataType);
107 1 : return DataType::INVALID;
108 : }
109 203 : return DATA_TYPE_MAP.at(hcclDataType);
110 : }
111 :
112 21 : inline std::string DataTypeToSerialString(const uint32_t dataType)
113 : {
114 21 : if (UNLIKELY(DATA_TYPE_TO_STRING_MAP.find(dataType) == DATA_TYPE_TO_STRING_MAP.end())) {
115 42 : return "UNDEFINED";
116 : }
117 0 : return DATA_TYPE_TO_STRING_MAP.at(dataType);
118 : }
119 :
120 1 : inline std::string OpTypeToSerialString(const uint32_t opType)
121 : {
122 1 : if (OP_TYPE_TO_STRING_MAP.find(opType) == OP_TYPE_TO_STRING_MAP.end()) {
123 0 : return "UNDEFINED";
124 : }
125 1 : return OP_TYPE_TO_STRING_MAP.at(opType);
126 : }
127 :
128 : } // namespace Hccl
129 :
130 : #endif // HCCLV2_DATA_TYPE_H
|
