1 /**
2 * Copyright 2020 Huawei Technologies Co., Ltd
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "common/common_test.h"
18 #include "schema/inner/model_generated.h"
19 #include "src/lite_session.h"
20 #include "src/sub_graph_kernel.h"
21 #include "ir/dtype/type_id.h"
22 #include "include/version.h"
23 #include "include/model.h"
24 #include "include/api/model.h"
25 #include "src/cxx_api/converters.h"
26 #include "src/cxx_api/model/model_impl.h"
27
28 using mindspore::kernel::KernelKey;
29 using mindspore::kernel::LiteKernel;
30 using mindspore::lite::InnerContext;
31 using mindspore::lite::LiteSession;
32 using mindspore::lite::Tensor;
33 using mindspore::TypeId::kNumberTypeFloat32;
34
35 class MultipleDeviceTest : public mindspore::CommonTest {
36 public:
37 MultipleDeviceTest() = default;
38 };
39
CreateMultyModel1(mindspore::schema::MetaGraphT * meta_graph)40 void CreateMultyModel1(mindspore::schema::MetaGraphT *meta_graph) {
41 meta_graph->name = "graph";
42 meta_graph->version = mindspore::lite::Version();
43
44 /* CPU GPU NPU support*/
45 auto cos = std::make_unique<mindspore::schema::CNodeT>();
46 cos->inputIndex = {0};
47 cos->outputIndex = {1};
48 cos->primitive = std::make_unique<mindspore::schema::PrimitiveT>();
49 cos->primitive->value.type = mindspore::schema::PrimitiveType_Cos;
50 auto cos_primitive = new mindspore::schema::CosT;
51 cos->primitive->value.value = cos_primitive;
52 cos->name = "cos";
53
54 /* CPU GPU support */
55 auto exp = std::make_unique<mindspore::schema::CNodeT>();
56 exp->inputIndex = {1};
57 exp->outputIndex = {2};
58 exp->primitive = std::make_unique<mindspore::schema::PrimitiveT>();
59 exp->primitive->value.type = mindspore::schema::PrimitiveType_ExpFusion;
60 auto exp_primitive = new mindspore::schema::ExpFusionT;
61 exp->primitive->value.value = exp_primitive;
62 exp->name = "exp";
63
64 /* CPU support */
65 auto where = std::make_unique<mindspore::schema::CNodeT>();
66 where->inputIndex = {2, 5, 6};
67 where->outputIndex = {3};
68 where->primitive = std::make_unique<mindspore::schema::PrimitiveT>();
69 where->primitive->value.type = mindspore::schema::PrimitiveType_Where;
70 auto where_primitive = new mindspore::schema::WhereT;
71 where->primitive->value.value = where_primitive;
72 where->name = "where";
73
74 /* CPU NPU GPU support */
75 auto sin = std::make_unique<mindspore::schema::CNodeT>();
76 sin->inputIndex = {3};
77 sin->outputIndex = {4};
78 sin->primitive = std::make_unique<mindspore::schema::PrimitiveT>();
79 sin->primitive->value.type = mindspore::schema::PrimitiveType_Sin;
80 auto sin_primitive = new mindspore::schema::SinT;
81 sin->primitive->value.value = sin_primitive;
82 sin->name = "sin";
83
84 /* tensors */
85 auto tensor0 = std::make_unique<mindspore::schema::TensorT>();
86 tensor0->nodeType = mindspore::lite::NodeType_ValueNode;
87 tensor0->format = mindspore::schema::Format_NHWC;
88 tensor0->dataType = mindspore::TypeId::kNumberTypeFloat32;
89 tensor0->dims = {1, 1, 1, 1};
90 tensor0->offset = -1;
91 tensor0->name = "tensor0";
92
93 auto tensor1 = std::make_unique<mindspore::schema::TensorT>();
94 tensor1->nodeType = mindspore::lite::NodeType_ValueNode;
95 tensor1->format = mindspore::schema::Format_NHWC;
96 tensor1->dataType = mindspore::TypeId::kNumberTypeFloat32;
97 tensor1->dims = {1, 1, 1, 1};
98 tensor1->offset = -1;
99 tensor1->name = "tensor1";
100
101 auto tensor2 = std::make_unique<mindspore::schema::TensorT>();
102 tensor2->nodeType = mindspore::lite::NodeType_ValueNode;
103 tensor2->format = mindspore::schema::Format_NHWC;
104 tensor2->dataType = mindspore::TypeId::kNumberTypeFloat32;
105 tensor2->dims = {1, 1, 1, 1};
106 tensor2->offset = -1;
107 tensor2->name = "tensor2";
108
109 auto tensor3 = std::make_unique<mindspore::schema::TensorT>();
110 tensor3->nodeType = mindspore::lite::NodeType_ValueNode;
111 tensor3->format = mindspore::schema::Format_NHWC;
112 tensor3->dataType = mindspore::TypeId::kNumberTypeFloat32;
113 tensor3->dims = {1, 1, 1, 1};
114 tensor3->offset = -1;
115 tensor3->name = "tensor3";
116
117 auto tensor4 = std::make_unique<mindspore::schema::TensorT>();
118 tensor4->nodeType = mindspore::lite::NodeType_ValueNode;
119 tensor4->format = mindspore::schema::Format_NHWC;
120 tensor4->dataType = mindspore::TypeId::kNumberTypeFloat32;
121 tensor4->dims = {1, 1, 1, 1};
122 tensor4->offset = -1;
123 tensor4->name = "tensor4";
124
125 auto tensor5 = std::make_unique<mindspore::schema::TensorT>();
126 tensor5->nodeType = mindspore::lite::NodeType_ValueNode;
127 tensor5->format = mindspore::schema::Format_NHWC;
128 tensor5->dataType = mindspore::TypeId::kNumberTypeFloat32;
129 tensor5->data.resize(4 * sizeof(float));
130 std::vector<float> t5 = {1.0, 2.0, 3.0, 4.0};
131 memcpy(tensor5->data.data(), t5.data(), 4 * sizeof(float));
132 tensor5->data.resize(4 * sizeof(float));
133 tensor5->dims = {1, 2, 2, 1};
134 tensor5->offset = -1;
135 tensor5->name = "tensor5";
136
137 auto tensor6 = std::make_unique<mindspore::schema::TensorT>();
138 tensor6->nodeType = mindspore::lite::NodeType_ValueNode;
139 tensor6->format = mindspore::schema::Format_NHWC;
140 tensor6->dataType = mindspore::TypeId::kNumberTypeFloat32;
141 tensor6->data.resize(4 * sizeof(float));
142 std::vector<float> t6 = {1.0, 2.0, 3.0, 4.0};
143 memcpy(tensor6->data.data(), t6.data(), 4 * sizeof(float));
144 tensor6->dims = {1, 2, 2, 1};
145 tensor6->offset = -1;
146 tensor6->name = "tensor6";
147
148 meta_graph->nodes.emplace_back(std::move(cos));
149 meta_graph->nodes.emplace_back(std::move(exp));
150 meta_graph->nodes.emplace_back(std::move(where));
151 meta_graph->nodes.emplace_back(std::move(sin));
152
153 meta_graph->allTensors.emplace_back(std::move(tensor0));
154 meta_graph->allTensors.emplace_back(std::move(tensor1));
155 meta_graph->allTensors.emplace_back(std::move(tensor2));
156 meta_graph->allTensors.emplace_back(std::move(tensor3));
157 meta_graph->allTensors.emplace_back(std::move(tensor4));
158 meta_graph->allTensors.emplace_back(std::move(tensor5));
159 meta_graph->allTensors.emplace_back(std::move(tensor6));
160
161 meta_graph->inputIndex = {0};
162 meta_graph->outputIndex = {4};
163 }
164
CreateMultyModel2(mindspore::schema::MetaGraphT * meta_graph)165 void CreateMultyModel2(mindspore::schema::MetaGraphT *meta_graph) {
166 meta_graph->name = "graph";
167
168 /* CPU GPU NPU support*/
169 auto cos = std::make_unique<mindspore::schema::CNodeT>();
170 cos->inputIndex = {0};
171 cos->outputIndex = {1};
172 cos->primitive = std::make_unique<mindspore::schema::PrimitiveT>();
173 cos->primitive->value.type = mindspore::schema::PrimitiveType_Cos;
174 auto cos_primitive = new mindspore::schema::CosT;
175 cos->primitive->value.value = cos_primitive;
176 cos->name = "cos";
177
178 /* CPU GPU support */
179 auto exp = std::make_unique<mindspore::schema::CNodeT>();
180 exp->inputIndex = {1};
181 exp->outputIndex = {2};
182 exp->primitive = std::make_unique<mindspore::schema::PrimitiveT>();
183 exp->primitive->value.type = mindspore::schema::PrimitiveType_ExpFusion;
184 auto exp_primitive = new mindspore::schema::ExpFusionT;
185 exp->primitive->value.value = exp_primitive;
186 exp->name = "exp";
187
188 /* tensors */
189 auto tensor0 = std::make_unique<mindspore::schema::TensorT>();
190 tensor0->nodeType = mindspore::lite::NodeType_ValueNode;
191 tensor0->format = mindspore::schema::Format_NHWC;
192 tensor0->dataType = mindspore::TypeId::kNumberTypeFloat32;
193 tensor0->dims = {1, 2, 2, 1};
194 tensor0->offset = -1;
195 tensor0->name = "tensor0";
196
197 auto tensor1 = std::make_unique<mindspore::schema::TensorT>();
198 tensor1->nodeType = mindspore::lite::NodeType_ValueNode;
199 tensor1->format = mindspore::schema::Format_NHWC;
200 tensor1->dataType = mindspore::TypeId::kNumberTypeFloat32;
201 tensor1->dims = {1, 2, 2, 1};
202 tensor1->offset = -1;
203 tensor1->name = "tensor1";
204
205 auto tensor2 = std::make_unique<mindspore::schema::TensorT>();
206 tensor2->nodeType = mindspore::lite::NodeType_ValueNode;
207 tensor2->format = mindspore::schema::Format_NHWC;
208 tensor2->dataType = mindspore::TypeId::kNumberTypeFloat32;
209 tensor2->dims = {1, 2, 2, 1};
210 tensor2->offset = -1;
211 tensor2->name = "tensor2";
212
213 meta_graph->nodes.emplace_back(std::move(cos));
214 meta_graph->nodes.emplace_back(std::move(exp));
215
216 meta_graph->allTensors.emplace_back(std::move(tensor0));
217 meta_graph->allTensors.emplace_back(std::move(tensor1));
218 meta_graph->allTensors.emplace_back(std::move(tensor2));
219
220 meta_graph->inputIndex = {0};
221 meta_graph->outputIndex = {2};
222 }
223
224 enum MultyDeviceMode1 { CPU, NPU, GPU, CPU_GPU, GPU_CPU, NPU_CPU, NPU_GPU_CPU, NPU2, GPU_NPU2 };
CheckResult(std::vector<mindspore::kernel::LiteKernel * > kernels,int mode)225 void CheckResult(std::vector<mindspore::kernel::LiteKernel *> kernels, int mode) {
226 /*
227 * cos exp where sin
228 * CPU * * * *
229 * GPU * * *
230 * NPU * *
231 *
232 * */
233
234 if (mode == CPU) {
235 ASSERT_EQ(1, kernels.size());
236 /* CPU : cos exp where sin */
237 auto subgraph1 = reinterpret_cast<mindspore::kernel::SubGraphKernel *>(kernels.at(0));
238 ASSERT_EQ(4, subgraph1->nodes().size());
239 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kCPU, subgraph1->desc().arch);
240
241 } else if (mode == NPU_CPU) {
242 ASSERT_EQ(3, kernels.size());
243 /* NPU : cos */
244 auto subgraph0 = kernels.at(0);
245 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kDelegate, subgraph0->desc().arch);
246 /* CPU : exp where */
247 auto subgraph1 = reinterpret_cast<mindspore::kernel::SubGraphKernel *>(kernels.at(1));
248 ASSERT_EQ(2, subgraph1->nodes().size());
249 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kCPU, subgraph1->desc().arch);
250 /* NPU : sin */
251 auto subgraph2 = kernels.at(2);
252 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kDelegate, subgraph2->desc().arch);
253
254 } else if (mode == GPU_CPU) {
255 /* GPU > CPU */
256 ASSERT_EQ(3, kernels.size());
257 /* GPU : to_format cos exp to_format */
258 auto subgraph0 = reinterpret_cast<mindspore::kernel::SubGraphKernel *>(kernels.at(0));
259 ASSERT_EQ(2 + 2, subgraph0->nodes().size());
260 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kGPU, subgraph0->desc().arch);
261 /* CPU : where */
262 auto subgraph1 = reinterpret_cast<mindspore::kernel::SubGraphKernel *>(kernels.at(1));
263 ASSERT_EQ(1, subgraph1->nodes().size());
264 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kCPU, subgraph1->desc().arch);
265 /* GPU : to_format sin to_format */
266 auto subgraph2 = reinterpret_cast<mindspore::kernel::SubGraphKernel *>(kernels.at(2));
267 ASSERT_EQ(3, subgraph2->nodes().size());
268 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kGPU, subgraph2->desc().arch);
269
270 } else if (mode == NPU_GPU_CPU) {
271 /* NPU > GPU > CPU */
272 ASSERT_EQ(4, kernels.size());
273 /* NPU : cos */
274 auto subgraph0 = kernels.at(0);
275 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kDelegate, subgraph0->desc().arch);
276 /* GPU : to_format exp to_format */
277 auto subgraph1 = reinterpret_cast<mindspore::kernel::SubGraphKernel *>(kernels.at(1));
278 ASSERT_EQ(3, subgraph1->nodes().size());
279 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kGPU, subgraph1->desc().arch);
280 /* CPU : where */
281 auto subgraph2 = reinterpret_cast<mindspore::kernel::SubGraphKernel *>(kernels.at(2));
282 ASSERT_EQ(1, subgraph2->nodes().size());
283 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kCPU, subgraph2->desc().arch);
284 /* NPU : sin */
285 auto subgraph3 = kernels.at(3);
286 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kDelegate, subgraph3->desc().arch);
287 } else if (mode == NPU2) {
288 /* NPU > GPU */
289 ASSERT_EQ(2, kernels.size());
290 /* NPU : cos */
291 auto subgraph0 = kernels.at(0);
292 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kDelegate, subgraph0->desc().arch);
293 /* GPU : to_format exp to_format */
294 auto subgraph1 = reinterpret_cast<mindspore::kernel::SubGraphKernel *>(kernels.at(1));
295 ASSERT_EQ(3, subgraph1->nodes().size());
296 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kGPU, subgraph1->desc().arch);
297 } else if (mode == GPU_NPU2) {
298 /* NPU > GPU */
299 ASSERT_EQ(1, kernels.size());
300 /* GPU : to_format cos exp to_format */
301 auto subgraph1 = reinterpret_cast<mindspore::kernel::SubGraphKernel *>(kernels.at(0));
302 ASSERT_EQ(4, subgraph1->nodes().size());
303 ASSERT_EQ(mindspore::kernel::KERNEL_ARCH::kGPU, subgraph1->desc().arch);
304 }
305 }
306
TEST_F(MultipleDeviceTest,OldApi1)307 TEST_F(MultipleDeviceTest, OldApi1) {
308 auto meta_graph = std::make_shared<mindspore::schema::MetaGraphT>();
309 CreateMultyModel1(meta_graph.get());
310
311 flatbuffers::FlatBufferBuilder builder(1024);
312 auto offset = mindspore::schema::MetaGraph::Pack(builder, meta_graph.get());
313 builder.Finish(offset);
314 mindspore::schema::FinishMetaGraphBuffer(builder, offset);
315 size_t size = builder.GetSize();
316 const char *content = reinterpret_cast<char *>(builder.GetBufferPointer());
317 mindspore::lite::Model *model = mindspore::lite::Model::Import(content, size);
318
319 auto context = new InnerContext();
320 mindspore::lite::DeviceContext cpu_device_ctx = {mindspore::lite::DT_CPU, {false, mindspore::lite::NO_BIND}};
321 mindspore::lite::DeviceContext gpu_device_ctx = {mindspore::lite::DT_GPU, {false, mindspore::lite::NO_BIND}};
322 context->device_list_.clear();
323 context->device_list_.emplace_back(gpu_device_ctx);
324 context->device_list_.emplace_back(cpu_device_ctx);
325 auto lite_session = new LiteSession();
326
327 auto ret = lite_session->Init(context);
328 ASSERT_EQ(mindspore::lite::RET_OK, ret);
329
330 ret = lite_session->CompileGraph(model);
331 ASSERT_EQ(mindspore::lite::RET_OK, ret);
332
333 CheckResult(lite_session->get_kernels(), MultyDeviceMode1::GPU_CPU);
334 }
335
TEST_F(MultipleDeviceTest,OldApi2)336 TEST_F(MultipleDeviceTest, OldApi2) {
337 auto meta_graph = std::make_shared<mindspore::schema::MetaGraphT>();
338 CreateMultyModel1(meta_graph.get());
339
340 flatbuffers::FlatBufferBuilder builder(1024);
341 auto offset = mindspore::schema::MetaGraph::Pack(builder, meta_graph.get());
342 builder.Finish(offset);
343 mindspore::schema::FinishMetaGraphBuffer(builder, offset);
344 size_t size = builder.GetSize();
345 const char *content = reinterpret_cast<char *>(builder.GetBufferPointer());
346
347 auto context = std::make_shared<mindspore::lite::Context>();
348 context->device_list_.push_back({mindspore::lite::DT_NPU, {false}});
349 mindspore::session::LiteSession *session =
350 mindspore::session::LiteSession::CreateSession(content, size, context.get());
351 ASSERT_NE(session, nullptr);
352
353 /* NPU > CPU */
354 CheckResult(reinterpret_cast<mindspore::lite::LiteSession *>(session)->get_kernels(), MultyDeviceMode1::NPU_CPU);
355 }
356
TEST_F(MultipleDeviceTest,NewApi1)357 TEST_F(MultipleDeviceTest, NewApi1) {
358 auto meta_graph = std::make_shared<mindspore::schema::MetaGraphT>();
359 CreateMultyModel1(meta_graph.get());
360
361 flatbuffers::FlatBufferBuilder builder(1024);
362 auto offset = mindspore::schema::MetaGraph::Pack(builder, meta_graph.get());
363 builder.Finish(offset);
364 mindspore::schema::FinishMetaGraphBuffer(builder, offset);
365 size_t size = builder.GetSize();
366
367 const char *content = reinterpret_cast<char *>(builder.GetBufferPointer());
368
369 auto context = std::shared_ptr<mindspore::Context>(new mindspore::Context());
370 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::KirinNPUDeviceInfo>());
371 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::GPUDeviceInfo>());
372
373 mindspore::Model *model = new mindspore::Model();
374 auto ret = model->Build(content, size, mindspore::kFlatBuffer, context);
375 ASSERT_EQ(false, ret.IsOk());
376
377 delete model;
378 }
379
TEST_F(MultipleDeviceTest,NewApi2)380 TEST_F(MultipleDeviceTest, NewApi2) {
381 mindspore::Context context;
382 context.MutableDeviceInfo().push_back(std::make_shared<mindspore::KirinNPUDeviceInfo>());
383 context.MutableDeviceInfo().push_back(std::make_shared<mindspore::CPUDeviceInfo>());
384 context.MutableDeviceInfo().push_back(std::make_shared<mindspore::GPUDeviceInfo>());
385
386 auto inner_context = std::shared_ptr<mindspore::lite::InnerContext>(mindspore::ContextUtils::Convert(&context));
387 ASSERT_EQ(inner_context->device_list_.size(), 3);
388 ASSERT_EQ(inner_context->device_list_.at(0).device_type_, mindspore::lite::DT_NPU);
389 ASSERT_EQ(inner_context->device_list_.at(1).device_type_, mindspore::lite::DT_CPU);
390 ASSERT_EQ(inner_context->device_list_.at(2).device_type_, mindspore::lite::DT_GPU);
391 }
392
TEST_F(MultipleDeviceTest,NewApi3)393 TEST_F(MultipleDeviceTest, NewApi3) {
394 mindspore::Context context;
395 context.MutableDeviceInfo().push_back(std::make_shared<mindspore::CPUDeviceInfo>());
396 context.MutableDeviceInfo().push_back(std::make_shared<mindspore::KirinNPUDeviceInfo>());
397
398 auto inner_context = std::shared_ptr<mindspore::lite::InnerContext>(mindspore::ContextUtils::Convert(&context));
399 ASSERT_EQ(inner_context->device_list_.size(), 2);
400 ASSERT_EQ(inner_context->device_list_.at(0).device_type_, mindspore::lite::DT_CPU);
401 ASSERT_EQ(inner_context->device_list_.at(1).device_type_, mindspore::lite::DT_NPU);
402 }
403
TEST_F(MultipleDeviceTest,NewApi4)404 TEST_F(MultipleDeviceTest, NewApi4) {
405 mindspore::Context context;
406 context.MutableDeviceInfo().push_back(std::make_shared<mindspore::GPUDeviceInfo>());
407 context.MutableDeviceInfo().push_back(std::make_shared<mindspore::CPUDeviceInfo>());
408
409 auto inner_context = std::shared_ptr<mindspore::lite::InnerContext>(mindspore::ContextUtils::Convert(&context));
410 ASSERT_EQ(inner_context->device_list_.size(), 2);
411 ASSERT_EQ(inner_context->device_list_.at(0).device_type_, mindspore::lite::DT_GPU);
412 ASSERT_EQ(inner_context->device_list_.at(1).device_type_, mindspore::lite::DT_CPU);
413 }
414
TEST_F(MultipleDeviceTest,NewApi5)415 TEST_F(MultipleDeviceTest, NewApi5) {
416 auto meta_graph = std::make_shared<mindspore::schema::MetaGraphT>();
417 CreateMultyModel1(meta_graph.get());
418
419 flatbuffers::FlatBufferBuilder builder(1024);
420 auto offset = mindspore::schema::MetaGraph::Pack(builder, meta_graph.get());
421 builder.Finish(offset);
422 mindspore::schema::FinishMetaGraphBuffer(builder, offset);
423 size_t size = builder.GetSize();
424
425 const char *content = reinterpret_cast<char *>(builder.GetBufferPointer());
426
427 auto context = std::make_shared<mindspore::Context>();
428 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::KirinNPUDeviceInfo>());
429 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::GPUDeviceInfo>());
430 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::CPUDeviceInfo>());
431
432 auto model_impl = std::make_shared<mindspore::ModelImpl>();
433 auto ret = model_impl->Build(content, size, mindspore::kFlatBuffer, context);
434 ASSERT_EQ(mindspore::kSuccess, ret.StatusCode());
435
436 CheckResult(reinterpret_cast<const mindspore::lite::LiteSession *>(model_impl->GetSession())->get_kernels(),
437 MultyDeviceMode1::NPU_GPU_CPU);
438
439 /* set input data */
440 std::vector<mindspore::MSTensor> inputs = model_impl->GetInputs();
441 auto in = inputs[0];
442 std::vector<float> in_float = {1.0, 2.0, 3.0, 4.0};
443 memcpy(in.MutableData(), in_float.data(), in.DataSize());
444
445 std::vector<mindspore::MSTensor> outputs = model_impl->GetOutputs();
446
447 model_impl->Predict(inputs, &outputs, nullptr, nullptr);
448
449 /* checkout output */
450 auto out = outputs[0];
451 void *out_data = out.MutableData();
452 float *fp32_data = reinterpret_cast<float *>(out_data);
453
454 ASSERT_LE(fabs(fp32_data[0] - (0.841471)), 0.01);
455 ASSERT_LE(fabs(fp32_data[1] - (0.909297)), 0.01);
456 ASSERT_LE(fabs(fp32_data[2] - (0.141120)), 0.01);
457 ASSERT_LE(fabs(fp32_data[3] - (-0.756802)), 0.01);
458 }
459
TEST_F(MultipleDeviceTest,NewApi6)460 TEST_F(MultipleDeviceTest, NewApi6) {
461 auto meta_graph = std::make_shared<mindspore::schema::MetaGraphT>();
462 CreateMultyModel1(meta_graph.get());
463
464 flatbuffers::FlatBufferBuilder builder(1024);
465 auto offset = mindspore::schema::MetaGraph::Pack(builder, meta_graph.get());
466 builder.Finish(offset);
467 mindspore::schema::FinishMetaGraphBuffer(builder, offset);
468 size_t size = builder.GetSize();
469
470 const char *content = reinterpret_cast<char *>(builder.GetBufferPointer());
471
472 auto context = std::make_shared<mindspore::Context>();
473 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::CPUDeviceInfo>());
474 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::KirinNPUDeviceInfo>());
475 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::GPUDeviceInfo>());
476
477 auto model_impl = std::make_shared<mindspore::ModelImpl>();
478 auto ret = model_impl->Build(content, size, mindspore::kFlatBuffer, context);
479 ASSERT_EQ(mindspore::kSuccess, ret.StatusCode());
480
481 CheckResult(reinterpret_cast<const mindspore::lite::LiteSession *>(model_impl->GetSession())->get_kernels(),
482 MultyDeviceMode1::CPU);
483
484 /* set input data */
485 std::vector<mindspore::MSTensor> inputs = model_impl->GetInputs();
486 auto in = inputs[0];
487 std::vector<float> in_float = {1.0, 2.0, 3.0, 4.0};
488 memcpy(in.MutableData(), in_float.data(), in.DataSize());
489
490 std::vector<mindspore::MSTensor> outputs = model_impl->GetOutputs();
491
492 model_impl->Predict(inputs, &outputs, nullptr, nullptr);
493
494 /* checkout output */
495 auto out = outputs[0];
496 void *out_data = out.MutableData();
497 float *fp32_data = reinterpret_cast<float *>(out_data);
498
499 ASSERT_LE(fabs(fp32_data[0] - (0.841471)), 0.01);
500 ASSERT_LE(fabs(fp32_data[1] - (0.909297)), 0.01);
501 ASSERT_LE(fabs(fp32_data[2] - (0.141120)), 0.01);
502 ASSERT_LE(fabs(fp32_data[3] - (-0.756802)), 0.01);
503 }
504
TEST_F(MultipleDeviceTest,NewApi7)505 TEST_F(MultipleDeviceTest, NewApi7) {
506 auto meta_graph = std::make_shared<mindspore::schema::MetaGraphT>();
507 CreateMultyModel2(meta_graph.get());
508
509 flatbuffers::FlatBufferBuilder builder(1024);
510 auto offset = mindspore::schema::MetaGraph::Pack(builder, meta_graph.get());
511 builder.Finish(offset);
512 mindspore::schema::FinishMetaGraphBuffer(builder, offset);
513 size_t size = builder.GetSize();
514
515 const char *content = reinterpret_cast<char *>(builder.GetBufferPointer());
516
517 auto context = std::make_shared<mindspore::Context>();
518 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::KirinNPUDeviceInfo>());
519 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::GPUDeviceInfo>());
520
521 auto model_impl = std::make_shared<mindspore::ModelImpl>();
522 auto ret = model_impl->Build(content, size, mindspore::kFlatBuffer, context);
523 ASSERT_EQ(mindspore::kSuccess, ret.StatusCode());
524
525 CheckResult(reinterpret_cast<const mindspore::lite::LiteSession *>(model_impl->GetSession())->get_kernels(),
526 MultyDeviceMode1::NPU2);
527 }
528
TEST_F(MultipleDeviceTest,NewApi8)529 TEST_F(MultipleDeviceTest, NewApi8) {
530 auto meta_graph = std::make_shared<mindspore::schema::MetaGraphT>();
531 CreateMultyModel2(meta_graph.get());
532
533 flatbuffers::FlatBufferBuilder builder(1024);
534 auto offset = mindspore::schema::MetaGraph::Pack(builder, meta_graph.get());
535 builder.Finish(offset);
536 mindspore::schema::FinishMetaGraphBuffer(builder, offset);
537 size_t size = builder.GetSize();
538
539 const char *content = reinterpret_cast<char *>(builder.GetBufferPointer());
540
541 // create a context
542 auto context = std::make_shared<mindspore::Context>();
543 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::GPUDeviceInfo>());
544 context->MutableDeviceInfo().push_back(std::make_shared<mindspore::KirinNPUDeviceInfo>());
545
546 auto model_impl = std::make_shared<mindspore::ModelImpl>();
547 auto ret = model_impl->Build(content, size, mindspore::kFlatBuffer, context);
548 ASSERT_EQ(mindspore::kSuccess, ret.StatusCode());
549
550 CheckResult(reinterpret_cast<const mindspore::lite::LiteSession *>(model_impl->GetSession())->get_kernels(),
551 MultyDeviceMode1::GPU_NPU2);
552 }
553