1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "lite_graph_to_hdi_model_v2_1.h"
17 #include <vector>
18 #include <algorithm>
19 #include <sys/mman.h>
20 #include "common/log.h"
21 #include "message_parcel.h"
22 #include "nnrt/v2_1/nnrt_types.h"
23 #include "nnrt/v2_1/node_attr_types.h"
24 #include "securec.h"
25
26 using namespace OHOS::HDI::Nnrt::V2_1;
27 typedef void *PrimitivePtr;
28 typedef void *TensorPtr;
29 namespace OHOS {
30 namespace NeuralNetworkRuntime {
31 namespace NNRt_V2_1 {
ConvertActivation(const PrimitivePtr primitive)32 std::vector<int8_t> ConvertActivation(const PrimitivePtr primitive)
33 {
34 if (primitive == nullptr) {
35 LOGE("ConvertActivation v2_1 failed, primitive is nullptr.");
36 return {};
37 }
38
39 Activation activation{};
40 activation.activationType = static_cast<HDI::Nnrt::V2_1::ActivationType>(
41 mindspore::lite::MindIR_Activation_GetActivationType(primitive));
42 activation.alpha = mindspore::lite::MindIR_Activation_GetAlpha(primitive);
43 activation.minVal = mindspore::lite::MindIR_Activation_GetMinVal(primitive);
44 activation.maxVal = mindspore::lite::MindIR_Activation_GetMaxVal(primitive);
45 activation.approximate = mindspore::lite::MindIR_Activation_GetApproximate(primitive);
46
47 OHOS::MessageParcel data;
48 (void)ActivationBlockMarshalling(data, activation);
49 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
50 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
51 return ret;
52 }
53
ConvertAddFusion(const PrimitivePtr primitive)54 std::vector<int8_t> ConvertAddFusion(const PrimitivePtr primitive)
55 {
56 if (primitive == nullptr) {
57 LOGE("ConvertAddFusion v2_1 failed, primitive is nullptr.");
58 return {};
59 }
60
61 AddFusion addFusion{};
62 addFusion.activationType = static_cast<HDI::Nnrt::V2_1::ActivationType>(
63 mindspore::lite::MindIR_Activation_GetActivationType(primitive));
64
65 OHOS::MessageParcel data;
66 (void)AddFusionBlockMarshalling(data, addFusion);
67 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
68 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
69 return ret;
70 }
71
ConvertAll(const PrimitivePtr primitive)72 std::vector<int8_t> ConvertAll(const PrimitivePtr primitive)
73 {
74 if (primitive == nullptr) {
75 LOGE("ConvertAll v2_1 failed, primitive is nullptr.");
76 return {};
77 }
78
79 All all{};
80 all.keepDims = mindspore::lite::MindIR_All_GetKeepDims(primitive);
81
82 OHOS::MessageParcel data;
83 (void)AllBlockMarshalling(data, all);
84 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
85 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
86 return ret;
87 }
88
ConvertArgMaxFusion(const PrimitivePtr primitive)89 std::vector<int8_t> ConvertArgMaxFusion(const PrimitivePtr primitive)
90 {
91 if (primitive == nullptr) {
92 LOGE("ConvertArgMaxFusion v2_1 failed, primitive is nullptr.");
93 return {};
94 }
95
96 ArgMaxFusion argMaxFusion{};
97 argMaxFusion.axis = mindspore::lite::MindIR_ArgMaxFusion_GetAxis(primitive);
98 argMaxFusion.topK = mindspore::lite::MindIR_ArgMaxFusion_GetTopK(primitive);
99 argMaxFusion.keepDims = mindspore::lite::MindIR_ArgMaxFusion_GetKeepDims(primitive);
100 argMaxFusion.outMaxValue = mindspore::lite::MindIR_ArgMaxFusion_GetOutMaxValue(primitive);
101
102 OHOS::MessageParcel data;
103 (void)ArgMaxFusionBlockMarshalling(data, argMaxFusion);
104 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
105 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
106 return ret;
107 }
108
ConvertAssert(const PrimitivePtr primitive)109 std::vector<int8_t> ConvertAssert(const PrimitivePtr primitive)
110 {
111 if (primitive == nullptr) {
112 LOGE("ConvertAssert v2_1 failed, primitive is nullptr.");
113 return {};
114 }
115
116 Assert assert{};
117 assert.summarize = mindspore::lite::MindIR_Assert_GetSummarize(primitive);
118
119 OHOS::MessageParcel data;
120 (void)AssertBlockMarshalling(data, assert);
121 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
122 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
123 return ret;
124 }
125
ConvertAvgPoolFusion(const PrimitivePtr primitive)126 std::vector<int8_t> ConvertAvgPoolFusion(const PrimitivePtr primitive)
127 {
128 if (primitive == nullptr) {
129 LOGE("ConvertAvgPoolFusion v2_1 failed, primitive is nullptr.");
130 return {};
131 }
132
133 AvgPoolFusion avgPoolFusion{};
134 avgPoolFusion.kernelSize = mindspore::lite::MindIR_AvgPoolFusion_GetKernelSize(primitive);
135 avgPoolFusion.strides = mindspore::lite::MindIR_AvgPoolFusion_GetStrides(primitive);
136 avgPoolFusion.pad = mindspore::lite::MindIR_AvgPoolFusion_GetPad(primitive);
137 avgPoolFusion.padMode = static_cast<PadMode>(mindspore::lite::MindIR_AvgPoolFusion_GetPadMode(primitive));
138 avgPoolFusion.roundMode = static_cast<RoundMode>(mindspore::lite::MindIR_AvgPoolFusion_GetRoundMode(primitive));
139 avgPoolFusion.format = static_cast<Format>(mindspore::lite::MindIR_AvgPoolFusion_GetFormat(primitive));
140 avgPoolFusion.global = mindspore::lite::MindIR_AvgPoolFusion_GetGlobal(primitive);
141 avgPoolFusion.activationType =
142 static_cast<ActivationType>(mindspore::lite::MindIR_AvgPoolFusion_GetActivationType(primitive));
143
144 OHOS::MessageParcel data;
145 (void)AvgPoolFusionBlockMarshalling(data, avgPoolFusion);
146 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
147 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
148 return ret;
149 }
150
ConvertBatchToSpaceND(const PrimitivePtr primitive)151 std::vector<int8_t> ConvertBatchToSpaceND(const PrimitivePtr primitive)
152 {
153 if (primitive == nullptr) {
154 LOGE("ConvertBatchToSpaceND v2_1 failed, primitive is nullptr.");
155 return {};
156 }
157
158 BatchToSpaceND batchToSpaceND{};
159 batchToSpaceND.blockShape = mindspore::lite::MindIR_BatchToSpaceND_GetBlockShape(primitive);
160 batchToSpaceND.crops = mindspore::lite::MindIR_BatchToSpaceND_GetCrops(primitive);
161
162 OHOS::MessageParcel data;
163 (void)BatchToSpaceNDBlockMarshalling(data, batchToSpaceND);
164 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
165 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
166 return ret;
167 }
168
ConvertBiasAdd(const PrimitivePtr primitive)169 std::vector<int8_t> ConvertBiasAdd(const PrimitivePtr primitive)
170 {
171 if (primitive == nullptr) {
172 LOGE("ConvertBiasAdd v2_1 failed, primitive is nullptr.");
173 return {};
174 }
175
176 BiasAdd biasAdd{};
177 OHOS::MessageParcel data;
178 (void)BiasAddBlockMarshalling(data, biasAdd);
179 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
180 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
181 return ret;
182 }
183
ConvertBroadcastTo(const PrimitivePtr primitive)184 std::vector<int8_t> ConvertBroadcastTo(const PrimitivePtr primitive)
185 {
186 if (primitive == nullptr) {
187 LOGE("ConvertBroadcastTo v2_1 failed, primitive is nullptr.");
188 return {};
189 }
190
191 BroadcastTo broadcastTo{};
192 broadcastTo.shape = mindspore::lite::MindIR_BroadcastTo_GetShape(primitive);
193
194 OHOS::MessageParcel data;
195 (void)BroadcastToBlockMarshalling(data, broadcastTo);
196 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
197 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
198 return ret;
199 }
200
ConvertCast(const PrimitivePtr primitive)201 std::vector<int8_t> ConvertCast(const PrimitivePtr primitive)
202 {
203 if (primitive == nullptr) {
204 LOGE("ConvertCast v2_1 failed, primitive is nullptr.");
205 return {};
206 }
207
208 Cast cast{};
209 OHOS::MessageParcel data;
210 (void)CastBlockMarshalling(data, cast);
211 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
212 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
213 return ret;
214 }
215
ConvertCeil(const PrimitivePtr primitive)216 std::vector<int8_t> ConvertCeil(const PrimitivePtr primitive)
217 {
218 if (primitive == nullptr) {
219 LOGE("ConvertCeil v2_1 failed, primitive is nullptr.");
220 return {};
221 }
222
223 Ceil ceil{};
224 OHOS::MessageParcel data;
225 (void)CeilBlockMarshalling(data, ceil);
226 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
227 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
228 return ret;
229 }
230
ConvertClip(const PrimitivePtr primitive)231 std::vector<int8_t> ConvertClip(const PrimitivePtr primitive)
232 {
233 if (primitive == nullptr) {
234 LOGE("ConvertClip v2_1 failed, primitive is nullptr.");
235 return {};
236 }
237
238 Clip clip{};
239 clip.max = mindspore::lite::MindIR_Clip_GetMax(primitive);
240 clip.min = mindspore::lite::MindIR_Clip_GetMin(primitive);
241
242 OHOS::MessageParcel data;
243 (void)ClipBlockMarshalling(data, clip);
244 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
245 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
246 return ret;
247 }
248
ConvertConcat(const PrimitivePtr primitive)249 std::vector<int8_t> ConvertConcat(const PrimitivePtr primitive)
250 {
251 if (primitive == nullptr) {
252 LOGE("ConvertConcat v2_1 failed, primitive is nullptr.");
253 return {};
254 }
255
256 Concat concat{};
257 concat.axis = mindspore::lite::MindIR_Concat_GetAxis(primitive);
258 OHOS::MessageParcel data;
259 (void)ConcatBlockMarshalling(data, concat);
260 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
261 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
262 return ret;
263 }
264
ConvertConv2DFusion(const PrimitivePtr primitive)265 std::vector<int8_t> ConvertConv2DFusion(const PrimitivePtr primitive)
266 {
267 if (primitive == nullptr) {
268 LOGE("ConvertConv2DFusion v2_1 failed, primitive is nullptr.");
269 return {};
270 }
271
272 Conv2DFusion conv2DFusion{};
273 conv2DFusion.kernelSize = mindspore::lite::MindIR_Conv2DFusion_GetKernelSize(primitive);
274 conv2DFusion.stride = mindspore::lite::MindIR_Conv2DFusion_GetStride(primitive);
275 conv2DFusion.dilation = mindspore::lite::MindIR_Conv2DFusion_GetDilation(primitive);
276 conv2DFusion.padMode = static_cast<PadMode>(mindspore::lite::MindIR_Conv2DFusion_GetPadMode(primitive));
277 conv2DFusion.padList = mindspore::lite::MindIR_Conv2DFusion_GetPadList(primitive);
278 conv2DFusion.group = mindspore::lite::MindIR_Conv2DFusion_GetGroup(primitive);
279 conv2DFusion.inChannel = mindspore::lite::MindIR_Conv2DFusion_GetInChannel(primitive);
280 conv2DFusion.outChannel = mindspore::lite::MindIR_Conv2DFusion_GetOutChannel(primitive);
281 conv2DFusion.activationType = static_cast<ActivationType>(
282 mindspore::lite::MindIR_Conv2DFusion_GetActivationType(primitive));
283
284 OHOS::MessageParcel data;
285 (void)Conv2DFusionBlockMarshalling(data, conv2DFusion);
286 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
287 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
288 return ret;
289 }
290
ConvertConv2dTransposeFusion(const PrimitivePtr primitive)291 std::vector<int8_t> ConvertConv2dTransposeFusion(const PrimitivePtr primitive)
292 {
293 if (primitive == nullptr) {
294 LOGE("ConvertConv2dTransposeFusion v2_1 failed, primitive is nullptr.");
295 return {};
296 }
297
298 Conv2dTransposeFusion conv2dTransposeFusion{};
299 conv2dTransposeFusion.kernelSize = mindspore::lite::MindIR_Conv2dTransposeFusion_GetKernelSize(primitive);
300 conv2dTransposeFusion.stride = mindspore::lite::MindIR_Conv2dTransposeFusion_GetStride(primitive);
301 conv2dTransposeFusion.dilation = mindspore::lite::MindIR_Conv2dTransposeFusion_GetDilation(primitive);
302 conv2dTransposeFusion.padMode = static_cast<PadMode>(
303 mindspore::lite::MindIR_Conv2dTransposeFusion_GetPadMode(primitive));
304 conv2dTransposeFusion.padList = mindspore::lite::MindIR_Conv2dTransposeFusion_GetPadList(primitive);
305 conv2dTransposeFusion.group = mindspore::lite::MindIR_Conv2dTransposeFusion_GetGroup(primitive);
306 conv2dTransposeFusion.inChannel = mindspore::lite::MindIR_Conv2dTransposeFusion_GetInChannel(primitive);
307 conv2dTransposeFusion.outChannel = mindspore::lite::MindIR_Conv2dTransposeFusion_GetOutChannel(primitive);
308 conv2dTransposeFusion.activationType = static_cast<ActivationType>(
309 mindspore::lite::MindIR_Conv2dTransposeFusion_GetActivationType(primitive));
310 conv2dTransposeFusion.outputPaddings = mindspore::lite::MindIR_Conv2dTransposeFusion_GetOutputPaddings(primitive);
311
312 OHOS::MessageParcel data;
313 (void)Conv2dTransposeFusionBlockMarshalling(data, conv2dTransposeFusion);
314 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
315 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
316 return ret;
317 }
318
ConvertCos(const PrimitivePtr primitive)319 std::vector<int8_t> ConvertCos(const PrimitivePtr primitive)
320 {
321 if (primitive == nullptr) {
322 LOGE("ConvertCos v2_1 failed, primitive is nullptr.");
323 return {};
324 }
325
326 Cos cos{};
327
328 OHOS::MessageParcel data;
329 (void)CosBlockMarshalling(data, cos);
330 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
331 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
332 return ret;
333 }
334
ConvertConstantOfShape(const PrimitivePtr primitive)335 std::vector<int8_t> ConvertConstantOfShape(const PrimitivePtr primitive)
336 {
337 if (primitive == nullptr) {
338 LOGE("ConvertConstantOfShape v2_1 failed, primitive is nullptr.");
339 return {};
340 }
341
342 ConstantOfShape constantOfShape{};
343 constantOfShape.dataType = mindspore::lite::MindIR_ConstantOfShape_GetDataType(primitive);
344 constantOfShape.value = mindspore::lite::MindIR_ConstantOfShape_GetValue(primitive);
345
346 OHOS::MessageParcel data;
347 (void)ConstantOfShapeBlockMarshalling(data, constantOfShape);
348 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
349 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
350 return ret;
351 }
352
ConvertCrop(const PrimitivePtr primitive)353 std::vector<int8_t> ConvertCrop(const PrimitivePtr primitive)
354 {
355 if (primitive == nullptr) {
356 LOGE("ConvertCrop v2_1 failed, primitive is nullptr.");
357 return {};
358 }
359
360 Crop crop{};
361 crop.axis = mindspore::lite::MindIR_Crop_GetAxis(primitive);
362 crop.offset = mindspore::lite::MindIR_Crop_GetOffsets(primitive);
363
364 OHOS::MessageParcel data;
365 (void)CropBlockMarshalling(data, crop);
366 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
367 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
368 return ret;
369 }
370
ConvertDepthToSpace(const PrimitivePtr primitive)371 std::vector<int8_t> ConvertDepthToSpace(const PrimitivePtr primitive)
372 {
373 if (primitive == nullptr) {
374 LOGE("ConvertDepthToSpace v2_1 failed, primitive is nullptr.");
375 return {};
376 }
377
378 DepthToSpace depthToSpace{};
379 depthToSpace.blockSize = mindspore::lite::MindIR_DepthToSpace_GetBlockSize(primitive);
380 depthToSpace.format = static_cast<Format>(
381 mindspore::lite::MindIR_DepthToSpace_GetFormat(primitive));
382 depthToSpace.mode = mindspore::lite::MindIR_DepthToSpace_GetMode(primitive);
383
384 OHOS::MessageParcel data;
385 (void)DepthToSpaceBlockMarshalling(data, depthToSpace);
386 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
387 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
388 return ret;
389 }
390
ConvertDetectionPostProcess(const PrimitivePtr primitive)391 std::vector<int8_t> ConvertDetectionPostProcess(const PrimitivePtr primitive)
392 {
393 if (primitive == nullptr) {
394 LOGE("ConvertDetectionPostProcess v2_1 failed, primitive is nullptr.");
395 return {};
396 }
397
398 DetectionPostProcess detectionPostProcess{};
399 detectionPostProcess.format = static_cast<Format>(
400 mindspore::lite::MindIR_DetectionPostProcess_GetFormat(primitive));
401 detectionPostProcess.inputSize = mindspore::lite::MindIR_DetectionPostProcess_GetInputSize(primitive);
402 detectionPostProcess.scale = mindspore::lite::MindIR_DetectionPostProcess_GetScale(primitive);
403 detectionPostProcess.nmsIoUThreshold = mindspore::lite::MindIR_DetectionPostProcess_GetNmsIouThreshold(primitive);
404 detectionPostProcess.nmsScoreThreshold =
405 mindspore::lite::MindIR_DetectionPostProcess_GetNmsScoreThreshold(primitive);
406 detectionPostProcess.maxDetections = mindspore::lite::MindIR_DetectionPostProcess_GetMaxDetections(primitive);
407 detectionPostProcess.detectionsPerClass =
408 mindspore::lite::MindIR_DetectionPostProcess_GetDetectionsPerClass(primitive);
409 detectionPostProcess.maxClassesPerDetection =
410 mindspore::lite::MindIR_DetectionPostProcess_GetMaxClassesPerDetection(primitive);
411 detectionPostProcess.numClasses = mindspore::lite::MindIR_DetectionPostProcess_GetNumClasses(primitive);
412 detectionPostProcess.useRegularNms = mindspore::lite::MindIR_DetectionPostProcess_GetUseRegularNms(primitive);
413 detectionPostProcess.outQuantized = mindspore::lite::MindIR_DetectionPostProcess_GetOutQuantized(primitive);
414
415 OHOS::MessageParcel data;
416 (void)DetectionPostProcessBlockMarshalling(data, detectionPostProcess);
417 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
418 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
419 return ret;
420 }
421
ConvertDivFusion(const PrimitivePtr primitive)422 std::vector<int8_t> ConvertDivFusion(const PrimitivePtr primitive)
423 {
424 if (primitive == nullptr) {
425 LOGE("ConvertDivFusion v2_1 failed, primitive is nullptr.");
426 return {};
427 }
428
429 DivFusion divFusion{};
430 divFusion.activationType = static_cast<ActivationType>(
431 mindspore::lite::MindIR_DivFusion_GetActivationType(primitive));
432 OHOS::MessageParcel data;
433 (void)DivFusionBlockMarshalling(data, divFusion);
434 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
435 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
436 return ret;
437 }
438
ConvertEltwise(const PrimitivePtr primitive)439 std::vector<int8_t> ConvertEltwise(const PrimitivePtr primitive)
440 {
441 if (primitive == nullptr) {
442 LOGE("ConvertEltwise v2_1 failed, primitive is nullptr.");
443 return {};
444 }
445
446 Eltwise eltwise{};
447 eltwise.mode = static_cast<EltwiseMode>(mindspore::lite::MindIR_Eltwise_GetMode(primitive));
448 OHOS::MessageParcel data;
449 (void)EltwiseBlockMarshalling(data, eltwise);
450 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
451 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
452 return ret;
453 }
454
ConvertEqual(const PrimitivePtr primitive)455 std::vector<int8_t> ConvertEqual(const PrimitivePtr primitive)
456 {
457 if (primitive == nullptr) {
458 LOGE("ConvertEqual v2_1 failed, primitive is nullptr.");
459 return {};
460 }
461
462 Equal equal{};
463 OHOS::MessageParcel data;
464 (void)EqualBlockMarshalling(data, equal);
465 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
466 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
467 return ret;
468 }
469
ConvertExpFusion(const PrimitivePtr primitive)470 std::vector<int8_t> ConvertExpFusion(const PrimitivePtr primitive)
471 {
472 if (primitive == nullptr) {
473 LOGE("ConvertExp v2_1 failed, primitive is nullptr.");
474 return {};
475 }
476
477 ExpFusion exp{};
478 exp.base = mindspore::lite::MindIR_ExpFusion_GetBase(primitive);
479 exp.scale = mindspore::lite::MindIR_ExpFusion_GetScale(primitive);
480 exp.shift = mindspore::lite::MindIR_ExpFusion_GetShift(primitive);
481
482 OHOS::MessageParcel data;
483 (void)ExpFusionBlockMarshalling(data, exp);
484 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
485 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
486 return ret;
487 }
488
ConvertExpandDims(const PrimitivePtr primitive)489 std::vector<int8_t> ConvertExpandDims(const PrimitivePtr primitive)
490 {
491 if (primitive == nullptr) {
492 LOGE("ConvertExpandDims v2_1 failed, primitive is nullptr.");
493 return {};
494 }
495
496 ExpandDims expandDims{};
497 OHOS::MessageParcel data;
498 (void)ExpandDimsBlockMarshalling(data, expandDims);
499 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
500 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
501 return ret;
502 }
503
ConvertFlatten(const PrimitivePtr primitive)504 std::vector<int8_t> ConvertFlatten(const PrimitivePtr primitive)
505 {
506 if (primitive == nullptr) {
507 LOGE("ConvertFlatten v2_1 failed, primitive is nullptr.");
508 return {};
509 }
510
511 Flatten faltten{};
512 faltten.axis = mindspore::lite::MindIR_Flatten_GetAxis(primitive);
513
514 OHOS::MessageParcel data;
515 (void)FlattenBlockMarshalling(data, faltten);
516 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
517 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
518 return ret;
519 }
520
ConvertFloor(const PrimitivePtr primitive)521 std::vector<int8_t> ConvertFloor(const PrimitivePtr primitive)
522 {
523 if (primitive == nullptr) {
524 LOGE("ConvertFloor v2_1 failed, primitive is nullptr.");
525 return {};
526 }
527
528 Floor floor{};
529
530 OHOS::MessageParcel data;
531 (void)FloorBlockMarshalling(data, floor);
532 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
533 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
534 return ret;
535 }
536
ConvertFill(const PrimitivePtr primitive)537 std::vector<int8_t> ConvertFill(const PrimitivePtr primitive)
538 {
539 if (primitive == nullptr) {
540 LOGE("ConvertFill v2_1 failed, primitive is nullptr.");
541 return {};
542 }
543
544 Fill fill{};
545 OHOS::MessageParcel data;
546 (void)FillBlockMarshalling(data, fill);
547 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
548 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
549 return ret;
550 }
551
ConvertFullConnection(const PrimitivePtr primitive)552 std::vector<int8_t> ConvertFullConnection(const PrimitivePtr primitive)
553 {
554 if (primitive == nullptr) {
555 LOGE("ConvertFullConnection v2_1 failed, primitive is nullptr.");
556 return {};
557 }
558
559 FullConnection fullConnection{};
560 fullConnection.hasBias = mindspore::lite::MindIR_FullConnection_GetHasBias(primitive);
561 fullConnection.useAxis = mindspore::lite::MindIR_FullConnection_GetUseAxis(primitive);
562 fullConnection.axis = mindspore::lite::MindIR_FullConnection_GetAxis(primitive);
563 fullConnection.activationType = static_cast<ActivationType>(
564 mindspore::lite::MindIR_FullConnection_GetActivationType(primitive));
565
566 OHOS::MessageParcel data;
567 (void)FullConnectionBlockMarshalling(data, fullConnection);
568 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
569 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
570 return ret;
571 }
572
ConvertFusedBatchNorm(const PrimitivePtr primitive)573 std::vector<int8_t> ConvertFusedBatchNorm(const PrimitivePtr primitive)
574 {
575 if (primitive == nullptr) {
576 LOGE("ConvertFusedBatchNorm v2_1 failed, primitive is nullptr.");
577 return {};
578 }
579
580 FusedBatchNorm fusedBatchNorm{};
581 fusedBatchNorm.epsilon = mindspore::lite::MindIR_FusedBatchNorm_GetEpsilon(primitive);
582 OHOS::MessageParcel data;
583 (void)FusedBatchNormBlockMarshalling(data, fusedBatchNorm);
584 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
585 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
586 return ret;
587 }
588
ConvertGather(const PrimitivePtr primitive)589 std::vector<int8_t> ConvertGather(const PrimitivePtr primitive)
590 {
591 if (primitive == nullptr) {
592 LOGE("ConvertGather v2_1 failed, primitive is nullptr.");
593 return {};
594 }
595
596 Gather gather{};
597 OHOS::MessageParcel data;
598 (void)GatherBlockMarshalling(data, gather);
599 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
600 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
601 return ret;
602 }
603
ConvertGatherNd(const PrimitivePtr primitive)604 std::vector<int8_t> ConvertGatherNd(const PrimitivePtr primitive)
605 {
606 if (primitive == nullptr) {
607 LOGE("ConvertGatherNd v2_1 failed, primitive is nullptr.");
608 return {};
609 }
610
611 GatherNd gatherNd{};
612 OHOS::MessageParcel data;
613 (void)GatherNdBlockMarshalling(data, gatherNd);
614 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
615 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
616 return ret;
617 }
618
ConvertGreater(const PrimitivePtr primitive)619 std::vector<int8_t> ConvertGreater(const PrimitivePtr primitive)
620 {
621 if (primitive == nullptr) {
622 LOGE("ConvertGreater v2_1 failed, primitive is nullptr.");
623 return {};
624 }
625
626 Greater greater{};
627 OHOS::MessageParcel data;
628 (void)GreaterBlockMarshalling(data, greater);
629 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
630 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
631 return ret;
632 }
633
ConvertGreaterEqual(const PrimitivePtr primitive)634 std::vector<int8_t> ConvertGreaterEqual(const PrimitivePtr primitive)
635 {
636 if (primitive == nullptr) {
637 LOGE("ConvertGreaterEqual v2_1 failed, primitive is nullptr.");
638 return {};
639 }
640
641 GreaterEqual greaterEqual{};
642 OHOS::MessageParcel data;
643 (void)GreaterEqualBlockMarshalling(data, greaterEqual);
644 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
645 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
646 return ret;
647 }
648
ConvertInstanceNorm(const PrimitivePtr primitive)649 std::vector<int8_t> ConvertInstanceNorm(const PrimitivePtr primitive)
650 {
651 if (primitive == nullptr) {
652 LOGE("ConvertInstanceNorm v2_1 failed, primitive is nullptr.");
653 return {};
654 }
655
656 InstanceNorm instanceNorm{};
657 instanceNorm.epsilon = mindspore::lite::MindIR_InstanceNorm_GetEpsilon(primitive);
658
659 OHOS::MessageParcel data;
660 (void)InstanceNormBlockMarshalling(data, instanceNorm);
661 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
662 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
663 return ret;
664 }
665
ConvertLayerNormFusion(const PrimitivePtr primitive)666 std::vector<int8_t> ConvertLayerNormFusion(const PrimitivePtr primitive)
667 {
668 if (primitive == nullptr) {
669 LOGE("ConvertLayerNorm v2_1 failed, primitive is nullptr.");
670 return {};
671 }
672
673 LayerNormFusion layerNormFusion{};
674 layerNormFusion.beginNormAxis = mindspore::lite::MindIR_LayerNormFusion_GetBeginNormAxis(primitive);
675 layerNormFusion.epsilon = mindspore::lite::MindIR_LayerNormFusion_GetEpsilon(primitive);
676 layerNormFusion.elementwiseAffine = mindspore::lite::MindIR_LayerNormFusion_GetElementwiseAffine(primitive);
677 layerNormFusion.beginParamsAxis = mindspore::lite::MindIR_LayerNormFusion_GetBeginParamsAxis(primitive);
678
679 OHOS::MessageParcel data;
680 (void)LayerNormFusionBlockMarshalling(data, layerNormFusion);
681 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
682 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
683 return ret;
684 }
685
ConvertLess(const PrimitivePtr primitive)686 std::vector<int8_t> ConvertLess(const PrimitivePtr primitive)
687 {
688 if (primitive == nullptr) {
689 LOGE("ConvertLess v2_1 failed, primitive is nullptr.");
690 return {};
691 }
692
693 Less less{};
694 OHOS::MessageParcel data;
695 (void)LessBlockMarshalling(data, less);
696 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
697 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
698 return ret;
699 }
700
ConvertLessEqual(const PrimitivePtr primitive)701 std::vector<int8_t> ConvertLessEqual(const PrimitivePtr primitive)
702 {
703 if (primitive == nullptr) {
704 LOGE("ConvertLessEqual v2_1 failed, primitive is nullptr.");
705 return {};
706 }
707
708 LessEqual lessEqual{};
709 OHOS::MessageParcel data;
710 (void)LessEqualBlockMarshalling(data, lessEqual);
711 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
712 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
713 return ret;
714 }
715
ConvertLog(const PrimitivePtr primitive)716 std::vector<int8_t> ConvertLog(const PrimitivePtr primitive)
717 {
718 if (primitive == nullptr) {
719 LOGE("ConvertLog v2_1 failed, primitive is nullptr.");
720 return {};
721 }
722
723 Log log{};
724
725 OHOS::MessageParcel data;
726 (void)LogBlockMarshalling(data, log);
727 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
728 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
729 return ret;
730 }
731
ConvertLogicalAnd(const PrimitivePtr primitive)732 std::vector<int8_t> ConvertLogicalAnd(const PrimitivePtr primitive)
733 {
734 if (primitive == nullptr) {
735 LOGE("ConvertLogicalAnd v2_1 failed, primitive is nullptr.");
736 return {};
737 }
738
739 LogicalAnd logicalAnd{};
740
741 OHOS::MessageParcel data;
742 (void)LogicalAndBlockMarshalling(data, logicalAnd);
743 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
744 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
745 return ret;
746 }
747
ConvertLogicalNot(const PrimitivePtr primitive)748 std::vector<int8_t> ConvertLogicalNot(const PrimitivePtr primitive)
749 {
750 if (primitive == nullptr) {
751 LOGE("ConvertLogicalNot v2_1 failed, primitive is nullptr.");
752 return {};
753 }
754
755 LogicalNot logicalNot{};
756
757 OHOS::MessageParcel data;
758 (void)LogicalNotBlockMarshalling(data, logicalNot);
759 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
760 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
761 return ret;
762 }
763
ConvertLogicalOr(const PrimitivePtr primitive)764 std::vector<int8_t> ConvertLogicalOr(const PrimitivePtr primitive)
765 {
766 if (primitive == nullptr) {
767 LOGE("ConvertLogicalOr v2_1 failed, primitive is nullptr.");
768 return {};
769 }
770
771 LogicalOr logicalOr{};
772
773 OHOS::MessageParcel data;
774 (void)LogicalOrBlockMarshalling(data, logicalOr);
775 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
776 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
777 return ret;
778 }
779
ConvertLRN(const PrimitivePtr primitive)780 std::vector<int8_t> ConvertLRN(const PrimitivePtr primitive)
781 {
782 if (primitive == nullptr) {
783 LOGE("ConvertLRN v2_1 failed, primitive is nullptr.");
784 return {};
785 }
786
787 LRN lrn{};
788 lrn.depthRadius = mindspore::lite::MindIR_LRN_GetDepthRadius(primitive);
789 lrn.bias = mindspore::lite::MindIR_LRN_GetBias(primitive);
790 lrn.alpha = mindspore::lite::MindIR_LRN_GetAlpha(primitive);
791 lrn.beta = mindspore::lite::MindIR_LRN_GetBeta(primitive);
792 lrn.normRegion = mindspore::lite::MindIR_LRN_GetNormRegion(primitive);
793
794 OHOS::MessageParcel data;
795 (void)LRNBlockMarshalling(data, lrn);
796 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
797 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
798 return ret;
799 }
800
ConvertLSTM(const PrimitivePtr primitive)801 std::vector<int8_t> ConvertLSTM(const PrimitivePtr primitive)
802 {
803 if (primitive == nullptr) {
804 LOGE("ConvertLSTM v2_1 failed, primitive is nullptr.");
805 return {};
806 }
807
808 LSTM lstm{};
809 lstm.bidirectional = mindspore::lite::MindIR_LSTM_GetBidirectional(primitive);
810 lstm.hasBias = mindspore::lite::MindIR_LSTM_GetHasBias(primitive);
811 lstm.inputSize = mindspore::lite::MindIR_LSTM_GetInputSize(primitive);
812 lstm.hiddenSize = mindspore::lite::MindIR_LSTM_GetHiddenSize(primitive);
813 lstm.numLayers = mindspore::lite::MindIR_LSTM_GetNumLayers(primitive);
814 lstm.numDirections = mindspore::lite::MindIR_LSTM_GetNumDirections(primitive);
815 lstm.dropout = mindspore::lite::MindIR_LSTM_GetDropout(primitive);
816 lstm.zoneoutCell = mindspore::lite::MindIR_LSTM_GetZoneoutCell(primitive);
817 lstm.zoneoutHidden = mindspore::lite::MindIR_LSTM_GetZoneoutHidden(primitive);
818 lstm.projSize = mindspore::lite::MindIR_LSTM_GetProjSize(primitive);
819
820 OHOS::MessageParcel data;
821 (void)LSTMBlockMarshalling(data, lstm);
822 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
823 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
824 return ret;
825 }
826
ConvertL2NormalizeFusion(const PrimitivePtr primitive)827 std::vector<int8_t> ConvertL2NormalizeFusion(const PrimitivePtr primitive)
828 {
829 if (primitive == nullptr) {
830 LOGE("ConvertL2NormalizeFusion v2_1 failed, primitive is nullptr.");
831 return {};
832 }
833
834 L2NormalizeFusion l2NormalizeFusion{};
835 l2NormalizeFusion.axis = mindspore::lite::MindIR_L2NormalizeFusion_GetAxis(primitive);
836 l2NormalizeFusion.epsilon = mindspore::lite::MindIR_L2NormalizeFusion_GetEpsilon(primitive);
837 l2NormalizeFusion.activationType = static_cast<ActivationType>(
838 mindspore::lite::MindIR_L2NormalizeFusion_GetActivationType(primitive));
839
840 OHOS::MessageParcel data;
841 (void)L2NormalizeFusionBlockMarshalling(data, l2NormalizeFusion);
842 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
843 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
844 return ret;
845 }
846
ConvertMatMulFusion(const PrimitivePtr primitive)847 std::vector<int8_t> ConvertMatMulFusion(const PrimitivePtr primitive)
848 {
849 if (primitive == nullptr) {
850 LOGE("ConvertMatMulFusion v2_1 failed, primitive is nullptr.");
851 return {};
852 }
853
854 MatMulFusion matMulFusion{};
855 matMulFusion.transposeA = mindspore::lite::MindIR_MatMulFusion_GetTransposeA(primitive);
856 matMulFusion.transposeB = mindspore::lite::MindIR_MatMulFusion_GetTransposeB(primitive);
857 matMulFusion.activationType = static_cast<ActivationType>(
858 mindspore::lite::MindIR_MatMulFusion_GetActivationType(primitive));
859
860 OHOS::MessageParcel data;
861 (void)MatMulFusionBlockMarshalling(data, matMulFusion);
862 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
863 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
864 return ret;
865 }
866
ConvertMaximum(const PrimitivePtr primitive)867 std::vector<int8_t> ConvertMaximum(const PrimitivePtr primitive)
868 {
869 if (primitive == nullptr) {
870 LOGE("ConvertMaximum v2_1 failed, primitive is nullptr.");
871 return {};
872 }
873
874 Maximum maximum{};
875 OHOS::MessageParcel data;
876 (void)MaximumBlockMarshalling(data, maximum);
877 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
878 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
879 return ret;
880 }
881
ConvertMaxPoolFusion(const PrimitivePtr primitive)882 std::vector<int8_t> ConvertMaxPoolFusion(const PrimitivePtr primitive)
883 {
884 if (primitive == nullptr) {
885 LOGE("ConvertMaxPoolFusion v2_1 failed, primitive is nullptr.");
886 return {};
887 }
888
889 MaxPoolFusion maxPoolFusion{};
890 maxPoolFusion.kernelSize = mindspore::lite::MindIR_MaxPoolFusion_GetKernelSize(primitive);
891 maxPoolFusion.strides = mindspore::lite::MindIR_MaxPoolFusion_GetStrides(primitive);
892 maxPoolFusion.pad = mindspore::lite::MindIR_MaxPoolFusion_GetPad(primitive);
893 maxPoolFusion.padMode = static_cast<PadMode>(mindspore::lite::MindIR_MaxPoolFusion_GetPadMode(primitive));
894 maxPoolFusion.format = static_cast<Format>(mindspore::lite::MindIR_MaxPoolFusion_GetFormat(primitive));
895 maxPoolFusion.roundMode = static_cast<RoundMode>(mindspore::lite::MindIR_MaxPoolFusion_GetRoundMode(primitive));
896 maxPoolFusion.global = mindspore::lite::MindIR_MaxPoolFusion_GetGlobal(primitive);
897 maxPoolFusion.activationType = static_cast<ActivationType>(
898 mindspore::lite::MindIR_MaxPoolFusion_GetActivationType(primitive));
899
900 OHOS::MessageParcel data;
901 (void)MaxPoolFusionBlockMarshalling(data, maxPoolFusion);
902 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
903 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
904 return ret;
905 }
906
ConvertMinimum(const PrimitivePtr primitive)907 std::vector<int8_t> ConvertMinimum(const PrimitivePtr primitive)
908 {
909 if (primitive == nullptr) {
910 LOGE("ConvertMinimum v2_1 failed, primitive is nullptr.");
911 return {};
912 }
913
914 Minimum minimum{};
915
916 OHOS::MessageParcel data;
917 (void)MinimumBlockMarshalling(data, minimum);
918 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
919 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
920 return ret;
921 }
922
ConvertMod(const PrimitivePtr primitive)923 std::vector<int8_t> ConvertMod(const PrimitivePtr primitive)
924 {
925 if (primitive == nullptr) {
926 LOGE("ConvertMod v2_1 failed, primitive is nullptr.");
927 return {};
928 }
929
930 Mod mod{};
931
932 OHOS::MessageParcel data;
933 (void)ModBlockMarshalling(data, mod);
934 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
935 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
936 return ret;
937 }
938
ConvertMulFusion(const PrimitivePtr primitive)939 std::vector<int8_t> ConvertMulFusion(const PrimitivePtr primitive)
940 {
941 if (primitive == nullptr) {
942 LOGE("ConvertMulFusion v2_1 failed, primitive is nullptr.");
943 return {};
944 }
945
946 MulFusion mulFusion{};
947 mulFusion.activationType = static_cast<ActivationType>(
948 mindspore::lite::MindIR_MulFusion_GetActivationType(primitive));
949 OHOS::MessageParcel data;
950 (void)MulFusionBlockMarshalling(data, mulFusion);
951 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
952 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
953 return ret;
954 }
955
ConvertNeg(const PrimitivePtr primitive)956 std::vector<int8_t> ConvertNeg(const PrimitivePtr primitive)
957 {
958 if (primitive == nullptr) {
959 LOGE("ConvertNeg v2_1 failed, primitive is nullptr.");
960 return {};
961 }
962
963 Neg neg{};
964
965 OHOS::MessageParcel data;
966 (void)NegBlockMarshalling(data, neg);
967 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
968 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
969 return ret;
970 }
971
ConvertNotEqual(const PrimitivePtr primitive)972 std::vector<int8_t> ConvertNotEqual(const PrimitivePtr primitive)
973 {
974 if (primitive == nullptr) {
975 LOGE("ConvertNotEqual v2_1 failed, primitive is nullptr.");
976 return {};
977 }
978
979 NotEqual notEqual{};
980
981 OHOS::MessageParcel data;
982 (void)NotEqualBlockMarshalling(data, notEqual);
983 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
984 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
985 return ret;
986 }
987
ConvertOneHot(const PrimitivePtr primitive)988 std::vector<int8_t> ConvertOneHot(const PrimitivePtr primitive)
989 {
990 if (primitive == nullptr) {
991 LOGE("ConvertOneHot v2_1 failed, primitive is nullptr.");
992 return {};
993 }
994
995 OneHot oneHot{};
996 oneHot.axis = mindspore::lite::MindIR_OneHot_GetAxis(primitive);
997 OHOS::MessageParcel data;
998 (void)OneHotBlockMarshalling(data, oneHot);
999 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1000 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1001 return ret;
1002 }
1003
ConvertPadFusion(const PrimitivePtr primitive)1004 std::vector<int8_t> ConvertPadFusion(const PrimitivePtr primitive)
1005 {
1006 if (primitive == nullptr) {
1007 LOGE("ConvertPadFusion v2_1 failed, primitive is nullptr.");
1008 return {};
1009 }
1010
1011 PadFusion padFusion{};
1012 padFusion.paddings = mindspore::lite::MindIR_PadFusion_GetPaddings(primitive);
1013 padFusion.paddingMode = static_cast<PaddingMode>(mindspore::lite::MindIR_PadFusion_GetPaddingMode(primitive));
1014 padFusion.constantValue = mindspore::lite::MindIR_PadFusion_GetConstantValue(primitive);
1015 OHOS::MessageParcel data;
1016 (void)PadFusionBlockMarshalling(data, padFusion);
1017 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1018 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1019 return ret;
1020 }
1021
ConvertPowFusion(const PrimitivePtr primitive)1022 std::vector<int8_t> ConvertPowFusion(const PrimitivePtr primitive)
1023 {
1024 if (primitive == nullptr) {
1025 LOGE("ConvertPowFusion v2_1 failed, primitive is nullptr.");
1026 return {};
1027 }
1028
1029 PowFusion powFusion{};
1030 powFusion.scale = mindspore::lite::MindIR_PowFusion_GetScale(primitive);
1031 powFusion.shift = mindspore::lite::MindIR_PowFusion_GetShift(primitive);
1032 OHOS::MessageParcel data;
1033 (void)PowFusionBlockMarshalling(data, powFusion);
1034 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1035 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1036 return ret;
1037 }
1038
ConvertPReLUFusion(const PrimitivePtr primitive)1039 std::vector<int8_t> ConvertPReLUFusion(const PrimitivePtr primitive)
1040 {
1041 if (primitive == nullptr) {
1042 LOGE("ConvertPReLUFusion v2_1 failed, primitive is nullptr.");
1043 return {};
1044 }
1045
1046 PReLUFusion pReLUFusion{};
1047 pReLUFusion.channelShared = mindspore::lite::MindIR_PReLUFusion_GetChannelShared(primitive);
1048 OHOS::MessageParcel data;
1049 (void)PReLUFusionBlockMarshalling(data, pReLUFusion);
1050 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1051 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1052 return ret;
1053 }
1054
ConvertQuantDTypeCast(const PrimitivePtr primitive)1055 std::vector<int8_t> ConvertQuantDTypeCast(const PrimitivePtr primitive)
1056 {
1057 if (primitive == nullptr) {
1058 LOGE("ConvertQuantDTypeCast v2_1 failed, primitive is nullptr.");
1059 return {};
1060 }
1061
1062 QuantDTypeCastV2 quantDTypeCast{};
1063 quantDTypeCast.srcT = mindspore::lite::MindIR_QuantDTypeCast_GetSrcT(primitive);
1064 quantDTypeCast.dstT = mindspore::lite::MindIR_QuantDTypeCast_GetDstT(primitive);
1065 quantDTypeCast.axis = mindspore::lite::MindIR_QuantDTypeCast_GetAxis(primitive);
1066
1067 OHOS::MessageParcel data;
1068 (void)QuantDTypeCastV2BlockMarshalling(data, quantDTypeCast);
1069 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1070 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1071 return ret;
1072 }
1073
ConvertRank(const PrimitivePtr primitive)1074 std::vector<int8_t> ConvertRank(const PrimitivePtr primitive)
1075 {
1076 if (primitive == nullptr) {
1077 LOGE("ConvertRank v2_1 failed, primitive is nullptr.");
1078 return {};
1079 }
1080
1081 Rank rank{};
1082
1083 OHOS::MessageParcel data;
1084 (void)RankBlockMarshalling(data, rank);
1085 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1086 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1087 return ret;
1088 }
1089
ConvertRange(const PrimitivePtr primitive)1090 std::vector<int8_t> ConvertRange(const PrimitivePtr primitive)
1091 {
1092 if (primitive == nullptr) {
1093 LOGE("ConvertRange v2_1 failed, primitive is nullptr.");
1094 return {};
1095 }
1096
1097 Range range{};
1098 range.dataType = mindspore::lite::MindIR_Range_GetDType(primitive);
1099 range.start = mindspore::lite::MindIR_Range_GetStart(primitive);
1100 range.limit = mindspore::lite::MindIR_Range_GetLimit(primitive);
1101 range.delta = mindspore::lite::MindIR_Range_GetDelta(primitive);
1102
1103 OHOS::MessageParcel data;
1104 (void)RangeBlockMarshalling(data, range);
1105 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1106 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1107 return ret;
1108 }
1109
ConvertReciprocal(const PrimitivePtr primitive)1110 std::vector<int8_t> ConvertReciprocal(const PrimitivePtr primitive)
1111 {
1112 if (primitive == nullptr) {
1113 LOGE("ConvertReciprocal v2_1 failed, primitive is nullptr.");
1114 return {};
1115 }
1116
1117 Reciprocal reciprocal{};
1118
1119 OHOS::MessageParcel data;
1120 (void)ReciprocalBlockMarshalling(data, reciprocal);
1121 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1122 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1123 return ret;
1124 }
1125
ConvertReduceFusion(const PrimitivePtr primitive)1126 std::vector<int8_t> ConvertReduceFusion(const PrimitivePtr primitive)
1127 {
1128 if (primitive == nullptr) {
1129 LOGE("ConvertReduceFusion v2_1 failed, primitive is nullptr.");
1130 return {};
1131 }
1132
1133 ReduceFusion reduceFusion{};
1134 reduceFusion.keepDims = mindspore::lite::MindIR_ReduceFusion_GetKeepDims(primitive);
1135 reduceFusion.mode = static_cast<ReduceMode>(mindspore::lite::MindIR_ReduceFusion_GetMode(primitive));
1136 reduceFusion.reduceToEnd = mindspore::lite::MindIR_ReduceFusion_GetReduceToEnd(primitive);
1137 reduceFusion.coeff = mindspore::lite::MindIR_ReduceFusion_GetCoeff(primitive);
1138 OHOS::MessageParcel data;
1139 (void)ReduceFusionBlockMarshalling(data, reduceFusion);
1140 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1141 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1142 return ret;
1143 }
1144
ConvertReshape(const PrimitivePtr primitive)1145 std::vector<int8_t> ConvertReshape(const PrimitivePtr primitive)
1146 {
1147 if (primitive == nullptr) {
1148 LOGE("ConvertReshape v2_1 failed, primitive is nullptr.");
1149 return {};
1150 }
1151
1152 Reshape reshape{};
1153 OHOS::MessageParcel data;
1154 (void)ReshapeBlockMarshalling(data, reshape);
1155 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1156 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1157 return ret;
1158 }
1159
ConvertResize(const PrimitivePtr primitive)1160 std::vector<int8_t> ConvertResize(const PrimitivePtr primitive)
1161 {
1162 if (primitive == nullptr) {
1163 LOGE("ConvertResize v2_1 failed, primitive is nullptr.");
1164 return {};
1165 }
1166
1167 Resize resize{};
1168 resize.method = static_cast<ResizeMethod>(mindspore::lite::MindIR_Resize_GetMethod(primitive));
1169 resize.newHeight = mindspore::lite::MindIR_Resize_GetNewHeight(primitive);
1170 resize.newWidth = mindspore::lite::MindIR_Resize_GetNewWidth(primitive);
1171 resize.preserveAspectRatio = mindspore::lite::MindIR_Resize_GetPreserveAspectRatio(primitive);
1172 resize.coordinateTransformMode =
1173 static_cast<CoordinateTransformMode>(mindspore::lite::MindIR_Resize_GetCoordinateTransformMode(primitive));
1174 resize.cubicCoeff = mindspore::lite::MindIR_Resize_GetCubicCoeff(primitive);
1175 resize.excludeOutside = mindspore::lite::MindIR_Resize_GetExcludeOutside(primitive);
1176 resize.extrapolationValue = mindspore::lite::MindIR_Resize_GetExtrapolationValue(primitive);
1177 resize.nearestMode = static_cast<NearestMode>(mindspore::lite::MindIR_Resize_GetNearestMode(primitive));
1178 OHOS::MessageParcel data;
1179 (void)ResizeBlockMarshalling(data, resize);
1180 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1181 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1182 return ret;
1183 }
1184
ConvertRound(const PrimitivePtr primitive)1185 std::vector<int8_t> ConvertRound(const PrimitivePtr primitive)
1186 {
1187 if (primitive == nullptr) {
1188 LOGE("ConvertRound v2_1 failed, primitive is nullptr.");
1189 return {};
1190 }
1191
1192 Round round{};
1193
1194 OHOS::MessageParcel data;
1195 (void)RoundBlockMarshalling(data, round);
1196 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1197 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1198 return ret;
1199 }
1200
ConvertRsqrt(const PrimitivePtr primitive)1201 std::vector<int8_t> ConvertRsqrt(const PrimitivePtr primitive)
1202 {
1203 if (primitive == nullptr) {
1204 LOGE("ConvertRsqrt v2_1 failed, primitive is nullptr.");
1205 return {};
1206 }
1207
1208 Rsqrt rsqrt{};
1209 OHOS::MessageParcel data;
1210 (void)RsqrtBlockMarshalling(data, rsqrt);
1211 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1212 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1213 return ret;
1214 }
1215
ConvertScaleFusion(const PrimitivePtr primitive)1216 std::vector<int8_t> ConvertScaleFusion(const PrimitivePtr primitive)
1217 {
1218 if (primitive == nullptr) {
1219 LOGE("ConvertScaleFusion v2_1 failed, primitive is nullptr.");
1220 return {};
1221 }
1222
1223 ScaleFusion scaleFusion{};
1224 scaleFusion.axis = mindspore::lite::MindIR_ScaleFusion_GetAxis(primitive);
1225 scaleFusion.activationType = static_cast<ActivationType>(
1226 mindspore::lite::MindIR_ScaleFusion_GetActivationType(primitive));
1227 OHOS::MessageParcel data;
1228 (void)ScaleFusionBlockMarshalling(data, scaleFusion);
1229 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1230 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1231 return ret;
1232 }
1233
ConvertScatterNd(const PrimitivePtr primitive)1234 std::vector<int8_t> ConvertScatterNd(const PrimitivePtr primitive)
1235 {
1236 if (primitive == nullptr) {
1237 LOGE("ConvertScatterNd v2_1 failed, primitive is nullptr.");
1238 return {};
1239 }
1240
1241 ScatterNd scatterNd{};
1242
1243 OHOS::MessageParcel data;
1244 (void)ScatterNdBlockMarshalling(data, scatterNd);
1245 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1246 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1247 return ret;
1248 }
1249
ConvertShape(const PrimitivePtr primitive)1250 std::vector<int8_t> ConvertShape(const PrimitivePtr primitive)
1251 {
1252 if (primitive == nullptr) {
1253 LOGE("ConvertShape v2_1 failed, primitive is nullptr.");
1254 return {};
1255 }
1256
1257 Shape shape{};
1258 OHOS::MessageParcel data;
1259 (void)ShapeBlockMarshalling(data, shape);
1260 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1261 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1262 return ret;
1263 }
1264
ConvertSin(const PrimitivePtr primitive)1265 std::vector<int8_t> ConvertSin(const PrimitivePtr primitive)
1266 {
1267 if (primitive == nullptr) {
1268 LOGE("ConvertSin v2_1 failed, primitive is nullptr.");
1269 return {};
1270 }
1271
1272 Sin sin{};
1273
1274 OHOS::MessageParcel data;
1275 (void)SinBlockMarshalling(data, sin);
1276 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1277 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1278 return ret;
1279 }
1280
ConvertSliceFusion(const PrimitivePtr primitive)1281 std::vector<int8_t> ConvertSliceFusion(const PrimitivePtr primitive)
1282 {
1283 if (primitive == nullptr) {
1284 LOGE("ConvertSliceFusion v2_1 failed, primitive is nullptr.");
1285 return {};
1286 }
1287
1288 SliceFusion sliceFusion{};
1289 sliceFusion.axes = mindspore::lite::MindIR_SliceFusion_GetAxes(primitive);
1290 OHOS::MessageParcel data;
1291 (void)SliceFusionBlockMarshalling(data, sliceFusion);
1292 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1293 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1294 return ret;
1295 }
1296
ConvertSoftmax(const PrimitivePtr primitive)1297 std::vector<int8_t> ConvertSoftmax(const PrimitivePtr primitive)
1298 {
1299 if (primitive == nullptr) {
1300 LOGE("ConvertSoftmax v2_1 failed, primitive is nullptr.");
1301 return {};
1302 }
1303
1304 Softmax softmax{};
1305 softmax.axis = mindspore::lite::MindIR_Softmax_GetAxis(primitive);
1306 OHOS::MessageParcel data;
1307 (void)SoftmaxBlockMarshalling(data, softmax);
1308 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1309 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1310 return ret;
1311 }
1312
ConvertSpaceToBatchND(const PrimitivePtr primitive)1313 std::vector<int8_t> ConvertSpaceToBatchND(const PrimitivePtr primitive)
1314 {
1315 if (primitive == nullptr) {
1316 LOGE("ConvertSpaceToBatchND v2_1 failed, primitive is nullptr.");
1317 return {};
1318 }
1319
1320 SpaceToBatchND spaceToBatchND{};
1321 spaceToBatchND.blockShape = mindspore::lite::MindIR_SpaceToBatchND_GetBlockShape(primitive);
1322 spaceToBatchND.paddings = mindspore::lite::MindIR_SpaceToBatchND_GetPaddings(primitive);
1323 OHOS::MessageParcel data;
1324 (void)SpaceToBatchNDBlockMarshalling(data, spaceToBatchND);
1325 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1326 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1327 return ret;
1328 }
1329
ConvertSpaceToDepth(const PrimitivePtr primitive)1330 std::vector<int8_t> ConvertSpaceToDepth(const PrimitivePtr primitive)
1331 {
1332 if (primitive == nullptr) {
1333 LOGE("ConvertSpaceToDepth v2_1 failed, primitive is nullptr.");
1334 return {};
1335 }
1336
1337 SpaceToDepth spaceToDepth{};
1338 spaceToDepth.format = static_cast<Format>(mindspore::lite::MindIR_SpaceToDepth_GetFormat(primitive));
1339 spaceToDepth.blockSize = mindspore::lite::MindIR_SpaceToDepth_GetBlockSize(primitive);
1340
1341 OHOS::MessageParcel data;
1342 (void)SpaceToDepthBlockMarshalling(data, spaceToDepth);
1343 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1344 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1345 return ret;
1346 }
1347
ConvertSparseToDense(const PrimitivePtr primitive)1348 std::vector<int8_t> ConvertSparseToDense(const PrimitivePtr primitive)
1349 {
1350 if (primitive == nullptr) {
1351 LOGE("ConvertSparseToDense v2_1 failed, primitive is nullptr.");
1352 return {};
1353 }
1354
1355 SparseToDense sparseToDense{};
1356 OHOS::MessageParcel data;
1357 (void)SparseToDenseBlockMarshalling(data, sparseToDense);
1358 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1359 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1360 return ret;
1361 }
1362
ConvertSplit(const PrimitivePtr primitive)1363 std::vector<int8_t> ConvertSplit(const PrimitivePtr primitive)
1364 {
1365 if (primitive == nullptr) {
1366 LOGE("ConvertSplit v2_1 failed, primitive is nullptr.");
1367 return {};
1368 }
1369
1370 Split split{};
1371 split.outputNum = mindspore::lite::MindIR_Split_GetOutputNum(primitive);
1372 split.sizeSplits = mindspore::lite::MindIR_Split_GetSizeSplits(primitive);
1373 split.axis = mindspore::lite::MindIR_Split_GetAxis(primitive);
1374 OHOS::MessageParcel data;
1375 (void)SplitBlockMarshalling(data, split);
1376 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1377 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1378 return ret;
1379 }
1380
ConvertSqrt(const PrimitivePtr primitive)1381 std::vector<int8_t> ConvertSqrt(const PrimitivePtr primitive)
1382 {
1383 if (primitive == nullptr) {
1384 LOGE("ConvertSqrt v2_1 failed, primitive is nullptr.");
1385 return {};
1386 }
1387
1388 Sqrt sqrt{};
1389 OHOS::MessageParcel data;
1390 (void)SqrtBlockMarshalling(data, sqrt);
1391 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1392 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1393 return ret;
1394 }
1395
ConvertSquare(const PrimitivePtr primitive)1396 std::vector<int8_t> ConvertSquare(const PrimitivePtr primitive)
1397 {
1398 if (primitive == nullptr) {
1399 LOGE("ConvertSquare v2_1 failed, primitive is nullptr.");
1400 return {};
1401 }
1402
1403 Square square{};
1404 OHOS::MessageParcel data;
1405 (void)SquareBlockMarshalling(data, square);
1406 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1407 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1408 return ret;
1409 }
1410
ConvertSquaredDifference(const PrimitivePtr primitive)1411 std::vector<int8_t> ConvertSquaredDifference(const PrimitivePtr primitive)
1412 {
1413 if (primitive == nullptr) {
1414 LOGE("ConvertSquaredDifference v2_1 failed, primitive is nullptr.");
1415 return {};
1416 }
1417
1418 SquaredDifference squaredDifference{};
1419 OHOS::MessageParcel data;
1420 (void)SquaredDifferenceBlockMarshalling(data, squaredDifference);
1421 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1422 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1423 return ret;
1424 }
1425
ConvertSqueeze(const PrimitivePtr primitive)1426 std::vector<int8_t> ConvertSqueeze(const PrimitivePtr primitive)
1427 {
1428 if (primitive == nullptr) {
1429 LOGE("ConvertSqueeze v2_1 failed, primitive is nullptr.");
1430 return {};
1431 }
1432
1433 Squeeze squeeze{};
1434 squeeze.axis = mindspore::lite::MindIR_Squeeze_GetAxis(primitive);
1435 OHOS::MessageParcel data;
1436 (void)SqueezeBlockMarshalling(data, squeeze);
1437 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1438 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1439 return ret;
1440 }
1441
ConvertStack(const PrimitivePtr primitive)1442 std::vector<int8_t> ConvertStack(const PrimitivePtr primitive)
1443 {
1444 if (primitive == nullptr) {
1445 LOGE("ConvertStack v2_1 failed, primitive is nullptr.");
1446 return {};
1447 }
1448
1449 Stack stack{};
1450 stack.axis = mindspore::lite::MindIR_Stack_GetAxis(primitive);
1451 OHOS::MessageParcel data;
1452 (void)StackBlockMarshalling(data, stack);
1453 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1454 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1455 return ret;
1456 }
1457
ConvertStridedSlice(const PrimitivePtr primitive)1458 std::vector<int8_t> ConvertStridedSlice(const PrimitivePtr primitive)
1459 {
1460 if (primitive == nullptr) {
1461 LOGE("ConvertStridedSlice v2_1 failed, primitive is nullptr.");
1462 return {};
1463 }
1464
1465 StridedSlice stridedSlice{};
1466 stridedSlice.beginMask = mindspore::lite::MindIR_StridedSlice_GetBeginMask(primitive);
1467 stridedSlice.endMask = mindspore::lite::MindIR_StridedSlice_GetEndMask(primitive);
1468 stridedSlice.ellipsisMask = mindspore::lite::MindIR_StridedSlice_GetEllipsisMask(primitive);
1469 stridedSlice.newAxisMask = mindspore::lite::MindIR_StridedSlice_GetNewAxisMask(primitive);
1470 stridedSlice.shrinkAxisMask = mindspore::lite::MindIR_StridedSlice_GetShrinkAxisMask(primitive);
1471 OHOS::MessageParcel data;
1472 (void)StridedSliceBlockMarshalling(data, stridedSlice);
1473 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1474 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1475 return ret;
1476 }
1477
ConvertSubFusion(const PrimitivePtr primitive)1478 std::vector<int8_t> ConvertSubFusion(const PrimitivePtr primitive)
1479 {
1480 if (primitive == nullptr) {
1481 LOGE("ConvertSubFusion v2_1 failed, primitive is nullptr.");
1482 return {};
1483 }
1484
1485 SubFusion subFusion{};
1486 subFusion.activationType = static_cast<ActivationType>(
1487 mindspore::lite::MindIR_SubFusion_GetActivationType(primitive));
1488 OHOS::MessageParcel data;
1489 (void)SubFusionBlockMarshalling(data, subFusion);
1490 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1491 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1492 return ret;
1493 }
1494
ConvertTileFusion(const PrimitivePtr primitive)1495 std::vector<int8_t> ConvertTileFusion(const PrimitivePtr primitive)
1496 {
1497 if (primitive == nullptr) {
1498 LOGE("ConvertTileFusion v2_1 failed, primitive is nullptr.");
1499 return {};
1500 }
1501
1502 TileFusion tileFusion{};
1503 tileFusion.dims = mindspore::lite::MindIR_TileFusion_GetDims(primitive);
1504 OHOS::MessageParcel data;
1505 (void)TileFusionBlockMarshalling(data, tileFusion);
1506 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1507 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1508 return ret;
1509 }
1510
ConvertTopKFusion(const PrimitivePtr primitive)1511 std::vector<int8_t> ConvertTopKFusion(const PrimitivePtr primitive)
1512 {
1513 if (primitive == nullptr) {
1514 LOGE("ConvertTopKFusion v2_1 failed, primitive is nullptr.");
1515 return {};
1516 }
1517
1518 TopKFusion topKFusion{};
1519 topKFusion.sorted = mindspore::lite::MindIR_TopKFusion_GetSorted(primitive);
1520 topKFusion.axis = mindspore::lite::MindIR_TopKFusion_GetAxis(primitive);
1521 OHOS::MessageParcel data;
1522 (void)TopKFusionBlockMarshalling(data, topKFusion);
1523 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1524 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1525 return ret;
1526 }
1527
ConvertTranspose(const PrimitivePtr primitive)1528 std::vector<int8_t> ConvertTranspose(const PrimitivePtr primitive)
1529 {
1530 if (primitive == nullptr) {
1531 LOGE("ConvertTranspose v2_1 failed, primitive is nullptr.");
1532 return {};
1533 }
1534
1535 Transpose transpose{};
1536 OHOS::MessageParcel data;
1537 (void)TransposeBlockMarshalling(data, transpose);
1538 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1539 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1540 return ret;
1541 }
1542
ConvertUnsqueeze(const PrimitivePtr primitive)1543 std::vector<int8_t> ConvertUnsqueeze(const PrimitivePtr primitive)
1544 {
1545 if (primitive == nullptr) {
1546 LOGE("ConvertUnsqueeze v2_1 failed, primitive is nullptr.");
1547 return {};
1548 }
1549
1550 Unsqueeze unsqueeze{};
1551 unsqueeze.axis = mindspore::lite::MindIR_Unsqueeze_GetAxis(primitive);
1552 OHOS::MessageParcel data;
1553 (void)UnsqueezeBlockMarshalling(data, unsqueeze);
1554 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1555 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1556 return ret;
1557 }
1558
ConvertUnstack(const PrimitivePtr primitive)1559 std::vector<int8_t> ConvertUnstack(const PrimitivePtr primitive)
1560 {
1561 if (primitive == nullptr) {
1562 LOGE("ConvertUnstack v2_1 failed, primitive is nullptr.");
1563 return {};
1564 }
1565
1566 Unstack unstack{};
1567 unstack.axis = mindspore::lite::MindIR_Unstack_GetAxis(primitive);
1568
1569 OHOS::MessageParcel data;
1570 (void)UnstackBlockMarshalling(data, unstack);
1571 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1572 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1573 return ret;
1574 }
1575
ConvertWhere(const PrimitivePtr primitive)1576 std::vector<int8_t> ConvertWhere(const PrimitivePtr primitive)
1577 {
1578 if (primitive == nullptr) {
1579 LOGE("ConvertWhere v2_1 failed, primitive is nullptr.");
1580 return {};
1581 }
1582
1583 Where where{};
1584
1585 OHOS::MessageParcel data;
1586 (void)WhereBlockMarshalling(data, where);
1587 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1588 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1589 return ret;
1590 }
1591
ConvertSelect(const PrimitivePtr primitive)1592 std::vector<int8_t> ConvertSelect(const PrimitivePtr primitive)
1593 {
1594 if (primitive == nullptr) {
1595 LOGE("ConvertSelect v2_1 failed, primitive is nullptr.");
1596 return {};
1597 }
1598
1599 Select select{};
1600
1601 OHOS::MessageParcel data;
1602 (void)SelectBlockMarshalling(data, select);
1603 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1604 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1605 return ret;
1606 }
1607
ConvertErf(const PrimitivePtr primitive)1608 std::vector<int8_t> ConvertErf(const PrimitivePtr primitive)
1609 {
1610 if (primitive == nullptr) {
1611 LOGE("ConvertErf v2_1 failed, primitive is nullptr.");
1612 return {};
1613 }
1614
1615 Erf erf{};
1616
1617 OHOS::MessageParcel data;
1618 (void)ErfBlockMarshalling(data, erf);
1619 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1620 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1621 return ret;
1622 }
1623
ConvertLogSoftmax(const PrimitivePtr primitive)1624 std::vector<int8_t> ConvertLogSoftmax(const PrimitivePtr primitive)
1625 {
1626 if (primitive == nullptr) {
1627 LOGE("ConvertLogSoftmax v2_1 failed, primitive is nullptr.");
1628 return {};
1629 }
1630
1631 LogSoftmax logSoftmax{};
1632 logSoftmax.axis = mindspore::lite::MindIR_LogSoftmax_GetAxis(primitive);
1633
1634 OHOS::MessageParcel data;
1635 (void)LogSoftmaxBlockMarshalling(data, logSoftmax);
1636 std::vector<int8_t> ret(reinterpret_cast<const int8_t *>(data.GetData()),
1637 reinterpret_cast<const int8_t *>(data.GetData()) + data.GetDataSize());
1638 return ret;
1639 }
1640
1641 std::unordered_map<NodeType, std::vector<int8_t>(*)(const PrimitivePtr)> convertOpMap = {
1642 {NODE_TYPE_ACTIVATION, &ConvertActivation},
1643 {NODE_TYPE_ADD_FUSION, &ConvertAddFusion},
1644 {NODE_TYPE_ALL, &ConvertAll},
1645 {NODE_TYPE_ARGMAX_FUSION, &ConvertArgMaxFusion},
1646 {NODE_TYPE_ASSERT, &ConvertAssert},
1647 {NODE_TYPE_AVGPOOL_FUSION, &ConvertAvgPoolFusion},
1648 {NODE_TYPE_BATCH_TO_SPACE_ND, &ConvertBatchToSpaceND},
1649 {NODE_TYPE_BIAS_ADD, &ConvertBiasAdd},
1650 {NODE_TYPE_BROADCAST_TO, &ConvertBroadcastTo},
1651 {NODE_TYPE_CAST, &ConvertCast},
1652 {NODE_TYPE_CEIL, &ConvertCeil},
1653 {NODE_TYPE_CLIP, &ConvertClip},
1654 {NODE_TYPE_CONCAT, &ConvertConcat},
1655 {NODE_TYPE_CONV2D_FUSION, &ConvertConv2DFusion},
1656 {NODE_TYPE_CONV2D_TRANSPOSE_FUSION, &ConvertConv2dTransposeFusion},
1657 {NODE_TYPE_COS, &ConvertCos},
1658 {NODE_TYPE_CONSTANT_OF_SHAPE, &ConvertConstantOfShape},
1659 {NODE_TYPE_CROP, &ConvertCrop},
1660 {NODE_TYPE_DEPTH_TO_SPACE, &ConvertDepthToSpace},
1661 {NODE_TYPE_DETECTION_POST_PROCESS, &ConvertDetectionPostProcess},
1662 {NODE_TYPE_DIV_FUSION, &ConvertDivFusion},
1663 {NODE_TYPE_ELTWISE, &ConvertEltwise},
1664 {NODE_TYPE_EQUAL, &ConvertEqual},
1665 {NODE_TYPE_EXPFUSION, &ConvertExpFusion},
1666 {NODE_TYPE_EXPAND_DIMS, &ConvertExpandDims},
1667 {NODE_TYPE_FLATTEN, &ConvertFlatten},
1668 {NODE_TYPE_FLOOR, &ConvertFloor},
1669 {NODE_TYPE_FILL, &ConvertFill},
1670 {NODE_TYPE_FULL_CONNECTION, &ConvertFullConnection},
1671 {NODE_TYPE_FUSED_BATCH_NORM, &ConvertFusedBatchNorm},
1672 {NODE_TYPE_GATHER, &ConvertGather},
1673 {NODE_TYPE_GATHER_ND, &ConvertGatherNd},
1674 {NODE_TYPE_GREATER, &ConvertGreater},
1675 {NODE_TYPE_GREATER_EQUAL, &ConvertGreaterEqual},
1676 {NODE_TYPE_INSTANCE_NORM, &ConvertInstanceNorm},
1677 {NODE_TYPE_LAYER_NORM_FUSION, &ConvertLayerNormFusion},
1678 {NODE_TYPE_LESS, &ConvertLess},
1679 {NODE_TYPE_LESS_EQUAL, &ConvertLessEqual},
1680 {NODE_TYPE_LOG, &ConvertLog},
1681 {NODE_TYPE_LOGICAL_AND, &ConvertLogicalAnd},
1682 {NODE_TYPE_LOGICAL_NOT, &ConvertLogicalNot},
1683 {NODE_TYPE_LOGICAL_OR, &ConvertLogicalOr},
1684 {NODE_TYPE_LRN, &ConvertLRN},
1685 {NODE_TYPE_LSTM, &ConvertLSTM},
1686 {NODE_TYPE_L2_NORMALIZE_FUSION, &ConvertL2NormalizeFusion},
1687 {NODE_TYPE_MATMUL_FUSION, &ConvertMatMulFusion},
1688 {NODE_TYPE_MAXIMUM, &ConvertMaximum},
1689 {NODE_TYPE_MAX_POOL_FUSION, &ConvertMaxPoolFusion},
1690 {NODE_TYPE_MINIMUM, &ConvertMinimum},
1691 {NODE_TYPE_MOD, &ConvertMod},
1692 {NODE_TYPE_MUL_FUSION, &ConvertMulFusion},
1693 {NODE_TYPE_NEG, &ConvertNeg},
1694 {NODE_TYPE_NOT_EQUAL, &ConvertNotEqual},
1695 {NODE_TYPE_ONE_HOT, &ConvertOneHot},
1696 {NODE_TYPE_PAD_FUSION, &ConvertPadFusion},
1697 {NODE_TYPE_POW_FUSION, &ConvertPowFusion},
1698 {NODE_TYPE_PRELU_FUSION, &ConvertPReLUFusion},
1699 {NODE_TYPE_QUANT_DTYPE_CAST, &ConvertQuantDTypeCast},
1700 {NODE_TYPE_RANK, &ConvertRank},
1701 {NODE_TYPE_RANGE, &ConvertRange},
1702 {NODE_TYPE_RECIPROCAL, &ConvertReciprocal},
1703 {NODE_TYPE_REDUCE_FUSION, &ConvertReduceFusion},
1704 {NODE_TYPE_RESHAPE, &ConvertReshape},
1705 {NODE_TYPE_RESIZE, &ConvertResize},
1706 {NODE_TYPE_ROUND, &ConvertRound},
1707 {NODE_TYPE_RSQRT, &ConvertRsqrt},
1708 {NODE_TYPE_SCALE_FUSION, &ConvertScaleFusion},
1709 {NODE_TYPE_SCATTER_ND, &ConvertScatterNd},
1710 {NODE_TYPE_SHAPE, &ConvertShape},
1711 {NODE_TYPE_SIN, &ConvertSin},
1712 {NODE_TYPE_SLICE_FUSION, &ConvertSliceFusion},
1713 {NODE_TYPE_SOFTMAX, &ConvertSoftmax},
1714 {NODE_TYPE_SPACE_TO_BATCH_ND, &ConvertSpaceToBatchND},
1715 {NODE_TYPE_SPACE_TO_DEPTH, &ConvertSpaceToDepth},
1716 {NODE_TYPE_SPARSE_TO_DENSE, &ConvertSparseToDense},
1717 {NODE_TYPE_SPLIT, &ConvertSplit},
1718 {NODE_TYPE_SQRT, &ConvertSqrt},
1719 {NODE_TYPE_SQUARED_DIFFERENCE, &ConvertSquaredDifference},
1720 {NODE_TYPE_SQUEEZE, &ConvertSqueeze},
1721 {NODE_TYPE_SQUARE, &ConvertSquare},
1722 {NODE_TYPE_STACK, &ConvertStack},
1723 {NODE_TYPE_STRIDED_SLICE, &ConvertStridedSlice},
1724 {NODE_TYPE_SUB_FUSION, &ConvertSubFusion},
1725 {NODE_TYPE_TILE_FUSION, &ConvertTileFusion},
1726 {NODE_TYPE_TOPK_FUSION, &ConvertTopKFusion},
1727 {NODE_TYPE_TRANSPOSE, &ConvertTranspose},
1728 {NODE_TYPE_UNSQUEEZE, &ConvertUnsqueeze},
1729 {NODE_TYPE_UNSTACK, &ConvertUnstack},
1730 {NODE_TYPE_WHERE, &ConvertWhere},
1731 {NODE_TYPE_SELECT, &ConvertSelect},
1732 {NODE_TYPE_ERF, &ConvertErf},
1733 {NODE_TYPE_LOG_SOFTMAX, &ConvertLogSoftmax}};
1734
Convert(OHOS::HDI::Nnrt::V2_1::NodeType type,const PrimitivePtr primitive)1735 std::vector<int8_t> Convert(OHOS::HDI::Nnrt::V2_1::NodeType type, const PrimitivePtr primitive)
1736 {
1737 if (convertOpMap.find(type) != convertOpMap.end()) {
1738 return convertOpMap[type](primitive);
1739 }
1740 LOGE("MindIR_LiteGraph_To_Model v2_1 failed, nodeType invalid, type =%d", type);
1741 return {};
1742 }
1743
MindIR_Tensor_GetQuantParams_OHOS(TensorPtr tensor)1744 inline std::vector<OHOS::HDI::Nnrt::V2_1::QuantParam> MindIR_Tensor_GetQuantParams_OHOS(TensorPtr tensor)
1745 {
1746 if (tensor != nullptr) {
1747 std::vector<OHOS::HDI::Nnrt::V2_1::QuantParam> result;
1748 auto src = mindspore::lite::MindIR_Tensor_GetQuantParams(tensor);
1749 if (src.empty()) {
1750 return {};
1751 }
1752 size_t size = src.size();
1753 for (size_t i = 0; i < size; i++) {
1754 OHOS::HDI::Nnrt::V2_1::QuantParam quantParam{src[i].numBits, src[i].zeroPoint, src[i].scale};
1755 result.emplace_back(quantParam);
1756 }
1757 return result;
1758 } else {
1759 return {};
1760 }
1761 }
1762
HDIModel_Destroy(OHOS::HDI::Nnrt::V2_1::Model ** model)1763 void HDIModel_Destroy(OHOS::HDI::Nnrt::V2_1::Model **model)
1764 {
1765 if (model != nullptr && *model != nullptr) {
1766 auto modelData = *model;
1767 delete (modelData);
1768 *model = nullptr;
1769 }
1770 }
1771
Copy_MindIR_Tensor_Data_To_HDIBuffer(const TensorPtr tensor,const OHOS::HDI::Nnrt::V2_1::SharedBuffer & bufferTemplete,uint8_t * mmapPtr,unsigned int offset)1772 OHOS::HDI::Nnrt::V2_1::SharedBuffer Copy_MindIR_Tensor_Data_To_HDIBuffer(const TensorPtr tensor,
1773 const OHOS::HDI::Nnrt::V2_1::SharedBuffer &bufferTemplete, uint8_t *mmapPtr, unsigned int offset)
1774 {
1775 if (tensor == nullptr) {
1776 LOGE("");
1777 return {-1, 0, offset, 0};
1778 }
1779 if (mmapPtr == nullptr) {
1780 LOGE("Tensor GetData failed, mmap pointer should not be nullptr");
1781 return {-1, 0, offset, 0};
1782 }
1783
1784 OHOS::HDI::Nnrt::V2_1::SharedBuffer result{};
1785 std::vector<uint8_t> data = mindspore::lite::MindIR_Tensor_GetData(tensor);
1786 if (data.empty()) {
1787 result.fd = -1;
1788 result.bufferSize = bufferTemplete.bufferSize;
1789 result.offset = offset;
1790 result.dataSize = 0;
1791 return result;
1792 }
1793 result.fd = bufferTemplete.fd;
1794 result.bufferSize = bufferTemplete.bufferSize;
1795 auto ret = memcpy_s(mmapPtr + offset, data.size(), data.data(), data.size());
1796 if (ret != EOK) {
1797 LOGE("Tensor memcpy failed.");
1798 return {-1, 0, offset, 0};
1799 }
1800 result.offset = offset;
1801 result.dataSize = data.size();
1802 return result;
1803 }
1804
LiteGraph_To_HDIModel(const mindspore::lite::LiteGraph * liteGraph,const OHOS::HDI::Nnrt::V2_1::SharedBuffer & buffer)1805 OHOS::HDI::Nnrt::V2_1::Model *LiteGraph_To_HDIModel(const mindspore::lite::LiteGraph *liteGraph,
1806 const OHOS::HDI::Nnrt::V2_1::SharedBuffer &buffer)
1807 {
1808 if (liteGraph == nullptr) {
1809 LOGE("MindIR_LiteGraph_To_Model v2_1 failed, lite graph is nullptr.");
1810 return nullptr;
1811 }
1812
1813 LOGI("MindIR_LiteGraph_To_Model begin");
1814
1815 std::vector<OHOS::HDI::Nnrt::V2_1::Node> nodes;
1816 std::vector<OHOS::HDI::Nnrt::V2_1::Tensor> allTensors;
1817 std::vector<OHOS::HDI::Nnrt::V2_1::SubGraph> subGraph;
1818
1819 // nodes
1820 for (auto node : liteGraph->all_nodes_) {
1821 if (node == nullptr) {
1822 LOGE("MindIR_LiteGraph_To_Model v2_1 failed, node is nullptr.");
1823 return nullptr;
1824 }
1825 OHOS::HDI::Nnrt::V2_1::Node tmp;
1826 tmp.name = node->name_;
1827 if (node->primitive_ == nullptr) {
1828 LOGE("MindIR_LiteGraph_To_Model v2_1 failed, node primitive is nullptr.");
1829 return nullptr;
1830 }
1831 tmp.nodeType = static_cast<OHOS::HDI::Nnrt::V2_1::NodeType>(
1832 mindspore::lite::MindIR_Primitive_GetType(node->primitive_));
1833 tmp.nodeAttr = Convert(tmp.nodeType, node->primitive_);
1834 tmp.inputIndex = node->input_indices_;
1835 tmp.outputIndex = node->output_indices_;
1836 tmp.quantType = static_cast<QuantType>(node->quant_type_);
1837 nodes.emplace_back(tmp);
1838 }
1839
1840 // Tensor
1841 unsigned int tensorBufferOffset = 0;
1842 uint8_t *mmapPtr = nullptr;
1843 if (buffer.fd != -1) {
1844 mmapPtr =
1845 static_cast<uint8_t *>(mmap(nullptr, buffer.bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, buffer.fd, 0));
1846 if (mmapPtr == MAP_FAILED) {
1847 LOGE("MindIR_LiteGraph_To_Model v2_1 failed, mmap failed.");
1848 return nullptr;
1849 }
1850 }
1851 for (auto tensor : liteGraph->all_tensors_) {
1852 OHOS::HDI::Nnrt::V2_1::Tensor tmp;
1853 tmp.name = mindspore::lite::MindIR_Tensor_GetName(tensor);
1854 tmp.dataType = static_cast<DataType>(mindspore::lite::MindIR_Tensor_GetDataType(tensor));
1855 tmp.dims = mindspore::lite::MindIR_Tensor_GetDims(tensor);
1856 tmp.format = static_cast<Format>(mindspore::lite::MindIR_Tensor_GetFormat(tensor));
1857 tmp.data = Copy_MindIR_Tensor_Data_To_HDIBuffer(tensor, buffer, mmapPtr, tensorBufferOffset);
1858 tmp.quantParams = MindIR_Tensor_GetQuantParams_OHOS(tensor);
1859 allTensors.emplace_back(tmp);
1860 tensorBufferOffset = tmp.data.offset + tmp.data.dataSize;
1861 }
1862 if (buffer.fd != -1) {
1863 auto munmapRes = munmap(mmapPtr, buffer.bufferSize);
1864 if (munmapRes != 0) {
1865 LOGE("MindIR_LiteGraph_To_Model v2_1 failed, unmap failed.");
1866 return nullptr;
1867 }
1868 }
1869
1870 // SubGraph
1871 for (auto graph : liteGraph->sub_graphs_) {
1872 OHOS::HDI::Nnrt::V2_1::SubGraph tmp;
1873 tmp.name = graph->name_;
1874 tmp.inputIndices = std::vector<uint32_t>(graph->input_indices_);
1875 tmp.outputIndices = std::vector<uint32_t>(graph->output_indices_);
1876 tmp.nodeIndices = std::vector<uint32_t>(graph->node_indices_);
1877 subGraph.emplace_back(tmp);
1878 }
1879
1880 auto *retModel = new (std::nothrow) OHOS::HDI::Nnrt::V2_1::Model();
1881 if (retModel == nullptr) {
1882 LOGE("MindIR_LiteGraph_To_Model v2_1 failed, new Model failed.");
1883 return nullptr;
1884 }
1885 retModel->name = liteGraph->name_;
1886 retModel->inputIndex = liteGraph->input_indices_;
1887 retModel->outputIndex = liteGraph->output_indices_;
1888 retModel->nodes = nodes;
1889 retModel->allTensors = allTensors;
1890 retModel->subGraph = subGraph;
1891 return retModel;
1892 }
1893 } // NNRt_V2_1
1894 } // NeuralNetworkRuntime
1895 } // OHOS