blob: 59f65541b84f61cb6faa502dc09ef98b4064aaf1 [file] [log] [blame]
Laurent Carlier749294b2020-06-01 09:03:17 +01001//
Jim Flynn6398a982020-05-27 17:05:21 +01002// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
David Beckecb56cd2018-09-05 12:52:57 +01003// SPDX-License-Identifier: MIT
telsoa014fcda012018-03-09 14:13:49 +00004//
telsoa014fcda012018-03-09 14:13:49 +00005
Jim Flynn77b284e2022-03-13 20:53:35 +00006#include <ArmNNProfilingServiceInitialiser.hpp>
7#include <ProfilingOptionsConverter.hpp>
8#include <Runtime.hpp>
9
Aron Virginas-Tarc26ba752018-10-22 13:32:01 +010010#include <armnn/Descriptors.hpp>
11#include <armnn/IRuntime.hpp>
12#include <armnn/INetwork.hpp>
Aron Virginas-Tarc26ba752018-10-22 13:32:01 +010013#include <armnn/TypesUtils.hpp>
telsoa014fcda012018-03-09 14:13:49 +000014
Jim Flynn77b284e2022-03-13 20:53:35 +000015#include <armnn/profiling/ArmNNProfiling.hpp>
16
Nikhil Raj77fe76b2021-06-09 14:55:32 +010017#include <common/include/LabelsAndEventClasses.hpp>
Jim Flynn77b284e2022-03-13 20:53:35 +000018#include <common/include/Processes.hpp>
19
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +000020#include <test/ProfilingTestUtils.hpp>
21
Aron Virginas-Tarc9cc8042018-11-01 16:15:57 +000022#include <HeapProfiling.hpp>
23#include <LeakChecking.hpp>
telsoa014fcda012018-03-09 14:13:49 +000024
25#ifdef WITH_VALGRIND
Aron Virginas-Tarc26ba752018-10-22 13:32:01 +010026#include <valgrind/memcheck.h>
telsoa014fcda012018-03-09 14:13:49 +000027#endif
28
Sadik Armagan1625efc2021-06-10 18:24:34 +010029#include <doctest/doctest.h>
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +000030#include "RuntimeTests.hpp"
Sadik Armagana097d2a2021-11-24 15:47:28 +000031#include <TestUtils.hpp>
Aron Virginas-Tarc26ba752018-10-22 13:32:01 +010032
telsoa014fcda012018-03-09 14:13:49 +000033namespace armnn
34{
35
Kevin Mayd92a6e42021-02-04 10:27:41 +000036void RuntimeLoadedNetworksReserve(armnn::RuntimeImpl* runtime)
telsoa014fcda012018-03-09 14:13:49 +000037{
38 runtime->m_LoadedNetworks.reserve(1);
39}
40
Jim Flynn6c9f17d2022-03-10 23:13:01 +000041} // namespace armnn
telsoa014fcda012018-03-09 14:13:49 +000042
Sadik Armagan1625efc2021-06-10 18:24:34 +010043TEST_SUITE("Runtime")
44{
45TEST_CASE("RuntimeUnloadNetwork")
telsoa014fcda012018-03-09 14:13:49 +000046{
47 // build 2 mock-networks and load them into the runtime
telsoa01c577f2c2018-08-31 09:22:23 +010048 armnn::IRuntime::CreationOptions options;
Keith Davis97da5e22020-03-05 16:25:28 +000049 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
telsoa014fcda012018-03-09 14:13:49 +000050
telsoa01c577f2c2018-08-31 09:22:23 +010051 // Mock network 1.
Keith Davis97da5e22020-03-05 16:25:28 +000052 armnn::NetworkId networkIdentifier1 = 1;
telsoa014fcda012018-03-09 14:13:49 +000053 armnn::INetworkPtr mockNetwork1(armnn::INetwork::Create());
54 mockNetwork1->AddInputLayer(0, "test layer");
Keith Davis97da5e22020-03-05 16:25:28 +000055 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
telsoa01c577f2c2018-08-31 09:22:23 +010056 runtime->LoadNetwork(networkIdentifier1, Optimize(*mockNetwork1, backends, runtime->GetDeviceSpec()));
telsoa014fcda012018-03-09 14:13:49 +000057
telsoa01c577f2c2018-08-31 09:22:23 +010058 // Mock network 2.
Keith Davis97da5e22020-03-05 16:25:28 +000059 armnn::NetworkId networkIdentifier2 = 2;
telsoa014fcda012018-03-09 14:13:49 +000060 armnn::INetworkPtr mockNetwork2(armnn::INetwork::Create());
61 mockNetwork2->AddInputLayer(0, "test layer");
telsoa01c577f2c2018-08-31 09:22:23 +010062 runtime->LoadNetwork(networkIdentifier2, Optimize(*mockNetwork2, backends, runtime->GetDeviceSpec()));
telsoa014fcda012018-03-09 14:13:49 +000063
telsoa01c577f2c2018-08-31 09:22:23 +010064 // Unloads one by its networkID.
Sadik Armagan1625efc2021-06-10 18:24:34 +010065 CHECK(runtime->UnloadNetwork(networkIdentifier1) == armnn::Status::Success);
telsoa014fcda012018-03-09 14:13:49 +000066
Sadik Armagan1625efc2021-06-10 18:24:34 +010067 CHECK(runtime->UnloadNetwork(networkIdentifier1) == armnn::Status::Failure);
telsoa014fcda012018-03-09 14:13:49 +000068}
69
Finn Williamsf37b9702021-09-01 18:06:04 +010070TEST_CASE("RuntimePreImportInputs")
71{
72 armnn::IRuntime::CreationOptions options;
Finn Williams8636bc72021-10-02 15:06:39 +010073 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
74 armnn::NetworkId networkId = 1;
Finn Williamsf37b9702021-09-01 18:06:04 +010075 armnn::INetworkPtr testNetwork(armnn::INetwork::Create());
Finn Williams8636bc72021-10-02 15:06:39 +010076
Finn Williamsf37b9702021-09-01 18:06:04 +010077 auto inputLayer1 = testNetwork->AddInputLayer(0, "input 1 layer");
78 auto inputLayer2 = testNetwork->AddInputLayer(1, "input 2 layer");
79 auto addLayer = testNetwork->AddAdditionLayer("add layer");
80 auto outputLayer = testNetwork->AddOutputLayer(2, "output layer");
81
82 TensorInfo tensorInfo{{4}, armnn::DataType::Signed32};
83
84 inputLayer1->GetOutputSlot(0).Connect(addLayer->GetInputSlot(0));
85 inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
Finn Williams8636bc72021-10-02 15:06:39 +010086
Finn Williamsf37b9702021-09-01 18:06:04 +010087 inputLayer2->GetOutputSlot(0).Connect(addLayer->GetInputSlot(1));
88 inputLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
89
90 addLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
91 addLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
92
Finn Williams8636bc72021-10-02 15:06:39 +010093 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
Finn Williamsf37b9702021-09-01 18:06:04 +010094
95 std::string er;
Colm Donelan03bf98a2022-05-30 15:20:36 +010096 armnn::INetworkProperties networkProperties(true, MemorySource::Undefined, MemorySource::Undefined);
Finn Williams8636bc72021-10-02 15:06:39 +010097 runtime->LoadNetwork(networkId,
Finn Williamsf37b9702021-09-01 18:06:04 +010098 Optimize(*testNetwork, backends, runtime->GetDeviceSpec()),
99 er,
100 networkProperties);
101
102 std::vector<int> inputData1(4, 10);
103 std::vector<int> inputData2(4, 20);
104 std::vector<int> output(4);
105
Cathal Corbett5b8093c2021-10-22 11:12:07 +0100106 ConstTensor inputTensor1({{4}, armnn::DataType::Signed32, 0.0f, 0, true}, inputData1.data());
107 ConstTensor inputTensor2({{4}, armnn::DataType::Signed32, 0.0f, 0, true}, inputData2.data());
Finn Williamsf37b9702021-09-01 18:06:04 +0100108 Tensor outputTensor({{4}, armnn::DataType::Signed32}, output.data());
109
Colm Donelan03bf98a2022-05-30 15:20:36 +0100110 auto importedInputVec1 = runtime->ImportInputs(networkId, {{0, inputTensor1}}, MemorySource::Malloc);
Finn Williamsf37b9702021-09-01 18:06:04 +0100111 CHECK(importedInputVec1.size() == 1);
112 CHECK(importedInputVec1[0] == 0);
113
Finn Williams8636bc72021-10-02 15:06:39 +0100114 auto memHandle = runtime->CreateWorkingMemHandle(networkId);
Finn Williamsf37b9702021-09-01 18:06:04 +0100115
116 runtime->Execute(*memHandle.get(), {{1, inputTensor2}}, {{2, outputTensor}}, {0 /* pre-imported id */});
Finn Williams8636bc72021-10-02 15:06:39 +0100117 for (auto val: output) {
Finn Williamsf37b9702021-09-01 18:06:04 +0100118 CHECK(val == 30);
119 }
120
Colm Donelan03bf98a2022-05-30 15:20:36 +0100121 auto importedInputVec2 = runtime->ImportInputs(networkId, {{1, inputTensor2}}, MemorySource::Malloc);
Finn Williamsf37b9702021-09-01 18:06:04 +0100122 CHECK(importedInputVec2.size() == 1);
123 CHECK(importedInputVec2[0] == 1);
124
125 runtime->Execute(*memHandle.get(), {{0, inputTensor1}}, {{2, outputTensor}}, {1 /* pre-imported id */});
Finn Williams8636bc72021-10-02 15:06:39 +0100126 for (auto val: output) {
Finn Williamsf37b9702021-09-01 18:06:04 +0100127 CHECK(val == 30);
128 }
129
130 runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0, 1});
Finn Williams8636bc72021-10-02 15:06:39 +0100131 for (auto val: output) {
Finn Williamsf37b9702021-09-01 18:06:04 +0100132 CHECK(val == 30);
133 }
Finn Williamsf37b9702021-09-01 18:06:04 +0100134 // Duplicate ImportedInputId and LayerBindingId
Finn Williams8636bc72021-10-02 15:06:39 +0100135 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0, 0});,
136 armnn::InvalidArgumentException);
Finn Williamsf37b9702021-09-01 18:06:04 +0100137 // Duplicate LayerBindingId
Finn Williams8636bc72021-10-02 15:06:39 +0100138 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{1, inputTensor2}}, {{2, outputTensor}}, {1});,
139 armnn::InvalidArgumentException);
Finn Williamsf37b9702021-09-01 18:06:04 +0100140 // Incorrect ImportedInputId
Finn Williams8636bc72021-10-02 15:06:39 +0100141 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{1, inputTensor2}}, {{2, outputTensor}}, {10});,
142 armnn::InvalidArgumentException);
Finn Williamsf37b9702021-09-01 18:06:04 +0100143 // Incorrect LayerBindingId
Finn Williams8636bc72021-10-02 15:06:39 +0100144 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{-2, inputTensor2}}, {{2, outputTensor}}, {1});,
145 armnn::InvalidArgumentException);
Finn Williamsf37b9702021-09-01 18:06:04 +0100146 // Incorrect layer binding id and ImportedInputId
Finn Williams8636bc72021-10-02 15:06:39 +0100147 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{-2, inputTensor2}}, {{2, outputTensor}}, {10});,
148 armnn::InvalidArgumentException);
Colm Donelan03bf98a2022-05-30 15:20:36 +0100149 auto importedInputVec3 = runtime->ImportInputs(networkId, {{1, inputTensor2}}, MemorySource::Malloc);
Finn Williamsf37b9702021-09-01 18:06:04 +0100150 CHECK(importedInputVec3[0] == 2);
151 // Too many ImportedInputIds
Finn Williams8636bc72021-10-02 15:06:39 +0100152 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0, 1, 2});,
153 armnn::InvalidArgumentException);
Finn Williamsf37b9702021-09-01 18:06:04 +0100154 // Too many InputTensors
155 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(),
Finn Williams8636bc72021-10-02 15:06:39 +0100156 {{0, inputTensor2},
157 {1, inputTensor2},
158 {2, inputTensor2}},
159 {{2, outputTensor}});, armnn::InvalidArgumentException);
Finn Williamsf37b9702021-09-01 18:06:04 +0100160 // Too few ImportedInputIds
Finn Williams8636bc72021-10-02 15:06:39 +0100161 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0});,
162 armnn::InvalidArgumentException);
163 runtime->ClearImportedInputs(networkId, {1});
164 runtime->Execute(*memHandle.get(), {{1, inputTensor2}}, {{2, outputTensor}}, {0}, {});
165 for (auto val: output) {
166 CHECK(val == 30);
167 }
168 // Using deleted pre-imported input
169 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0, 1}, {});,
170 armnn::InvalidArgumentException);
171
172 // Trying to delete deleted pre-imported tensor
173 CHECK_THROWS_AS(runtime->ClearImportedInputs(networkId, {1});, armnn::InvalidArgumentException);
174
175 // Trying to delete unknown pre-imported tensor
176 CHECK_THROWS_AS(runtime->ClearImportedInputs(networkId, {10});, armnn::InvalidArgumentException);
177}
Colm Donelan03bf98a2022-05-30 15:20:36 +0100178
Finn Williams8636bc72021-10-02 15:06:39 +0100179TEST_CASE("RuntimePreImportOutputs")
180{
181 armnn::IRuntime::CreationOptions options;
182 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
183
184 armnn::NetworkId networkId = 1;
185
186 armnn::INetworkPtr testNetwork(armnn::INetwork::Create());
Cathal Corbett5b8093c2021-10-22 11:12:07 +0100187 TensorInfo tensorInfo{{4}, armnn::DataType::Float32, 0.0f, 0, true};
Finn Williams8636bc72021-10-02 15:06:39 +0100188
189 auto inputLayer1 = testNetwork->AddInputLayer(0, "input 1 layer");
190 inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
191
192 ActivationDescriptor activationDescriptor;
193 activationDescriptor.m_Function = ActivationFunction::BoundedReLu;
194 activationDescriptor.m_A = 2.0f;
195 activationDescriptor.m_B = 0.0f;
196 auto activationLayer1 = testNetwork->AddActivationLayer(activationDescriptor, "add layer");
197 auto outputLayer1 = testNetwork->AddOutputLayer(2, "output layer");
198
199 inputLayer1->GetOutputSlot(0).Connect(activationLayer1->GetInputSlot(0));
200
201 activationLayer1->GetOutputSlot(0).Connect(outputLayer1->GetInputSlot(0));
202 activationLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
203
204 auto inputLayer2 = testNetwork->AddInputLayer(1, "input 1 layer");
205
206 activationDescriptor.m_A = 4.0f;
207 activationDescriptor.m_B = 2.0f;
208 auto activationLayer2 = testNetwork->AddActivationLayer(activationDescriptor, "add layer");
209 auto outputLayer2 = testNetwork->AddOutputLayer(3, "output layer");
210
211 inputLayer2->GetOutputSlot(0).Connect(activationLayer2->GetInputSlot(0));
212 inputLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
213
214 activationLayer2->GetOutputSlot(0).Connect(outputLayer2->GetInputSlot(0));
215 activationLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
216
217 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
218
219 std::string er;
Colm Donelan03bf98a2022-05-30 15:20:36 +0100220 armnn::INetworkProperties networkProperties(true, MemorySource::Undefined, MemorySource::Undefined);
Finn Williams8636bc72021-10-02 15:06:39 +0100221 runtime->LoadNetwork(networkId,
222 Optimize(*testNetwork, backends, runtime->GetDeviceSpec()),
223 er,
224 networkProperties);
225
226 std::vector<float> inputData1(4, 1.0f);
227 std::vector<float> inputData2(4, 3.0f);
228
229 std::vector<float> outputData1(4);
230 std::vector<float> outputData2(4);
231
232 ConstTensor inputTensor1(tensorInfo, inputData1.data());
233 ConstTensor inputTensor2(tensorInfo, inputData2.data());
234
235 Tensor outputTensor1{tensorInfo, outputData1.data()};
236 Tensor outputTensor2{tensorInfo, outputData2.data()};
237
238 InputTensors inputTensors = {{0, inputTensor1}, {1, inputTensor2}};
239
240 std::pair<LayerBindingId, class Tensor> output1{2, outputTensor1};
241 std::pair<LayerBindingId, class Tensor> output2{3, outputTensor2};
242
243 auto testOutputs = [&]()
244 {
245 for (auto val : outputData1)
246 {
247 CHECK(val == 1.0f);
248 }
249
250 for (auto val : outputData2)
251 {
252 CHECK(val == 3.0f);
253 }
254 };
255
256 auto memHandle = runtime->CreateWorkingMemHandle(networkId);
257
258 runtime->Execute(*memHandle.get(),inputTensors, {output1, output2});
259 testOutputs();
260
Colm Donelan03bf98a2022-05-30 15:20:36 +0100261 auto importedOutputVec = runtime->ImportOutputs(networkId, {output1, output2 }, MemorySource::Malloc);
Finn Williams8636bc72021-10-02 15:06:39 +0100262 CHECK(importedOutputVec.size() == 2);
263 CHECK(importedOutputVec[0] == 0);
264 CHECK(importedOutputVec[1] == 1);
265
266 runtime->Execute(*memHandle.get(), inputTensors, {}, {}, importedOutputVec);
267 testOutputs();
268
269 runtime->Execute(*memHandle.get(), inputTensors, {output1}, {}, {1});
270 testOutputs();
271
272 runtime->Execute(*memHandle.get(), inputTensors, {output2}, {}, {0});
273 testOutputs();
274
Colm Donelan03bf98a2022-05-30 15:20:36 +0100275 auto importedInputVec = runtime->ImportInputs(networkId, inputTensors, MemorySource::Malloc);
Finn Williams8636bc72021-10-02 15:06:39 +0100276 CHECK(importedInputVec.size() == 2);
277 CHECK(importedInputVec[0] == 0);
278 CHECK(importedInputVec[1] == 1);
279
280 runtime->Execute(*memHandle.get(), {}, {}, importedInputVec, importedOutputVec);
281 testOutputs();
282
283 runtime->Execute(*memHandle.get(), {{0, inputTensor1}}, {output2}, {1}, {0});
284 testOutputs();
285
286 // Too many ids
287 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {output1, output2}, {}, {0, 1});,
288 armnn::InvalidArgumentException);
289
290 // Duplicate ids
291 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {output2}, {}, {1});,
292 armnn::InvalidArgumentException);
293
294 // Duplicate ids
295 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {output1, output1}, {}, {});,
296 armnn::InvalidArgumentException);
297
298 // Duplicate ids
299 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {}, {}, {0, 0}),
300 armnn::InvalidArgumentException);
301
302 // Unknown id
303 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {output1}, {}, {3});,
304 armnn::InvalidArgumentException);
305
306 // Unknown id
307 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {{4, outputTensor2}}, {}, {1});,
308 armnn::InvalidArgumentException);
309
310 // Input id for output
311 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {{0, outputTensor2}}, {}, {1});,
312 armnn::InvalidArgumentException);
313
314 // Input id for output
315 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {{0, outputTensor2}}, {}, {1});,
316 armnn::InvalidArgumentException);
317
318 // Output id for input
319 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{2, inputTensor1}}, {{0, outputTensor2}}, {1}, {1, 0});,
320 armnn::InvalidArgumentException);
321
322 runtime->ClearImportedOutputs(networkId, {1});
323
324 runtime->Execute(*memHandle.get(), inputTensors, {output2}, {}, {0});
325 testOutputs();
326
327 // Trying to use deleted pre-imported tensor
328 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {}, {}, importedOutputVec),
329 armnn::InvalidArgumentException);
330
331 // Trying to delete deleted pre-imported tensor
332 CHECK_THROWS_AS(runtime->ClearImportedOutputs(networkId, {1});, armnn::InvalidArgumentException);
333
334 // Trying to delete unknown pre-imported tensor
335 CHECK_THROWS_AS(runtime->ClearImportedOutputs(networkId, {10});, armnn::InvalidArgumentException);
Finn Williamsf37b9702021-09-01 18:06:04 +0100336}
337
surmeh013537c2c2018-05-18 16:31:43 +0100338// Note: the current builds we don't do valgrind and gperftools based leak checking at the same
telsoa01c577f2c2018-08-31 09:22:23 +0100339// time, so in practice WITH_VALGRIND and ARMNN_LEAK_CHECKING_ENABLED are exclusive. The
340// valgrind tests can stay for x86 builds, but on hikey Valgrind is just way too slow
341// to be integrated into the CI system.
surmeh013537c2c2018-05-18 16:31:43 +0100342
telsoa01c577f2c2018-08-31 09:22:23 +0100343#ifdef ARMNN_LEAK_CHECKING_ENABLED
344
345struct DisableGlobalLeakChecking
346{
347 DisableGlobalLeakChecking()
348 {
349 ARMNN_LOCAL_LEAK_CHECKING_ONLY();
350 }
351};
352
Sadik Armagan1625efc2021-06-10 18:24:34 +0100353TEST_CASE_FIXTURE(DisableGlobalLeakChecking, "RuntimeHeapMemoryUsageSanityChecks")
surmeh013537c2c2018-05-18 16:31:43 +0100354{
Sadik Armagan1625efc2021-06-10 18:24:34 +0100355 CHECK(ARMNN_LEAK_CHECKER_IS_ACTIVE());
surmeh013537c2c2018-05-18 16:31:43 +0100356 {
357 ARMNN_SCOPED_LEAK_CHECKER("Sanity_Check_Outer");
358 {
359 ARMNN_SCOPED_LEAK_CHECKER("Sanity_Check_Inner");
Sadik Armagan1625efc2021-06-10 18:24:34 +0100360 CHECK(ARMNN_NO_LEAKS_IN_SCOPE() == true);
surmeh013537c2c2018-05-18 16:31:43 +0100361 std::unique_ptr<char[]> dummyAllocation(new char[1000]);
Sadik Armagan1625efc2021-06-10 18:24:34 +0100362 // "A leak of 1000 bytes is expected here. "
363 // "Please make sure environment variable: HEAPCHECK=draconian is set!"
364 CHECK((ARMNN_NO_LEAKS_IN_SCOPE() == false));
365 CHECK(ARMNN_BYTES_LEAKED_IN_SCOPE() == 1000);
366 CHECK(ARMNN_OBJECTS_LEAKED_IN_SCOPE() == 1);
surmeh013537c2c2018-05-18 16:31:43 +0100367 }
Sadik Armagan1625efc2021-06-10 18:24:34 +0100368 CHECK(ARMNN_NO_LEAKS_IN_SCOPE());
369 CHECK(ARMNN_BYTES_LEAKED_IN_SCOPE() == 0);
370 CHECK(ARMNN_OBJECTS_LEAKED_IN_SCOPE() == 0);
surmeh013537c2c2018-05-18 16:31:43 +0100371 }
372}
373
surmeh013537c2c2018-05-18 16:31:43 +0100374#endif // ARMNN_LEAK_CHECKING_ENABLED
375
376// Note: this part of the code is due to be removed when we fully trust the gperftools based results.
telsoa014fcda012018-03-09 14:13:49 +0000377#ifdef WITH_VALGRIND
telsoa01c577f2c2018-08-31 09:22:23 +0100378// Run with the following command to get all the amazing output (in the devenv/build folder) :)
telsoa014fcda012018-03-09 14:13:49 +0000379// valgrind --leak-check=full --show-leak-kinds=all --log-file=Valgrind_Memcheck_Leak_Report.txt armnn/test/UnitTests
Sadik Armagan1625efc2021-06-10 18:24:34 +0100380TEST_CASE("RuntimeMemoryLeak")
telsoa014fcda012018-03-09 14:13:49 +0000381{
382 // From documentation:
383
384 // This means that no pointer to the block can be found. The block is classified as "lost",
385 // because the programmer could not possibly have freed it at program exit, since no pointer to it exists.
386 unsigned long leakedBefore = 0;
Keith Davis97da5e22020-03-05 16:25:28 +0000387 unsigned long leakedAfter = 0;
telsoa014fcda012018-03-09 14:13:49 +0000388
389 // A start-pointer or chain of start-pointers to the block is found. Since the block is still pointed at,
390 // the programmer could, at least in principle, have freed it before program exit.
telsoa01c577f2c2018-08-31 09:22:23 +0100391 // We want to test this in case memory is not freed as early as it could have been.
telsoa014fcda012018-03-09 14:13:49 +0000392 unsigned long reachableBefore = 0;
Keith Davis97da5e22020-03-05 16:25:28 +0000393 unsigned long reachableAfter = 0;
telsoa014fcda012018-03-09 14:13:49 +0000394
telsoa01c577f2c2018-08-31 09:22:23 +0100395 // Needed as out params but we don't test them.
Keith Davis97da5e22020-03-05 16:25:28 +0000396 unsigned long dubious = 0;
telsoa014fcda012018-03-09 14:13:49 +0000397 unsigned long suppressed = 0;
398
399 armnn::NetworkId networkIdentifier1 = 1;
400
401 // ensure that runtime is large enough before checking for memory leaks
402 // otherwise when loading the network it will automatically reserve memory that won't be released until destruction
telsoa01c577f2c2018-08-31 09:22:23 +0100403 armnn::IRuntime::CreationOptions options;
Kevin Mayd92a6e42021-02-04 10:27:41 +0000404 armnn::RuntimeImpl runtime(options);
telsoa014fcda012018-03-09 14:13:49 +0000405 armnn::RuntimeLoadedNetworksReserve(&runtime);
406
telsoa014fcda012018-03-09 14:13:49 +0000407 {
Keith Davis97da5e22020-03-05 16:25:28 +0000408 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
telsoa014fcda012018-03-09 14:13:49 +0000409
Francis Murtagh3d2b4b22021-02-15 18:23:17 +0000410 armnn::INetworkPtr mockNetwork1(armnn::INetwork::Create());
telsoa014fcda012018-03-09 14:13:49 +0000411 mockNetwork1->AddInputLayer(0, "test layer");
412
Matteo Martincigh9326aab2018-11-15 10:54:54 +0000413 // Warm-up load/unload pair to put the runtime in a stable state (memory-wise).
telsoa01c577f2c2018-08-31 09:22:23 +0100414 runtime.LoadNetwork(networkIdentifier1, Optimize(*mockNetwork1, backends, runtime.GetDeviceSpec()));
Matteo Martincigh9326aab2018-11-15 10:54:54 +0000415 runtime.UnloadNetwork(networkIdentifier1);
416
417 // Checks for leaks before we load the network and record them so that we can see the delta after unloading.
418 VALGRIND_DO_QUICK_LEAK_CHECK;
419 VALGRIND_COUNT_LEAKS(leakedBefore, dubious, reachableBefore, suppressed);
420
421 // The actual test.
422 runtime.LoadNetwork(networkIdentifier1, Optimize(*mockNetwork1, backends, runtime.GetDeviceSpec()));
423 runtime.UnloadNetwork(networkIdentifier1);
424
425 VALGRIND_DO_ADDED_LEAK_CHECK;
426 VALGRIND_COUNT_LEAKS(leakedAfter, dubious, reachableAfter, suppressed);
telsoa014fcda012018-03-09 14:13:49 +0000427 }
428
telsoa01c577f2c2018-08-31 09:22:23 +0100429 // If we're not running under Valgrind, these vars will have been initialised to 0, so this will always pass.
Sadik Armagan1625efc2021-06-10 18:24:34 +0100430 CHECK(leakedBefore == leakedAfter);
431 CHECK(reachableBefore == reachableAfter);
telsoa014fcda012018-03-09 14:13:49 +0000432
telsoa01c577f2c2018-08-31 09:22:23 +0100433 // These are needed because VALGRIND_COUNT_LEAKS is a macro that assigns to the parameters
434 // so they are assigned to, but still considered unused, causing a warning.
Jim Flynn9265a882022-03-10 23:35:26 +0000435 armnn::IgnoreUnused(dubious);
436 armnn::IgnoreUnused(suppressed);
telsoa014fcda012018-03-09 14:13:49 +0000437}
Aron Virginas-Tarc26ba752018-10-22 13:32:01 +0100438#endif // WITH_VALGRIND
telsoa01c577f2c2018-08-31 09:22:23 +0100439
Sadik Armagan1625efc2021-06-10 18:24:34 +0100440TEST_CASE("RuntimeCpuRef")
telsoa01c577f2c2018-08-31 09:22:23 +0100441{
442 using namespace armnn;
443
444 // Create runtime in which test will run
445 armnn::IRuntime::CreationOptions options;
Keith Davis97da5e22020-03-05 16:25:28 +0000446 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
telsoa01c577f2c2018-08-31 09:22:23 +0100447
448 // build up the structure of the network
449 INetworkPtr net(INetwork::Create());
450
451 IConnectableLayer* input = net->AddInputLayer(0);
452
453 // This layer configuration isn't supported by CpuAcc, should be fall back to CpuRef.
454 NormalizationDescriptor descriptor;
455 IConnectableLayer* normalize = net->AddNormalizationLayer(descriptor);
456
457 IConnectableLayer* output = net->AddOutputLayer(0);
458
459 input->GetOutputSlot(0).Connect(normalize->GetInputSlot(0));
460 normalize->GetOutputSlot(0).Connect(output->GetInputSlot(0));
461
462 input->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
463 normalize->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
464
465 // optimize the network
David Beckf0b48452018-10-19 15:20:56 +0100466 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
Keith Davis97da5e22020-03-05 16:25:28 +0000467 IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime->GetDeviceSpec());
telsoa01c577f2c2018-08-31 09:22:23 +0100468
469 // Load it into the runtime. It should success.
470 armnn::NetworkId netId;
Sadik Armagan1625efc2021-06-10 18:24:34 +0100471 CHECK(runtime->LoadNetwork(netId, std::move(optNet)) == Status::Success);
telsoa01c577f2c2018-08-31 09:22:23 +0100472}
473
Sadik Armagan1625efc2021-06-10 18:24:34 +0100474TEST_CASE("RuntimeFallbackToCpuRef")
telsoa01c577f2c2018-08-31 09:22:23 +0100475{
476 using namespace armnn;
477
478 // Create runtime in which test will run
479 armnn::IRuntime::CreationOptions options;
Keith Davis97da5e22020-03-05 16:25:28 +0000480 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
telsoa01c577f2c2018-08-31 09:22:23 +0100481
482 // build up the structure of the network
483 INetworkPtr net(INetwork::Create());
484
485 IConnectableLayer* input = net->AddInputLayer(0);
486
487 // This layer configuration isn't supported by CpuAcc, should be fall back to CpuRef.
488 NormalizationDescriptor descriptor;
489 IConnectableLayer* normalize = net->AddNormalizationLayer(descriptor);
490
491 IConnectableLayer* output = net->AddOutputLayer(0);
492
493 input->GetOutputSlot(0).Connect(normalize->GetInputSlot(0));
494 normalize->GetOutputSlot(0).Connect(output->GetInputSlot(0));
495
496 input->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
497 normalize->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
498
499 // Allow fallback to CpuRef.
David Beckf0b48452018-10-19 15:20:56 +0100500 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc, armnn::Compute::CpuRef };
telsoa01c577f2c2018-08-31 09:22:23 +0100501 // optimize the network
Keith Davis97da5e22020-03-05 16:25:28 +0000502 IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime->GetDeviceSpec());
telsoa01c577f2c2018-08-31 09:22:23 +0100503
504 // Load it into the runtime. It should succeed.
505 armnn::NetworkId netId;
Sadik Armagan1625efc2021-06-10 18:24:34 +0100506 CHECK(runtime->LoadNetwork(netId, std::move(optNet)) == Status::Success);
telsoa01c577f2c2018-08-31 09:22:23 +0100507}
508
Sadik Armagan1625efc2021-06-10 18:24:34 +0100509TEST_CASE("IVGCVSW_1929_QuantizedSoftmaxIssue")
jimfly016b0b53d2018-10-08 14:43:01 +0100510{
511 // Test for issue reported by Chris Nix in https://jira.arm.com/browse/IVGCVSW-1929
512 using namespace armnn;
513
514 // Create runtime in which test will run
515 armnn::IRuntime::CreationOptions options;
Keith Davis97da5e22020-03-05 16:25:28 +0000516 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
jimfly016b0b53d2018-10-08 14:43:01 +0100517
518 // build up the structure of the network
519 INetworkPtr net(INetwork::Create());
Keith Davis97da5e22020-03-05 16:25:28 +0000520 armnn::IConnectableLayer* input = net->AddInputLayer(0,"input");
521 armnn::IConnectableLayer* softmax = net->AddSoftmaxLayer(armnn::SoftmaxDescriptor(), "softmax");
522 armnn::IConnectableLayer* output = net->AddOutputLayer(0, "output");
jimfly016b0b53d2018-10-08 14:43:01 +0100523
524 input->GetOutputSlot(0).Connect(softmax->GetInputSlot(0));
525 softmax->GetOutputSlot(0).Connect(output->GetInputSlot(0));
526
Keith Davis97da5e22020-03-05 16:25:28 +0000527 input->GetOutputSlot(0).SetTensorInfo(armnn::TensorInfo(armnn::TensorShape({ 1, 5 }),
528 armnn::DataType::QAsymmU8,
529 1.0f / 255,
530 0));
jimfly016b0b53d2018-10-08 14:43:01 +0100531
Keith Davis97da5e22020-03-05 16:25:28 +0000532 softmax->GetOutputSlot(0).SetTensorInfo(armnn::TensorInfo(armnn::TensorShape({ 1, 5 }),
533 armnn::DataType::QAsymmU8));
jimfly016b0b53d2018-10-08 14:43:01 +0100534
Keith Davis97da5e22020-03-05 16:25:28 +0000535 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
536 std::vector<std::string> errMessages;
Mike Kelly3a613cc2020-09-29 20:50:35 +0100537
538 try
539 {
540 armnn::IOptimizedNetworkPtr optNet = Optimize(*net,
Keith Davis97da5e22020-03-05 16:25:28 +0000541 backends,
542 runtime->GetDeviceSpec(),
543 OptimizerOptions(),
544 errMessages);
Sadik Armagan1625efc2021-06-10 18:24:34 +0100545 FAIL("An exception should have been thrown");
Mike Kelly3a613cc2020-09-29 20:50:35 +0100546 }
Cathal Corbett5aa9fd72022-02-25 15:33:28 +0000547 catch (const armnn::InvalidArgumentException&)
Mike Kelly3a613cc2020-09-29 20:50:35 +0100548 {
549 // Different exceptions are thrown on different backends
550 }
Sadik Armagan1625efc2021-06-10 18:24:34 +0100551 CHECK(errMessages.size() > 0);
jimfly016b0b53d2018-10-08 14:43:01 +0100552}
553
Sadik Armagan1625efc2021-06-10 18:24:34 +0100554TEST_CASE("RuntimeBackendOptions")
Derek Lamberti836b27b2019-11-20 10:51:57 +0000555{
556 using namespace armnn;
557
558 IRuntime::CreationOptions creationOptions;
559 auto& backendOptions = creationOptions.m_BackendOptions;
560
561
562 // Define Options on explicit construction
563 BackendOptions options1("FakeBackend1",
Keith Davis97da5e22020-03-05 16:25:28 +0000564 {
565 { "Option1", 1.3f },
566 { "Option2", true }
567 });
Derek Lamberti836b27b2019-11-20 10:51:57 +0000568
569 // Add an option after construction
Keith Davis97da5e22020-03-05 16:25:28 +0000570 options1.AddOption({ "Option3", "some_value" });
Derek Lamberti836b27b2019-11-20 10:51:57 +0000571
572 // Add the options to CreationOptions struct
573 backendOptions.push_back(options1);
574
575 // Add more Options via inplace explicit construction
Keith Davis97da5e22020-03-05 16:25:28 +0000576 backendOptions.emplace_back(BackendOptions{ "FakeBackend1",
577 {{ "Option4", 42 }}
578 });
Derek Lamberti836b27b2019-11-20 10:51:57 +0000579
580
581 // First group
Sadik Armagan1625efc2021-06-10 18:24:34 +0100582 CHECK(backendOptions[0].GetBackendId().Get() == "FakeBackend1");
583 CHECK(backendOptions[0].GetOption(0).GetName() == "Option1");
584 CHECK(backendOptions[0].GetOption(0).GetValue().IsFloat() == true);
585 CHECK(backendOptions[0].GetOption(0).GetValue().AsFloat() == 1.3f);
Derek Lamberti836b27b2019-11-20 10:51:57 +0000586
Sadik Armagan1625efc2021-06-10 18:24:34 +0100587 CHECK(backendOptions[0].GetOption(1).GetName() == "Option2");
588 CHECK(backendOptions[0].GetOption(1).GetValue().IsBool() == true);
589 CHECK(backendOptions[0].GetOption(1).GetValue().AsBool() == true);
Derek Lamberti836b27b2019-11-20 10:51:57 +0000590
Sadik Armagan1625efc2021-06-10 18:24:34 +0100591 CHECK(backendOptions[0].GetOption(2).GetName() == "Option3");
592 CHECK(backendOptions[0].GetOption(2).GetValue().IsString() == true);
593 CHECK(backendOptions[0].GetOption(2).GetValue().AsString() == "some_value");
Derek Lamberti836b27b2019-11-20 10:51:57 +0000594
595 // Second group
Sadik Armagan1625efc2021-06-10 18:24:34 +0100596 CHECK(backendOptions[1].GetBackendId().Get() == "FakeBackend1");
597 CHECK(backendOptions[1].GetOption(0).GetName() == "Option4");
598 CHECK(backendOptions[1].GetOption(0).GetValue().IsInt() == true);
599 CHECK(backendOptions[1].GetOption(0).GetValue().AsInt() == 42);
Derek Lamberti836b27b2019-11-20 10:51:57 +0000600}
601
Sadik Armagan1625efc2021-06-10 18:24:34 +0100602TEST_CASE("ProfilingDisable")
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000603{
604 using namespace armnn;
605
Jim Flynn6c9f17d2022-03-10 23:13:01 +0000606 LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal);
607
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000608 // Create runtime in which the test will run
609 armnn::IRuntime::CreationOptions options;
Kevin Mayd92a6e42021-02-04 10:27:41 +0000610 armnn::RuntimeImpl runtime(options);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000611
612 // build up the structure of the network
613 INetworkPtr net(INetwork::Create());
614
615 IConnectableLayer* input = net->AddInputLayer(0);
616
617 // This layer configuration isn't supported by CpuAcc, should fall back to CpuRef.
618 NormalizationDescriptor descriptor;
619 IConnectableLayer* normalize = net->AddNormalizationLayer(descriptor);
620
621 IConnectableLayer* output = net->AddOutputLayer(0);
622
623 input->GetOutputSlot(0).Connect(normalize->GetInputSlot(0));
624 normalize->GetOutputSlot(0).Connect(output->GetInputSlot(0));
625
626 input->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
627 normalize->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
628
629 // optimize the network
630 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
Sadik Armagan3184c902020-03-18 10:57:30 +0000631 IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime.GetDeviceSpec());
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000632
633 // Load it into the runtime. It should succeed.
634 armnn::NetworkId netId;
Sadik Armagan1625efc2021-06-10 18:24:34 +0100635 CHECK(runtime.LoadNetwork(netId, std::move(optNet)) == Status::Success);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000636
Jim Flynn34430252022-03-04 15:03:58 +0000637 armnn::ArmNNProfilingServiceInitialiser initialiser;
638 ProfilingServiceRuntimeHelper profilingServiceHelper(
639 arm::pipe::MAX_ARMNN_COUNTER, initialiser, GetProfilingService(&runtime));
Cathal Corbett5aa9fd72022-02-25 15:33:28 +0000640 BufferManager& bufferManager = profilingServiceHelper.GetProfilingBufferManager();
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000641 auto readableBuffer = bufferManager.GetReadableBuffer();
642
643 // Profiling is not enabled, the post-optimisation structure should not be created
Sadik Armagan1625efc2021-06-10 18:24:34 +0100644 CHECK(!readableBuffer);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000645}
646
Sadik Armagan1625efc2021-06-10 18:24:34 +0100647TEST_CASE("ProfilingEnableCpuRef")
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000648{
649 using namespace armnn;
Cathal Corbett5aa9fd72022-02-25 15:33:28 +0000650 using namespace arm::pipe;
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000651
652 // Create runtime in which the test will run
653 armnn::IRuntime::CreationOptions options;
654 options.m_ProfilingOptions.m_EnableProfiling = true;
Keith Davis33ed2212020-03-30 10:43:41 +0100655 options.m_ProfilingOptions.m_TimelineEnabled = true;
656
Kevin Mayd92a6e42021-02-04 10:27:41 +0000657 armnn::RuntimeImpl runtime(options);
Jim Flynn4c9ed1d2022-01-23 23:57:20 +0000658 GetProfilingService(&runtime).ResetExternalProfilingOptions(
659 ConvertExternalProfilingOptions(options.m_ProfilingOptions), false);
Keith Davis33ed2212020-03-30 10:43:41 +0100660
Jim Flynn34430252022-03-04 15:03:58 +0000661 armnn::ArmNNProfilingServiceInitialiser initialiser;
662 ProfilingServiceRuntimeHelper profilingServiceHelper(
663 arm::pipe::MAX_ARMNN_COUNTER, initialiser, GetProfilingService(&runtime));
Keith Davis33ed2212020-03-30 10:43:41 +0100664 profilingServiceHelper.ForceTransitionToState(ProfilingState::NotConnected);
665 profilingServiceHelper.ForceTransitionToState(ProfilingState::WaitingForAck);
666 profilingServiceHelper.ForceTransitionToState(ProfilingState::Active);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000667
668 // build up the structure of the network
669 INetworkPtr net(INetwork::Create());
670
671 IConnectableLayer* input = net->AddInputLayer(0, "input");
672
673 NormalizationDescriptor descriptor;
674 IConnectableLayer* normalize = net->AddNormalizationLayer(descriptor, "normalization");
675
676 IConnectableLayer* output = net->AddOutputLayer(0, "output");
677
678 input->GetOutputSlot(0).Connect(normalize->GetInputSlot(0));
679 normalize->GetOutputSlot(0).Connect(output->GetInputSlot(0));
680
681 input->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
682 normalize->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
683
684 // optimize the network
685 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
Sadik Armagan3184c902020-03-18 10:57:30 +0000686 IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime.GetDeviceSpec());
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000687
688 ProfilingGuid optNetGuid = optNet->GetGuid();
689
690 // Load it into the runtime. It should succeed.
691 armnn::NetworkId netId;
Sadik Armagan1625efc2021-06-10 18:24:34 +0100692 CHECK(runtime.LoadNetwork(netId, std::move(optNet)) == Status::Success);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000693
Cathal Corbett5aa9fd72022-02-25 15:33:28 +0000694 BufferManager& bufferManager = profilingServiceHelper.GetProfilingBufferManager();
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000695 auto readableBuffer = bufferManager.GetReadableBuffer();
696
697 // Profiling is enabled, the post-optimisation structure should be created
Sadik Armagan1625efc2021-06-10 18:24:34 +0100698 CHECK(readableBuffer != nullptr);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000699
700 unsigned int size = readableBuffer->GetSize();
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000701
702 const unsigned char* readableData = readableBuffer->GetReadableData();
Sadik Armagan1625efc2021-06-10 18:24:34 +0100703 CHECK(readableData != nullptr);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000704
705 unsigned int offset = 0;
706
Keith Davis97da5e22020-03-05 16:25:28 +0000707 // Verify Header
Jim Flynnf7713212020-07-14 09:50:59 +0100708 VerifyTimelineHeaderBinary(readableData, offset, size - 8);
Keith Davis97da5e22020-03-05 16:25:28 +0000709
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000710 // Post-optimisation network
711 // Network entity
Jim Flynn6398a982020-05-27 17:05:21 +0100712 VerifyTimelineEntityBinaryPacketData(optNetGuid, readableData, offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000713
714 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000715 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000716 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000717 optNetGuid,
718 LabelsAndEventClasses::NETWORK_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000719 LabelsAndEventClasses::TYPE_GUID,
720 readableData,
721 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000722
Jim Flynnf7713212020-07-14 09:50:59 +0100723 // Network - START OF LIFE
Jim Flynndecd08b2022-03-13 22:35:46 +0000724 ProfilingGuid networkSolEventGuid = VerifyTimelineEventBinaryPacket(arm::pipe::EmptyOptional(),
725 arm::pipe::EmptyOptional(),
726 arm::pipe::EmptyOptional(),
Jim Flynnf7713212020-07-14 09:50:59 +0100727 readableData,
728 offset);
Jim Flynnf7713212020-07-14 09:50:59 +0100729
730 // Network - START OF LIFE event relationship
731 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000732 arm::pipe::EmptyOptional(),
Jim Flynnf7713212020-07-14 09:50:59 +0100733 optNetGuid,
734 networkSolEventGuid,
735 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
736 readableData,
737 offset);
Jim Flynnf7713212020-07-14 09:50:59 +0100738
739 // Process ID Label
Jim Flynn9c85b412022-03-16 00:27:43 +0000740 int processID = arm::pipe::GetCurrentProcessId();
Jim Flynnf7713212020-07-14 09:50:59 +0100741 std::stringstream ss;
742 ss << processID;
743 std::string processIdLabel = ss.str();
Jim Flynndecd08b2022-03-13 22:35:46 +0000744 VerifyTimelineLabelBinaryPacketData(arm::pipe::EmptyOptional(), processIdLabel, readableData, offset);
Jim Flynnf7713212020-07-14 09:50:59 +0100745
746 // Entity - Process ID relationship
747 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000748 arm::pipe::EmptyOptional(),
Jim Flynnf7713212020-07-14 09:50:59 +0100749 optNetGuid,
Jim Flynndecd08b2022-03-13 22:35:46 +0000750 arm::pipe::EmptyOptional(),
Jim Flynnf7713212020-07-14 09:50:59 +0100751 LabelsAndEventClasses::PROCESS_ID_GUID,
752 readableData,
753 offset);
Jim Flynnf7713212020-07-14 09:50:59 +0100754
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000755 // Input layer
756 // Input layer entity
Keith Davis97da5e22020-03-05 16:25:28 +0000757 VerifyTimelineEntityBinaryPacketData(input->GetGuid(), readableData, offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000758
759 // Name Entity
Jim Flynndecd08b2022-03-13 22:35:46 +0000760 ProfilingGuid inputLabelGuid = VerifyTimelineLabelBinaryPacketData(
761 arm::pipe::EmptyOptional(), "input", readableData, offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000762
763 // Entity - Name relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000764 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000765 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000766 input->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100767 inputLabelGuid,
Keith Davis97da5e22020-03-05 16:25:28 +0000768 LabelsAndEventClasses::NAME_GUID,
769 readableData,
770 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000771
772 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000773 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000774 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000775 input->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100776 LabelsAndEventClasses::LAYER_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000777 LabelsAndEventClasses::TYPE_GUID,
778 readableData,
779 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000780
781 // Network - Input layer relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000782 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000783 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000784 optNetGuid,
785 input->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100786 LabelsAndEventClasses::CHILD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000787 readableData,
788 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000789
790 // Normalization layer
791 // Normalization layer entity
Keith Davis97da5e22020-03-05 16:25:28 +0000792 VerifyTimelineEntityBinaryPacketData(normalize->GetGuid(), readableData, offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000793
794 // Name entity
Jim Flynn6398a982020-05-27 17:05:21 +0100795 ProfilingGuid normalizationLayerNameGuid = VerifyTimelineLabelBinaryPacketData(
Jim Flynndecd08b2022-03-13 22:35:46 +0000796 arm::pipe::EmptyOptional(), "normalization", readableData, offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000797
798 // Entity - Name relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000799 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000800 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000801 normalize->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100802 normalizationLayerNameGuid,
Keith Davis97da5e22020-03-05 16:25:28 +0000803 LabelsAndEventClasses::NAME_GUID,
804 readableData,
805 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000806
807 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000808 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000809 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000810 normalize->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100811 LabelsAndEventClasses::LAYER_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000812 LabelsAndEventClasses::TYPE_GUID,
813 readableData,
814 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000815
816 // Network - Normalize layer relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000817 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000818 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000819 optNetGuid,
820 normalize->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100821 LabelsAndEventClasses::CHILD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000822 readableData,
823 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000824
825 // Input layer - Normalize layer relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000826 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000827 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000828 input->GetGuid(),
829 normalize->GetGuid(),
Keith Davis97da5e22020-03-05 16:25:28 +0000830 LabelsAndEventClasses::CONNECTION_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000831 readableData,
832 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000833
834 // Normalization workload
835 // Normalization workload entity
Jim Flynn6398a982020-05-27 17:05:21 +0100836 ProfilingGuid normalizationWorkloadGuid = VerifyTimelineEntityBinaryPacketData(
Jim Flynndecd08b2022-03-13 22:35:46 +0000837 arm::pipe::EmptyOptional(), readableData, offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000838
839 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000840 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000841 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +0100842 normalizationWorkloadGuid,
843 LabelsAndEventClasses::WORKLOAD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000844 LabelsAndEventClasses::TYPE_GUID,
845 readableData,
846 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000847
848 // BackendId entity
Jim Flynn6398a982020-05-27 17:05:21 +0100849 ProfilingGuid cpuRefLabelGuid = VerifyTimelineLabelBinaryPacketData(
Jim Flynndecd08b2022-03-13 22:35:46 +0000850 arm::pipe::EmptyOptional(), "CpuRef", readableData, offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000851
852 // Entity - BackendId relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000853 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000854 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +0100855 normalizationWorkloadGuid,
856 cpuRefLabelGuid,
Keith Davis97da5e22020-03-05 16:25:28 +0000857 LabelsAndEventClasses::BACKENDID_GUID,
858 readableData,
859 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000860
861 // Normalize layer - Normalize workload relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000862 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000863 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000864 normalize->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100865 normalizationWorkloadGuid,
866 LabelsAndEventClasses::CHILD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000867 readableData,
868 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000869
870 // Output layer
871 // Output layer entity
Keith Davis97da5e22020-03-05 16:25:28 +0000872 VerifyTimelineEntityBinaryPacketData(output->GetGuid(), readableData, offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000873
874 // Name entity
Jim Flynn6398a982020-05-27 17:05:21 +0100875 ProfilingGuid outputLabelGuid = VerifyTimelineLabelBinaryPacketData(
Jim Flynndecd08b2022-03-13 22:35:46 +0000876 arm::pipe::EmptyOptional(), "output", readableData, offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000877
878 // Entity - Name relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000879 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000880 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000881 output->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100882 outputLabelGuid,
Keith Davis97da5e22020-03-05 16:25:28 +0000883 LabelsAndEventClasses::NAME_GUID,
884 readableData,
885 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000886
887 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000888 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000889 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000890 output->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100891 LabelsAndEventClasses::LAYER_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000892 LabelsAndEventClasses::TYPE_GUID,
893 readableData,
894 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000895
896 // Network - Output layer relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000897 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000898 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000899 optNetGuid,
900 output->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100901 LabelsAndEventClasses::CHILD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000902 readableData,
903 offset);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000904
905 // Normalize layer - Output layer relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000906 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000907 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000908 normalize->GetGuid(),
909 output->GetGuid(),
Keith Davis97da5e22020-03-05 16:25:28 +0000910 LabelsAndEventClasses::CONNECTION_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000911 readableData,
912 offset);
Derek Lamberti836b27b2019-11-20 10:51:57 +0000913
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +0000914 bufferManager.MarkRead(readableBuffer);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000915
916 // Creates structures for input & output.
917 std::vector<float> inputData(16);
918 std::vector<float> outputData(16);
919
Cathal Corbett5b8093c2021-10-22 11:12:07 +0100920 TensorInfo inputTensorInfo = runtime.GetInputTensorInfo(netId, 0);
921 inputTensorInfo.SetConstant(true);
Keith Davis97da5e22020-03-05 16:25:28 +0000922 InputTensors inputTensors
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000923 {
Cathal Corbett5b8093c2021-10-22 11:12:07 +0100924 {0, ConstTensor(inputTensorInfo, inputData.data())}
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000925 };
926 OutputTensors outputTensors
927 {
Sadik Armagan3184c902020-03-18 10:57:30 +0000928 {0, Tensor(runtime.GetOutputTensorInfo(netId, 0), outputData.data())}
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000929 };
930
931 // Does the inference.
Sadik Armagan3184c902020-03-18 10:57:30 +0000932 runtime.EnqueueWorkload(netId, inputTensors, outputTensors);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000933
Finn Williamsb6a402f2020-03-24 13:46:22 +0000934 // Get readable buffer for input workload
935 auto inputReadableBuffer = bufferManager.GetReadableBuffer();
Sadik Armagan1625efc2021-06-10 18:24:34 +0100936 CHECK(inputReadableBuffer != nullptr);
David Monahan6198fe02019-12-02 08:35:43 +0000937
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000938 // Get readable buffer for output workload
939 auto outputReadableBuffer = bufferManager.GetReadableBuffer();
Sadik Armagan1625efc2021-06-10 18:24:34 +0100940 CHECK(outputReadableBuffer != nullptr);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000941
Finn Williamsb6a402f2020-03-24 13:46:22 +0000942 // Get readable buffer for inference timeline
943 auto inferenceReadableBuffer = bufferManager.GetReadableBuffer();
Sadik Armagan1625efc2021-06-10 18:24:34 +0100944 CHECK(inferenceReadableBuffer != nullptr);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000945
946 // Validate input workload data
947 size = inputReadableBuffer->GetSize();
Sadik Armagan1625efc2021-06-10 18:24:34 +0100948 CHECK(size == 164);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000949
950 readableData = inputReadableBuffer->GetReadableData();
Sadik Armagan1625efc2021-06-10 18:24:34 +0100951 CHECK(readableData != nullptr);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000952
953 offset = 0;
954
Keith Davis97da5e22020-03-05 16:25:28 +0000955 // Verify Header
Finn Williams0a336dc2020-05-11 15:39:58 +0100956 VerifyTimelineHeaderBinary(readableData, offset, 156);
Keith Davis97da5e22020-03-05 16:25:28 +0000957
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000958 // Input workload
959 // Input workload entity
Jim Flynndecd08b2022-03-13 22:35:46 +0000960 ProfilingGuid inputWorkloadGuid = VerifyTimelineEntityBinaryPacketData(
961 arm::pipe::EmptyOptional(), readableData, offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000962
963 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000964 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000965 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +0100966 inputWorkloadGuid,
967 LabelsAndEventClasses::WORKLOAD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000968 LabelsAndEventClasses::TYPE_GUID,
969 readableData,
970 offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000971
972 // BackendId entity
Jim Flynn6398a982020-05-27 17:05:21 +0100973 ProfilingGuid CpuRefLabelGuid = VerifyTimelineLabelBinaryPacketData(
Jim Flynndecd08b2022-03-13 22:35:46 +0000974 arm::pipe::EmptyOptional(), "CpuRef", readableData, offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000975
976 // Entity - BackendId relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000977 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000978 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +0100979 inputWorkloadGuid,
980 CpuRefLabelGuid,
Keith Davis97da5e22020-03-05 16:25:28 +0000981 LabelsAndEventClasses::BACKENDID_GUID,
982 readableData,
983 offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000984
985 // Input layer - Input workload relationship
Keith Davis97da5e22020-03-05 16:25:28 +0000986 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +0000987 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +0000988 input->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +0100989 inputWorkloadGuid,
990 LabelsAndEventClasses::CHILD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +0000991 readableData,
992 offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000993
994 bufferManager.MarkRead(inputReadableBuffer);
995
996 // Validate output workload data
997 size = outputReadableBuffer->GetSize();
Sadik Armagan1625efc2021-06-10 18:24:34 +0100998 CHECK(size == 164);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +0000999
1000 readableData = outputReadableBuffer->GetReadableData();
Sadik Armagan1625efc2021-06-10 18:24:34 +01001001 CHECK(readableData != nullptr);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +00001002
1003 offset = 0;
1004
Keith Davis97da5e22020-03-05 16:25:28 +00001005 // Verify Header
Finn Williams0a336dc2020-05-11 15:39:58 +01001006 VerifyTimelineHeaderBinary(readableData, offset, 156);
Keith Davis97da5e22020-03-05 16:25:28 +00001007
Narumol Prangnawarataa68e012019-11-29 17:17:43 +00001008 // Output workload
1009 // Output workload entity
Jim Flynndecd08b2022-03-13 22:35:46 +00001010 ProfilingGuid outputWorkloadGuid = VerifyTimelineEntityBinaryPacketData(
1011 arm::pipe::EmptyOptional(), readableData, offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +00001012
1013 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001014 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001015 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001016 outputWorkloadGuid,
1017 LabelsAndEventClasses::WORKLOAD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001018 LabelsAndEventClasses::TYPE_GUID,
1019 readableData,
1020 offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +00001021
1022 // BackendId entity
Jim Flynndecd08b2022-03-13 22:35:46 +00001023 VerifyTimelineLabelBinaryPacketData(arm::pipe::EmptyOptional(), "CpuRef", readableData, offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +00001024
1025 // Entity - BackendId relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001026 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001027 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001028 outputWorkloadGuid,
1029 CpuRefLabelGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001030 LabelsAndEventClasses::BACKENDID_GUID,
1031 readableData,
1032 offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +00001033
1034 // Output layer - Output workload relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001035 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001036 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +00001037 output->GetGuid(),
Jim Flynn6398a982020-05-27 17:05:21 +01001038 outputWorkloadGuid,
1039 LabelsAndEventClasses::CHILD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001040 readableData,
1041 offset);
Narumol Prangnawarataa68e012019-11-29 17:17:43 +00001042
1043 bufferManager.MarkRead(outputReadableBuffer);
David Monahan6198fe02019-12-02 08:35:43 +00001044
1045 // Validate inference data
1046 size = inferenceReadableBuffer->GetSize();
Sadik Armagan1625efc2021-06-10 18:24:34 +01001047 CHECK(size == 976 + 8 * ThreadIdSize);
David Monahan6198fe02019-12-02 08:35:43 +00001048
1049 readableData = inferenceReadableBuffer->GetReadableData();
Sadik Armagan1625efc2021-06-10 18:24:34 +01001050 CHECK(readableData != nullptr);
David Monahan6198fe02019-12-02 08:35:43 +00001051
1052 offset = 0;
1053
Keith Davis97da5e22020-03-05 16:25:28 +00001054 // Verify Header
Finn Williams0a336dc2020-05-11 15:39:58 +01001055 VerifyTimelineHeaderBinary(readableData, offset, 968 + 8 * ThreadIdSize);
Keith Davis97da5e22020-03-05 16:25:28 +00001056
David Monahan6198fe02019-12-02 08:35:43 +00001057 // Inference timeline trace
1058 // Inference entity
Jim Flynndecd08b2022-03-13 22:35:46 +00001059 ProfilingGuid inferenceGuid = VerifyTimelineEntityBinaryPacketData(
1060 arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001061
1062 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001063 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001064 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001065 inferenceGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001066 LabelsAndEventClasses::INFERENCE_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001067 LabelsAndEventClasses::TYPE_GUID,
1068 readableData,
1069 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001070
1071 // Network - Inference relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001072 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001073 arm::pipe::EmptyOptional(),
Keith Davis97da5e22020-03-05 16:25:28 +00001074 optNetGuid,
Jim Flynn6398a982020-05-27 17:05:21 +01001075 inferenceGuid,
1076 LabelsAndEventClasses::EXECUTION_OF_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001077 readableData,
1078 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001079
1080 // Start Inference life
1081 // Event packet - timeline, threadId, eventGuid
Jim Flynn6398a982020-05-27 17:05:21 +01001082 ProfilingGuid inferenceEventGuid = VerifyTimelineEventBinaryPacket(
Jim Flynndecd08b2022-03-13 22:35:46 +00001083 arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001084
1085 // Inference - event relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001086 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001087 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001088 inferenceGuid,
1089 inferenceEventGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001090 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1091 readableData,
1092 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001093
1094 // Execution
1095 // Input workload execution
1096 // Input workload execution entity
Jim Flynn6398a982020-05-27 17:05:21 +01001097 ProfilingGuid inputWorkloadExecutionGuid = VerifyTimelineEntityBinaryPacketData(
Jim Flynndecd08b2022-03-13 22:35:46 +00001098 arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001099
1100 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001101 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001102 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001103 inputWorkloadExecutionGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001104 LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001105 LabelsAndEventClasses::TYPE_GUID,
1106 readableData,
1107 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001108
1109 // Inference - Workload execution relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001110 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001111 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001112 inferenceGuid,
1113 inputWorkloadExecutionGuid,
1114 LabelsAndEventClasses::CHILD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001115 readableData,
1116 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001117
1118 // Workload - Workload execution relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001119 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001120 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001121 inputWorkloadGuid,
1122 inputWorkloadExecutionGuid,
1123 LabelsAndEventClasses::EXECUTION_OF_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001124 readableData,
1125 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001126
1127 // Start Input workload execution life
1128 // Event packet - timeline, threadId, eventGuid
Jim Flynn6398a982020-05-27 17:05:21 +01001129 ProfilingGuid inputWorkloadExecutionSOLEventId = VerifyTimelineEventBinaryPacket(
Jim Flynndecd08b2022-03-13 22:35:46 +00001130 arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001131
1132 // Input workload execution - event relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001133 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001134 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001135 inputWorkloadExecutionGuid,
1136 inputWorkloadExecutionSOLEventId,
Keith Davis97da5e22020-03-05 16:25:28 +00001137 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1138 readableData,
1139 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001140
1141 // End of Input workload execution life
1142 // Event packet - timeline, threadId, eventGuid
Jim Flynn6398a982020-05-27 17:05:21 +01001143 ProfilingGuid inputWorkloadExecutionEOLEventId = VerifyTimelineEventBinaryPacket(
Jim Flynndecd08b2022-03-13 22:35:46 +00001144 arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001145
1146 // Input workload execution - event relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001147 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001148 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001149 inputWorkloadExecutionGuid,
1150 inputWorkloadExecutionEOLEventId,
Keith Davis97da5e22020-03-05 16:25:28 +00001151 LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1152 readableData,
1153 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001154
1155 // Normalize workload execution
1156 // Normalize workload execution entity
Jim Flynn6398a982020-05-27 17:05:21 +01001157 ProfilingGuid normalizeWorkloadExecutionGuid = VerifyTimelineEntityBinaryPacketData(
Jim Flynndecd08b2022-03-13 22:35:46 +00001158 arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001159
1160 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001161 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001162 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001163 normalizeWorkloadExecutionGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001164 LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001165 LabelsAndEventClasses::TYPE_GUID,
1166 readableData,
1167 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001168
1169 // Inference - Workload execution relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001170 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001171 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001172 inferenceGuid,
1173 normalizeWorkloadExecutionGuid,
1174 LabelsAndEventClasses::CHILD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001175 readableData,
1176 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001177
1178 // Workload - Workload execution relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001179 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001180 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001181 normalizationWorkloadGuid,
1182 normalizeWorkloadExecutionGuid,
1183 LabelsAndEventClasses::EXECUTION_OF_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001184 readableData,
1185 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001186
1187 // Start Normalize workload execution life
1188 // Event packet - timeline, threadId, eventGuid
Jim Flynn6398a982020-05-27 17:05:21 +01001189 ProfilingGuid normalizationWorkloadExecutionSOLEventGuid = VerifyTimelineEventBinaryPacket(
Jim Flynndecd08b2022-03-13 22:35:46 +00001190 arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001191
1192 // Normalize workload execution - event relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001193 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001194 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001195 normalizeWorkloadExecutionGuid,
1196 normalizationWorkloadExecutionSOLEventGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001197 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1198 readableData,
1199 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001200
1201 // End of Normalize workload execution life
1202 // Event packet - timeline, threadId, eventGuid
Jim Flynn6398a982020-05-27 17:05:21 +01001203 ProfilingGuid normalizationWorkloadExecutionEOLEventGuid = VerifyTimelineEventBinaryPacket(
Jim Flynndecd08b2022-03-13 22:35:46 +00001204 arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001205
1206 // Normalize workload execution - event relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001207 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001208 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001209 normalizeWorkloadExecutionGuid,
1210 normalizationWorkloadExecutionEOLEventGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001211 LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1212 readableData,
1213 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001214
1215 // Output workload execution
1216 // Output workload execution entity
Jim Flynn6398a982020-05-27 17:05:21 +01001217 ProfilingGuid outputWorkloadExecutionGuid = VerifyTimelineEntityBinaryPacketData(
Jim Flynndecd08b2022-03-13 22:35:46 +00001218 arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001219
1220 // Entity - Type relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001221 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001222 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001223 outputWorkloadExecutionGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001224 LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001225 LabelsAndEventClasses::TYPE_GUID,
1226 readableData,
1227 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001228
1229 // Inference - Workload execution relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001230 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001231 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001232 inferenceGuid,
1233 outputWorkloadExecutionGuid,
1234 LabelsAndEventClasses::CHILD_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001235 readableData,
1236 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001237
1238 // Workload - Workload execution relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001239 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001240 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001241 outputWorkloadGuid,
1242 outputWorkloadExecutionGuid,
1243 LabelsAndEventClasses::EXECUTION_OF_GUID,
Keith Davis97da5e22020-03-05 16:25:28 +00001244 readableData,
1245 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001246
1247 // Start Output workload execution life
1248 // Event packet - timeline, threadId, eventGuid
Jim Flynn6398a982020-05-27 17:05:21 +01001249 ProfilingGuid outputWorkloadExecutionSOLEventGuid = VerifyTimelineEventBinaryPacket(
Jim Flynndecd08b2022-03-13 22:35:46 +00001250 arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001251
1252 // Output workload execution - event relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001253 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001254 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001255 outputWorkloadExecutionGuid,
1256 outputWorkloadExecutionSOLEventGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001257 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1258 readableData,
1259 offset);
Finn Williams0a336dc2020-05-11 15:39:58 +01001260
David Monahan6198fe02019-12-02 08:35:43 +00001261 // End of Normalize workload execution life
1262 // Event packet - timeline, threadId, eventGuid
Jim Flynn6398a982020-05-27 17:05:21 +01001263 ProfilingGuid outputWorkloadExecutionEOLEventGuid = VerifyTimelineEventBinaryPacket(
Jim Flynndecd08b2022-03-13 22:35:46 +00001264 arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001265
1266 // Output workload execution - event relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001267 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001268 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001269 outputWorkloadExecutionGuid,
1270 outputWorkloadExecutionEOLEventGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001271 LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1272 readableData,
1273 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001274
1275 // End of Inference life
1276 // Event packet - timeline, threadId, eventGuid
Jim Flynn6398a982020-05-27 17:05:21 +01001277 ProfilingGuid inferenceEOLEventGuid = VerifyTimelineEventBinaryPacket(
Jim Flynndecd08b2022-03-13 22:35:46 +00001278 arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), arm::pipe::EmptyOptional(), readableData, offset);
David Monahan6198fe02019-12-02 08:35:43 +00001279
1280 // Inference - event relationship
Keith Davis97da5e22020-03-05 16:25:28 +00001281 VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
Jim Flynndecd08b2022-03-13 22:35:46 +00001282 arm::pipe::EmptyOptional(),
Jim Flynn6398a982020-05-27 17:05:21 +01001283 inferenceGuid,
1284 inferenceEOLEventGuid,
Keith Davis97da5e22020-03-05 16:25:28 +00001285 LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1286 readableData,
1287 offset);
David Monahan6198fe02019-12-02 08:35:43 +00001288
1289 bufferManager.MarkRead(inferenceReadableBuffer);
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +00001290}
1291
Sadik Armagan1625efc2021-06-10 18:24:34 +01001292TEST_CASE("ProfilingPostOptimisationStructureCpuRef")
Narumol Prangnawaratdf31cfe2019-11-22 11:26:06 +00001293{
1294 VerifyPostOptimisationStructureTestImpl(armnn::Compute::CpuRef);
1295}
1296
Colm Donelan03bf98a2022-05-30 15:20:36 +01001297TEST_CASE("RuntimeOptimizeImportOff_LoadNetworkImportOn")
1298{
1299 // In this test case we'll optimize a network with both import and export disabled. Then we'll attempt to load
1300 // that network but specify that the import memory source is Malloc.
1301
1302 armnn::IRuntime::CreationOptions options;
1303 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
1304 armnn::NetworkId networkId = 1;
1305 armnn::INetworkPtr testNetwork(armnn::INetwork::Create());
1306
1307 auto inputLayer1 = testNetwork->AddInputLayer(0, "input 1 layer");
1308 auto inputLayer2 = testNetwork->AddInputLayer(1, "input 2 layer");
1309 auto addLayer = testNetwork->AddAdditionLayer("add layer");
1310 auto outputLayer = testNetwork->AddOutputLayer(2, "output layer");
1311
1312 TensorInfo tensorInfo{{4}, armnn::DataType::Signed32};
1313
1314 inputLayer1->GetOutputSlot(0).Connect(addLayer->GetInputSlot(0));
1315 inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1316
1317 inputLayer2->GetOutputSlot(0).Connect(addLayer->GetInputSlot(1));
1318 inputLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1319
1320 addLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
1321 addLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1322
1323 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
1324
1325 OptimizerOptions optimizedOptions;
1326 // Hard set import and export to off.
1327 optimizedOptions.m_ImportEnabled = false;
1328 optimizedOptions.m_ExportEnabled = false;
1329 IOptimizedNetworkPtr optNet = Optimize(*testNetwork, backends, runtime->GetDeviceSpec(), optimizedOptions);
1330 CHECK(optNet);
1331
1332 std::string er;
1333 // Load the network passing an import memory source.
1334 armnn::INetworkProperties networkProperties1(true, MemorySource::Malloc, MemorySource::Undefined);
1335 // There should be an InvalidArgumentException.
1336 runtime->LoadNetwork(networkId, std::move(optNet), er, networkProperties1);
1337 CHECK(er.find("However, it was disabled when this network was optimized") != -1);
1338}
1339
1340TEST_CASE("RuntimeOptimizeExportOff_LoadNetworkExportOn")
1341{
1342 // In this test case we'll optimize a network with both import and export disabled. Then we'll attempt to load
1343 // that network but specify that the export memory source as Malloc.
1344
1345 armnn::IRuntime::CreationOptions options;
1346 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
1347 armnn::NetworkId networkId = 1;
1348 armnn::INetworkPtr testNetwork(armnn::INetwork::Create());
1349
1350 auto inputLayer1 = testNetwork->AddInputLayer(0, "input 1 layer");
1351 auto inputLayer2 = testNetwork->AddInputLayer(1, "input 2 layer");
1352 auto addLayer = testNetwork->AddAdditionLayer("add layer");
1353 auto outputLayer = testNetwork->AddOutputLayer(2, "output layer");
1354
1355 TensorInfo tensorInfo{{4}, armnn::DataType::Signed32};
1356
1357 inputLayer1->GetOutputSlot(0).Connect(addLayer->GetInputSlot(0));
1358 inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1359
1360 inputLayer2->GetOutputSlot(0).Connect(addLayer->GetInputSlot(1));
1361 inputLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1362
1363 addLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
1364 addLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1365
1366 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
1367
1368 OptimizerOptions optimizedOptions;
1369 // Hard set import and export to off.
1370 optimizedOptions.m_ImportEnabled = false;
1371 optimizedOptions.m_ExportEnabled = false;
1372 IOptimizedNetworkPtr optNet = Optimize(*testNetwork, backends, runtime->GetDeviceSpec(), optimizedOptions);
1373 CHECK(optNet);
1374
1375 std::string er;
1376 // Load the network passing an import memory source.
1377 armnn::INetworkProperties networkProperties1(true, MemorySource::Undefined, MemorySource::Malloc);
1378 // There should be an InvalidArgumentException.
1379 runtime->LoadNetwork(networkId, std::move(optNet), er, networkProperties1);
1380 CHECK(er.find("However, it was disabled when this network was optimized") != -1);
1381}
1382
1383TEST_CASE("RuntimeOptimizeImportOn_LoadNetworkImportOff")
1384{
1385 // In this test case we'll optimize a network with import enabled. Then we'll attempt to load
1386 // that network but specify that the import memory source is Undefined.
1387
1388 armnn::IRuntime::CreationOptions options;
1389 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
1390 armnn::NetworkId networkId = 1;
1391 armnn::INetworkPtr testNetwork(armnn::INetwork::Create());
1392
1393 auto inputLayer1 = testNetwork->AddInputLayer(0, "input 1 layer");
1394 auto inputLayer2 = testNetwork->AddInputLayer(1, "input 2 layer");
1395 auto addLayer = testNetwork->AddAdditionLayer("add layer");
1396 auto outputLayer = testNetwork->AddOutputLayer(2, "output layer");
1397
1398 TensorInfo tensorInfo{{4}, armnn::DataType::Signed32};
1399
1400 inputLayer1->GetOutputSlot(0).Connect(addLayer->GetInputSlot(0));
1401 inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1402
1403 inputLayer2->GetOutputSlot(0).Connect(addLayer->GetInputSlot(1));
1404 inputLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1405
1406 addLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
1407 addLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1408
1409 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
1410
1411 OptimizerOptions optimizedOptions;
1412 // Hard set import and export to off.
1413 optimizedOptions.m_ImportEnabled = true;
1414 optimizedOptions.m_ExportEnabled = false;
1415 IOptimizedNetworkPtr optNet = Optimize(*testNetwork, backends, runtime->GetDeviceSpec(), optimizedOptions);
1416 CHECK(optNet);
1417
1418 std::string er;
1419 // Load the network passing an import memory source.
1420 armnn::INetworkProperties networkProperties1(true, MemorySource::Undefined, MemorySource::Undefined);
1421 // There should be an InvalidArgumentException.
1422 runtime->LoadNetwork(networkId, std::move(optNet), er, networkProperties1);
1423 CHECK(er.find("However, it was enabled when this network was optimized") != -1);
1424}
1425
1426TEST_CASE("RuntimeOptimizeExportOn_LoadNetworkExportOff")
1427{
1428 // In this test case we'll optimize a network with export enabled. Then we'll attempt to load
1429 // that network but specify that the export memory source is Undefined.
1430
1431 armnn::IRuntime::CreationOptions options;
1432 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
1433 armnn::NetworkId networkId = 1;
1434 armnn::INetworkPtr testNetwork(armnn::INetwork::Create());
1435
1436 auto inputLayer1 = testNetwork->AddInputLayer(0, "input 1 layer");
1437 auto inputLayer2 = testNetwork->AddInputLayer(1, "input 2 layer");
1438 auto addLayer = testNetwork->AddAdditionLayer("add layer");
1439 auto outputLayer = testNetwork->AddOutputLayer(2, "output layer");
1440
1441 TensorInfo tensorInfo{{4}, armnn::DataType::Signed32};
1442
1443 inputLayer1->GetOutputSlot(0).Connect(addLayer->GetInputSlot(0));
1444 inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1445
1446 inputLayer2->GetOutputSlot(0).Connect(addLayer->GetInputSlot(1));
1447 inputLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1448
1449 addLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
1450 addLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
1451
1452 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
1453
1454 OptimizerOptions optimizedOptions;
1455 // Hard set import and export to off.
1456 optimizedOptions.m_ImportEnabled = false;
1457 optimizedOptions.m_ExportEnabled = true;
1458 IOptimizedNetworkPtr optNet = Optimize(*testNetwork, backends, runtime->GetDeviceSpec(), optimizedOptions);
1459 CHECK(optNet);
1460
1461 std::string er;
1462 // Load the network passing an import memory source.
1463 armnn::INetworkProperties networkProperties1(true, MemorySource::Undefined, MemorySource::Undefined);
1464 // There should be an InvalidArgumentException.
1465 runtime->LoadNetwork(networkId, std::move(optNet), er, networkProperties1);
1466 CHECK(er.find("However, it was enabled when this network was optimized") != -1);
1467}
1468
Sadik Armagan1625efc2021-06-10 18:24:34 +01001469}