Line data Source code
1 : /**
2 : * Copyright (c) 2026 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 : #include "ccu_rep_v1.h"
12 : #include "ccu_ins_generator_v1.h"
13 : #include "string_util.h"
14 : #include "exception_util.h"
15 : #include "ccu_api_exception.h"
16 : #include "ccu_kernel.h"
17 :
18 : namespace hcomm {
19 : namespace CcuRep {
20 37 : void CcuRepMul::SetCommonInfo()
21 : {
22 37 : type = CcuRepType::MUL;
23 37 : instrCount = insGenPtr->GetInstrCount(type);
24 37 : }
25 :
26 7 : CcuRepMul::CcuRepMul(
27 7 : CcuInsGeneratorBase* insGenPtr, const Variable& varC, const Variable& varA, const Variable& varB)
28 7 : : insGenPtr(insGenPtr),
29 7 : subType(MulSubType::VAR_MUL_VAR_TO_VAR),
30 7 : varA(varA),
31 7 : varB(varB),
32 14 : varC(varC)
33 : {
34 7 : SetCommonInfo();
35 7 : }
36 :
37 5 : CcuRepMul::CcuRepMul(CcuInsGeneratorBase* insGenPtr, const Variable& varC, const Variable& varA, uint16_t immedB)
38 5 : : insGenPtr(insGenPtr),
39 5 : subType(MulSubType::VAR_MUL_IMMED_TO_VAR),
40 5 : varA(varA),
41 5 : varC(varC),
42 10 : immedB(immedB)
43 : {
44 5 : SetCommonInfo();
45 5 : }
46 :
47 3 : CcuRepMul::CcuRepMul(CcuInsGeneratorBase* insGenPtr, const Variable& varA, const Variable& varB)
48 3 : : insGenPtr(insGenPtr),
49 3 : subType(MulSubType::SELF_MUL_VAR_VARIABLE),
50 3 : varA(varA),
51 3 : varB(varB)
52 : {
53 3 : SetCommonInfo();
54 3 : }
55 :
56 3 : CcuRepMul::CcuRepMul(CcuInsGeneratorBase* insGenPtr, const Variable& varA, uint16_t immedB)
57 3 : : insGenPtr(insGenPtr),
58 3 : subType(MulSubType::SELF_MUL_IMMED_VARIABLE),
59 3 : varA(varA),
60 3 : immedB(immedB)
61 : {
62 3 : SetCommonInfo();
63 3 : }
64 :
65 3 : CcuRepMul::CcuRepMul(
66 3 : CcuInsGeneratorBase* insGenPtr, const Address& addrC, const Variable& varA, const Variable& varB)
67 3 : : insGenPtr(insGenPtr),
68 3 : subType(MulSubType::VAR_MUL_VAR_TO_ADDR),
69 3 : varA(varA),
70 3 : varB(varB),
71 6 : addrC(addrC)
72 : {
73 3 : SetCommonInfo();
74 3 : }
75 :
76 3 : CcuRepMul::CcuRepMul(
77 3 : CcuInsGeneratorBase* insGenPtr, const Address& addrC, const Variable& varA, const Address& addrB)
78 3 : : insGenPtr(insGenPtr),
79 3 : subType(MulSubType::VAR_MUL_ADDR_TO_ADDR),
80 3 : varA(varA),
81 3 : addrB(addrB),
82 6 : addrC(addrC)
83 : {
84 3 : SetCommonInfo();
85 3 : }
86 :
87 3 : CcuRepMul::CcuRepMul(CcuInsGeneratorBase* insGenPtr, const Address& addrA, const Variable& varB)
88 3 : : insGenPtr(insGenPtr),
89 3 : subType(MulSubType::SELF_MUL_VAR_ADDRESS),
90 3 : varB(varB),
91 6 : addrA(addrA)
92 : {
93 3 : SetCommonInfo();
94 3 : }
95 :
96 3 : CcuRepMul::CcuRepMul(
97 3 : CcuInsGeneratorBase* insGenPtr, const Address& addrC, const Address& addrA, const uint16_t immedB)
98 3 : : insGenPtr(insGenPtr),
99 3 : subType(MulSubType::ADDR_MUL_IMMED_TO_ADDR),
100 3 : addrA(addrA),
101 3 : addrC(addrC),
102 6 : immedB(immedB)
103 : {
104 3 : SetCommonInfo();
105 3 : }
106 :
107 2 : CcuRepMul::CcuRepMul(
108 2 : CcuInsGeneratorBase* insGenPtr, const Address& addrC, const Variable& varA, const uint16_t immedB)
109 2 : : insGenPtr(insGenPtr),
110 2 : subType(MulSubType::VAR_MUL_IMMED_TO_ADDR),
111 2 : varA(varA),
112 2 : addrC(addrC),
113 2 : immedB(immedB)
114 : {
115 2 : SetCommonInfo();
116 2 : }
117 :
118 2 : CcuRepMul::CcuRepMul(CcuInsGeneratorBase* insGenPtr, const Address& addrA, const uint16_t immedB)
119 2 : : insGenPtr(insGenPtr),
120 2 : subType(MulSubType::SELF_MUL_IMMED_ADDRESS),
121 2 : addrA(addrA),
122 4 : immedB(immedB)
123 : {
124 2 : SetCommonInfo();
125 2 : }
126 :
127 3 : CcuRepMul::CcuRepMul(
128 3 : CcuInsGeneratorBase* insGenPtr, const Variable& varC, const Address& addrA, const uint16_t immedB)
129 3 : : insGenPtr(insGenPtr),
130 3 : subType(MulSubType::ADDR_MUL_IMMED_TO_VAR),
131 3 : varC(varC),
132 3 : addrA(addrA),
133 6 : immedB(immedB)
134 : {
135 3 : SetCommonInfo();
136 3 : }
137 :
138 8 : void CcuRepMul::ValidateInsGenPtrForMul()
139 : {
140 8 : CcuInsGeneratorV1* tmpPtrV1 = dynamic_cast<CcuInsGeneratorV1*>(insGenPtr);
141 8 : CHK_PRT_THROW(
142 : (tmpPtrV1 && !supportCcuV1),
143 : HCCL_ERROR("[CcuRepMul][%s]Cannot translate CcuRepMul for A5 when supportCcuV1 is false", __func__),
144 : Hccl::CcuApiException, "tmpPtrV1 does not match supportCcuV1");
145 8 : }
146 :
147 8 : bool CcuRepMul::Translate(
148 : CcuKernel* ccuKernel, CcuInstr*& instr, uint16_t& instrId, [[maybe_unused]] const TransDep& dep)
149 : {
150 8 : ValidateInsGenPtrForMul();
151 8 : Hccl::CHECK_NULLPTR(instr, "[CcuRepMul::Translate] instr is nullptr!");
152 8 : this->instrId = instrId;
153 8 : translated = true;
154 :
155 8 : CHK_PRT_THROW(
156 : insGenPtr->CcuRepMulTranslate(ccuKernel, instr, this) != HcclResult::HCCL_SUCCESS,
157 : HCCL_ERROR("[CcuRepMul][Translate] failed to translate for instrId[%u]", instrId), Hccl::CcuApiException,
158 : "CcuRepMul translate failed");
159 :
160 8 : CHK_PRT_THROW(
161 : (instrId > UINT16_MAX - instrCount),
162 : HCCL_ERROR(
163 : "[CcuRepMul::Translate]uint16 integer overflow occurs, instrId = [%hu], instrCount = [%hu]", instrId,
164 : instrCount),
165 : Hccl::InternalException, "integer overflow");
166 8 : instrId += instrCount;
167 :
168 8 : return translated;
169 : }
170 :
171 15 : std::string CcuRepMul::Describe()
172 : {
173 15 : switch (subType) {
174 3 : case MulSubType::VAR_MUL_VAR_TO_VAR: {
175 : return Hccl::StringFormat(
176 3 : "Variable[%u] = Variable[%u] * Variable[%u]", varC.Id(), varA.Id(), varB.Id());
177 : }
178 3 : case MulSubType::VAR_MUL_IMMED_TO_VAR: {
179 3 : return Hccl::StringFormat("Variable[%u] = Variable[%u] * Immed[%u]", varC.Id(), varA.Id(), immedB);
180 : }
181 1 : case MulSubType::SELF_MUL_VAR_VARIABLE: {
182 1 : return Hccl::StringFormat("Variable[%u] *= Variable[%u]", varA.Id(), varB.Id());
183 : }
184 1 : case MulSubType::SELF_MUL_IMMED_VARIABLE: {
185 1 : return Hccl::StringFormat("Variable[%u] *= Immed[%u]", varA.Id(), immedB);
186 : }
187 1 : case MulSubType::VAR_MUL_VAR_TO_ADDR: {
188 : return Hccl::StringFormat(
189 1 : "Address[%u] = Variable[%u] * Variable[%u]", addrC.Id(), varA.Id(), varB.Id());
190 : }
191 1 : case MulSubType::VAR_MUL_ADDR_TO_ADDR: {
192 : return Hccl::StringFormat(
193 1 : "Address[%u] = Variable[%u] * Address[%u]", addrC.Id(), varA.Id(), addrB.Id());
194 : }
195 1 : case MulSubType::VAR_MUL_IMMED_TO_ADDR: {
196 1 : return Hccl::StringFormat("address[%u] = Variable[%u] * Immed[%u]", addrC.Id(), varA.Id(), immedB);
197 : }
198 1 : case MulSubType::ADDR_MUL_IMMED_TO_ADDR: {
199 1 : return Hccl::StringFormat("address[%u] = address[%u] * Immed[%u]", addrC.Id(), addrA.Id(), immedB);
200 : }
201 1 : case MulSubType::SELF_MUL_VAR_ADDRESS: {
202 1 : return Hccl::StringFormat("address[%u] *= Variable[%u]", addrA.Id(), varB.Id());
203 : }
204 1 : case MulSubType::SELF_MUL_IMMED_ADDRESS: {
205 1 : return Hccl::StringFormat("address[%u] *= Immed[%u]", addrA.Id(), immedB);
206 : }
207 1 : case MulSubType::ADDR_MUL_IMMED_TO_VAR: {
208 1 : return Hccl::StringFormat("Variable[%u] = address[%u] * Immed[%u]", varC.Id(), addrA.Id(), immedB);
209 : }
210 0 : default: {
211 0 : return Hccl::StringFormat("Invalid Mul");
212 : }
213 : }
214 : }
215 :
216 3 : Address CcuRepMul::GetAddrA() { return addrA; }
217 :
218 1 : Address CcuRepMul::GetAddrB() { return addrB; }
219 :
220 3 : Address CcuRepMul::GetAddrC() { return addrC; }
221 :
222 8 : Variable CcuRepMul::GetVarA() { return varA; }
223 :
224 6 : Variable CcuRepMul::GetVarB() { return varB; }
225 :
226 7 : Variable CcuRepMul::GetVarC() { return varC; }
227 :
228 4 : uint16_t CcuRepMul::GetImmedB() { return immedB; }
229 :
230 19 : MulSubType CcuRepMul::GetSubType() { return subType; }
231 : }; // namespace CcuRep
232 : }; // namespace hcomm
|
