39 TEST_CASE(
"RuntimeUnloadNetwork")
48 mockNetwork1->AddInputLayer(0,
"test layer");
50 runtime->LoadNetwork(networkIdentifier1,
Optimize(*mockNetwork1, backends, runtime->GetDeviceSpec()));
55 mockNetwork2->AddInputLayer(0,
"test layer");
56 runtime->LoadNetwork(networkIdentifier2,
Optimize(*mockNetwork2, backends, runtime->GetDeviceSpec()));
64 TEST_CASE(
"RuntimePreImportInputs")
71 auto inputLayer1 = testNetwork->AddInputLayer(0,
"input 1 layer");
72 auto inputLayer2 = testNetwork->AddInputLayer(1,
"input 2 layer");
73 auto addLayer = testNetwork->AddAdditionLayer(
"add layer");
74 auto outputLayer = testNetwork->AddOutputLayer(2,
"output layer");
78 inputLayer1->GetOutputSlot(0).Connect(addLayer->GetInputSlot(0));
79 inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
81 inputLayer2->GetOutputSlot(0).Connect(addLayer->GetInputSlot(1));
82 inputLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
84 addLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
85 addLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
91 runtime->LoadNetwork(networkId,
92 Optimize(*testNetwork, backends, runtime->GetDeviceSpec()),
96 std::vector<int> inputData1(4, 10);
97 std::vector<int> inputData2(4, 20);
98 std::vector<int> output(4);
104 auto importedInputVec1 = runtime->ImportInputs(networkId, {{0, inputTensor1}});
105 CHECK(importedInputVec1.size() == 1);
106 CHECK(importedInputVec1[0] == 0);
108 auto memHandle = runtime->CreateWorkingMemHandle(networkId);
110 runtime->Execute(*memHandle.get(), {{1, inputTensor2}}, {{2, outputTensor}}, {0 });
111 for (
auto val: output) {
115 auto importedInputVec2 = runtime->ImportInputs(networkId, {{1, inputTensor2}});
116 CHECK(importedInputVec2.size() == 1);
117 CHECK(importedInputVec2[0] == 1);
119 runtime->Execute(*memHandle.get(), {{0, inputTensor1}}, {{2, outputTensor}}, {1 });
120 for (
auto val: output) {
124 runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0, 1});
125 for (
auto val: output) {
129 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0, 0});,
132 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{1, inputTensor2}}, {{2, outputTensor}}, {1});,
135 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{1, inputTensor2}}, {{2, outputTensor}}, {10});,
138 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{-2, inputTensor2}}, {{2, outputTensor}}, {1});,
141 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{-2, inputTensor2}}, {{2, outputTensor}}, {10});,
143 auto importedInputVec3 = runtime->ImportInputs(networkId, {{1, inputTensor2}});
144 CHECK(importedInputVec3[0] == 2);
146 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0, 1, 2});,
149 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(),
155 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0});,
157 runtime->ClearImportedInputs(networkId, {1});
158 runtime->Execute(*memHandle.get(), {{1, inputTensor2}}, {{2, outputTensor}}, {0}, {});
159 for (
auto val: output) {
163 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {}, {{2, outputTensor}}, {0, 1}, {});,
172 TEST_CASE(
"RuntimePreImportOutputs")
182 auto inputLayer1 = testNetwork->AddInputLayer(0,
"input 1 layer");
183 inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
186 activationDescriptor.
m_Function = ActivationFunction::BoundedReLu;
187 activationDescriptor.
m_A = 2.0f;
188 activationDescriptor.
m_B = 0.0f;
189 auto activationLayer1 = testNetwork->AddActivationLayer(activationDescriptor,
"add layer");
190 auto outputLayer1 = testNetwork->AddOutputLayer(2,
"output layer");
192 inputLayer1->GetOutputSlot(0).Connect(activationLayer1->GetInputSlot(0));
194 activationLayer1->GetOutputSlot(0).Connect(outputLayer1->GetInputSlot(0));
195 activationLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
197 auto inputLayer2 = testNetwork->AddInputLayer(1,
"input 1 layer");
199 activationDescriptor.
m_A = 4.0f;
200 activationDescriptor.
m_B = 2.0f;
201 auto activationLayer2 = testNetwork->AddActivationLayer(activationDescriptor,
"add layer");
202 auto outputLayer2 = testNetwork->AddOutputLayer(3,
"output layer");
204 inputLayer2->GetOutputSlot(0).Connect(activationLayer2->GetInputSlot(0));
205 inputLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
207 activationLayer2->GetOutputSlot(0).Connect(outputLayer2->GetInputSlot(0));
208 activationLayer2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
214 runtime->LoadNetwork(networkId,
215 Optimize(*testNetwork, backends, runtime->GetDeviceSpec()),
219 std::vector<float> inputData1(4, 1.0f);
220 std::vector<float> inputData2(4, 3.0f);
222 std::vector<float> outputData1(4);
223 std::vector<float> outputData2(4);
225 ConstTensor inputTensor1(tensorInfo, inputData1.data());
226 ConstTensor inputTensor2(tensorInfo, inputData2.data());
228 Tensor outputTensor1{tensorInfo, outputData1.data()};
229 Tensor outputTensor2{tensorInfo, outputData2.data()};
231 InputTensors inputTensors = {{0, inputTensor1}, {1, inputTensor2}};
233 std::pair<LayerBindingId, class Tensor> output1{2, outputTensor1};
234 std::pair<LayerBindingId, class Tensor> output2{3, outputTensor2};
236 auto testOutputs = [&]()
238 for (
auto val : outputData1)
243 for (
auto val : outputData2)
249 auto memHandle = runtime->CreateWorkingMemHandle(networkId);
251 runtime->Execute(*memHandle.get(),inputTensors, {output1, output2});
254 auto importedOutputVec = runtime->ImportOutputs(networkId, {output1, output2 });
255 CHECK(importedOutputVec.size() == 2);
256 CHECK(importedOutputVec[0] == 0);
257 CHECK(importedOutputVec[1] == 1);
259 runtime->Execute(*memHandle.get(), inputTensors, {}, {}, importedOutputVec);
262 runtime->Execute(*memHandle.get(), inputTensors, {output1}, {}, {1});
265 runtime->Execute(*memHandle.get(), inputTensors, {output2}, {}, {0});
268 auto importedInputVec = runtime->ImportInputs(networkId, inputTensors);
269 CHECK(importedInputVec.size() == 2);
270 CHECK(importedInputVec[0] == 0);
271 CHECK(importedInputVec[1] == 1);
273 runtime->Execute(*memHandle.get(), {}, {}, importedInputVec, importedOutputVec);
276 runtime->Execute(*memHandle.get(), {{0, inputTensor1}}, {output2}, {1}, {0});
280 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {output1, output2}, {}, {0, 1});,
284 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {output2}, {}, {1});,
288 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {output1, output1}, {}, {});,
292 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {}, {}, {0, 0}),
296 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {output1}, {}, {3});,
300 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {{4, outputTensor2}}, {}, {1});,
304 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {{0, outputTensor2}}, {}, {1});,
308 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {{0, outputTensor2}}, {}, {1});,
312 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), {{2, inputTensor1}}, {{0, outputTensor2}}, {1}, {1, 0});,
315 runtime->ClearImportedOutputs(networkId, {1});
317 runtime->Execute(*memHandle.get(), inputTensors, {output2}, {}, {0});
321 CHECK_THROWS_AS(runtime->Execute(*memHandle.get(), inputTensors, {}, {}, importedOutputVec),
336 #ifdef ARMNN_LEAK_CHECKING_ENABLED 338 struct DisableGlobalLeakChecking
340 DisableGlobalLeakChecking()
346 TEST_CASE_FIXTURE(DisableGlobalLeakChecking,
"RuntimeHeapMemoryUsageSanityChecks")
354 std::unique_ptr<char[]> dummyAllocation(
new char[1000]);
367 #endif // ARMNN_LEAK_CHECKING_ENABLED 373 TEST_CASE(
"RuntimeMemoryLeak")
379 unsigned long leakedBefore = 0;
380 unsigned long leakedAfter = 0;
385 unsigned long reachableBefore = 0;
386 unsigned long reachableAfter = 0;
389 unsigned long dubious = 0;
390 unsigned long suppressed = 0;
404 mockNetwork1->AddInputLayer(0,
"test layer");
407 runtime.LoadNetwork(networkIdentifier1,
Optimize(*mockNetwork1, backends, runtime.GetDeviceSpec()));
408 runtime.UnloadNetwork(networkIdentifier1);
411 VALGRIND_DO_QUICK_LEAK_CHECK;
412 VALGRIND_COUNT_LEAKS(leakedBefore, dubious, reachableBefore, suppressed);
415 runtime.LoadNetwork(networkIdentifier1,
Optimize(*mockNetwork1, backends, runtime.GetDeviceSpec()));
416 runtime.UnloadNetwork(networkIdentifier1);
418 VALGRIND_DO_ADDED_LEAK_CHECK;
419 VALGRIND_COUNT_LEAKS(leakedAfter, dubious, reachableAfter, suppressed);
423 CHECK(leakedBefore == leakedAfter);
424 CHECK(reachableBefore == reachableAfter);
431 #endif // WITH_VALGRIND 433 TEST_CASE(
"RuntimeCpuRef")
435 using namespace armnn;
464 CHECK(runtime->LoadNetwork(netId, std::move(optNet)) == Status::Success);
467 TEST_CASE(
"RuntimeFallbackToCpuRef")
469 using namespace armnn;
499 CHECK(runtime->LoadNetwork(netId, std::move(optNet)) == Status::Success);
502 TEST_CASE(
"IVGCVSW_1929_QuantizedSoftmaxIssue")
505 using namespace armnn;
528 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
529 std::vector<std::string> errMessages;
535 runtime->GetDeviceSpec(),
538 FAIL(
"An exception should have been thrown");
544 CHECK(errMessages.size() > 0);
547 TEST_CASE(
"RuntimeBackendOptions")
549 using namespace armnn;
563 options1.
AddOption({
"Option3",
"some_value" });
566 backendOptions.push_back(options1);
575 CHECK(backendOptions[0].
GetBackendId().Get() ==
"FakeBackend1");
576 CHECK(backendOptions[0].GetOption(0).GetName() ==
"Option1");
577 CHECK(backendOptions[0].GetOption(0).GetValue().IsFloat() ==
true);
578 CHECK(backendOptions[0].GetOption(0).GetValue().AsFloat() == 1.3f);
580 CHECK(backendOptions[0].GetOption(1).GetName() ==
"Option2");
581 CHECK(backendOptions[0].GetOption(1).GetValue().IsBool() ==
true);
582 CHECK(backendOptions[0].GetOption(1).GetValue().AsBool() ==
true);
584 CHECK(backendOptions[0].GetOption(2).GetName() ==
"Option3");
585 CHECK(backendOptions[0].GetOption(2).GetValue().IsString() ==
true);
586 CHECK(backendOptions[0].GetOption(2).GetValue().AsString() ==
"some_value");
589 CHECK(backendOptions[1].
GetBackendId().Get() ==
"FakeBackend1");
590 CHECK(backendOptions[1].GetOption(0).GetName() ==
"Option4");
591 CHECK(backendOptions[1].GetOption(0).GetValue().IsInt() ==
true);
592 CHECK(backendOptions[1].GetOption(0).GetValue().AsInt() == 42);
595 TEST_CASE(
"ProfilingDisable")
597 using namespace armnn;
621 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
626 CHECK(runtime.LoadNetwork(netId, std::move(optNet)) == Status::Success);
633 CHECK(!readableBuffer);
636 TEST_CASE(
"ProfilingEnableCpuRef")
638 using namespace armnn;
650 profilingServiceHelper.ForceTransitionToState(ProfilingState::NotConnected);
651 profilingServiceHelper.ForceTransitionToState(ProfilingState::WaitingForAck);
652 profilingServiceHelper.ForceTransitionToState(ProfilingState::Active);
660 IConnectableLayer* normalize = net->AddNormalizationLayer(descriptor,
"normalization");
671 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
674 ProfilingGuid optNetGuid = optNet->GetGuid();
678 CHECK(runtime.LoadNetwork(netId, std::move(optNet)) == Status::Success);
684 CHECK(readableBuffer !=
nullptr);
686 unsigned int size = readableBuffer->GetSize();
688 const unsigned char* readableData = readableBuffer->GetReadableData();
689 CHECK(readableData !=
nullptr);
691 unsigned int offset = 0;
704 LabelsAndEventClasses::NETWORK_GUID,
705 LabelsAndEventClasses::TYPE_GUID,
721 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
727 std::stringstream ss;
729 std::string processIdLabel = ss.str();
737 LabelsAndEventClasses::PROCESS_ID_GUID,
753 LabelsAndEventClasses::NAME_GUID,
761 LabelsAndEventClasses::LAYER_GUID,
762 LabelsAndEventClasses::TYPE_GUID,
771 LabelsAndEventClasses::CHILD_GUID,
787 normalizationLayerNameGuid,
788 LabelsAndEventClasses::NAME_GUID,
796 LabelsAndEventClasses::LAYER_GUID,
797 LabelsAndEventClasses::TYPE_GUID,
806 LabelsAndEventClasses::CHILD_GUID,
815 LabelsAndEventClasses::CONNECTION_GUID,
827 normalizationWorkloadGuid,
828 LabelsAndEventClasses::WORKLOAD_GUID,
829 LabelsAndEventClasses::TYPE_GUID,
840 normalizationWorkloadGuid,
842 LabelsAndEventClasses::BACKENDID_GUID,
850 normalizationWorkloadGuid,
851 LabelsAndEventClasses::CHILD_GUID,
868 LabelsAndEventClasses::NAME_GUID,
876 LabelsAndEventClasses::LAYER_GUID,
877 LabelsAndEventClasses::TYPE_GUID,
886 LabelsAndEventClasses::CHILD_GUID,
895 LabelsAndEventClasses::CONNECTION_GUID,
899 bufferManager.MarkRead(readableBuffer);
902 std::vector<float> inputData(16);
903 std::vector<float> outputData(16);
905 TensorInfo inputTensorInfo = runtime.GetInputTensorInfo(netId, 0);
909 {0,
ConstTensor(inputTensorInfo, inputData.data())}
913 {0,
Tensor(runtime.GetOutputTensorInfo(netId, 0), outputData.data())}
917 runtime.EnqueueWorkload(netId, inputTensors, outputTensors);
920 auto inputReadableBuffer = bufferManager.GetReadableBuffer();
921 CHECK(inputReadableBuffer !=
nullptr);
924 auto outputReadableBuffer = bufferManager.GetReadableBuffer();
925 CHECK(outputReadableBuffer !=
nullptr);
928 auto inferenceReadableBuffer = bufferManager.GetReadableBuffer();
929 CHECK(inferenceReadableBuffer !=
nullptr);
932 size = inputReadableBuffer->GetSize();
935 readableData = inputReadableBuffer->GetReadableData();
936 CHECK(readableData !=
nullptr);
951 LabelsAndEventClasses::WORKLOAD_GUID,
952 LabelsAndEventClasses::TYPE_GUID,
965 LabelsAndEventClasses::BACKENDID_GUID,
974 LabelsAndEventClasses::CHILD_GUID,
978 bufferManager.MarkRead(inputReadableBuffer);
981 size = outputReadableBuffer->GetSize();
984 readableData = outputReadableBuffer->GetReadableData();
985 CHECK(readableData !=
nullptr);
1000 LabelsAndEventClasses::WORKLOAD_GUID,
1001 LabelsAndEventClasses::TYPE_GUID,
1013 LabelsAndEventClasses::BACKENDID_GUID,
1022 LabelsAndEventClasses::CHILD_GUID,
1026 bufferManager.MarkRead(outputReadableBuffer);
1029 size = inferenceReadableBuffer->GetSize();
1032 readableData = inferenceReadableBuffer->GetReadableData();
1033 CHECK(readableData !=
nullptr);
1048 LabelsAndEventClasses::INFERENCE_GUID,
1049 LabelsAndEventClasses::TYPE_GUID,
1058 LabelsAndEventClasses::EXECUTION_OF_GUID,
1072 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1085 inputWorkloadExecutionGuid,
1086 LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
1087 LabelsAndEventClasses::TYPE_GUID,
1095 inputWorkloadExecutionGuid,
1096 LabelsAndEventClasses::CHILD_GUID,
1104 inputWorkloadExecutionGuid,
1105 LabelsAndEventClasses::EXECUTION_OF_GUID,
1117 inputWorkloadExecutionGuid,
1118 inputWorkloadExecutionSOLEventId,
1119 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1131 inputWorkloadExecutionGuid,
1132 inputWorkloadExecutionEOLEventId,
1133 LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1145 normalizeWorkloadExecutionGuid,
1146 LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
1147 LabelsAndEventClasses::TYPE_GUID,
1155 normalizeWorkloadExecutionGuid,
1156 LabelsAndEventClasses::CHILD_GUID,
1163 normalizationWorkloadGuid,
1164 normalizeWorkloadExecutionGuid,
1165 LabelsAndEventClasses::EXECUTION_OF_GUID,
1177 normalizeWorkloadExecutionGuid,
1178 normalizationWorkloadExecutionSOLEventGuid,
1179 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1191 normalizeWorkloadExecutionGuid,
1192 normalizationWorkloadExecutionEOLEventGuid,
1193 LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1205 outputWorkloadExecutionGuid,
1206 LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
1207 LabelsAndEventClasses::TYPE_GUID,
1215 outputWorkloadExecutionGuid,
1216 LabelsAndEventClasses::CHILD_GUID,
1224 outputWorkloadExecutionGuid,
1225 LabelsAndEventClasses::EXECUTION_OF_GUID,
1237 outputWorkloadExecutionGuid,
1238 outputWorkloadExecutionSOLEventGuid,
1239 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1251 outputWorkloadExecutionGuid,
1252 outputWorkloadExecutionEOLEventGuid,
1253 LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1266 inferenceEOLEventGuid,
1267 LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1271 bufferManager.MarkRead(inferenceReadableBuffer);
1274 TEST_CASE(
"ProfilingPostOptimisationStructureCpuRef")
#define ARMNN_SCOPED_LEAK_CHECKER(TAG)
profiling::ProfilingService & GetProfilingService(armnn::RuntimeImpl *runtime)
#define ARMNN_LOCAL_LEAK_CHECKING_ONLY()
static IRuntimePtr Create(const CreationOptions &options)
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
ProfilingGuid VerifyTimelineEntityBinaryPacketData(Optional< ProfilingGuid > guid, const unsigned char *readableData, unsigned int &offset)
void VerifyPostOptimisationStructureTestImpl(armnn::BackendId backendId)
CPU Execution: Reference C++ kernels.
std::unique_ptr< IRuntime, void(*)(IRuntime *runtime)> IRuntimePtr
std::vector< std::pair< LayerBindingId, class ConstTensor > > InputTensors
Copyright (c) 2021 ARM Limited and Contributors.
void IgnoreUnused(Ts &&...)
bool m_EnableProfiling
Indicates whether external profiling is enabled or not.
virtual void SetTensorInfo(const TensorInfo &tensorInfo)=0
#define ARMNN_LEAK_CHECKER_IS_ACTIVE()
A tensor defined by a TensorInfo (shape and data type) and a mutable backing store.
#define ARMNN_OBJECTS_LEAKED_IN_SCOPE()
TEST_CASE_FIXTURE(ClContextControlFixture, "CopyBetweenNeonAndGpu")
std::vector< BackendOptions > m_BackendOptions
Pass backend specific options.
const char * GetBackendId()
void RuntimeLoadedNetworksReserve(armnn::RuntimeImpl *runtime)
void AddOption(BackendOption &&option)
IOptimizedNetworkPtr Optimize(const INetwork &network, const std::vector< BackendId > &backendPreferences, const IDeviceSpec &deviceSpec, const OptimizerOptions &options=OptimizerOptions(), Optional< std::vector< std::string > &> messages=EmptyOptional())
Create an optimized version of the network.
void VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType relationshipType, Optional< ProfilingGuid > relationshipGuid, Optional< ProfilingGuid > headGuid, Optional< ProfilingGuid > tailGuid, Optional< ProfilingGuid > attributeGuid, const unsigned char *readableData, unsigned int &offset)
virtual LayerGuid GetGuid() const =0
Returns the unique id of the layer.
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
std::vector< std::pair< LayerBindingId, class Tensor > > OutputTensors
std::unique_ptr< IOptimizedNetwork, void(*)(IOptimizedNetwork *network)> IOptimizedNetworkPtr
void ResetExternalProfilingOptions(const ExternalProfilingOptions &options, bool resetProfilingService=false)
ArmNN performs an optimization on each model/network before it gets loaded for execution.
IPacketBufferPtr GetReadableBuffer() override
constexpr unsigned int ThreadIdSize
An ActivationDescriptor for the ActivationLayer.
void VerifyTimelineHeaderBinary(const unsigned char *readableData, unsigned int &offset, uint32_t packetDataLength)
Struct for the users to pass backend specific options.
float m_A
Alpha upper bound value used by the activation functions. (BoundedReLu, Linear, TanH, Elu).
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
CPU Execution: NEON: ArmCompute.
#define ARMNN_NO_LEAKS_IN_SCOPE()
virtual const IInputSlot & GetInputSlot(unsigned int index) const =0
Get a const input slot handle by slot index.
void SetConstant(const bool IsConstant=true)
Marks the data corresponding to this tensor info as constant.
bool m_TimelineEnabled
Indicates whether external timeline profiling is enabled or not.
virtual const IOutputSlot & GetOutputSlot(unsigned int index) const =0
Get the const output slot handle by slot index.
std::unique_ptr< INetwork, void(*)(INetwork *network)> INetworkPtr
ProfilingGuid VerifyTimelineEventBinaryPacket(Optional< uint64_t > timestamp, Optional< int > threadId, Optional< ProfilingGuid > eventGuid, const unsigned char *readableData, unsigned int &offset)
virtual int Connect(IInputSlot &destination)=0
ProfilingGuid VerifyTimelineLabelBinaryPacketData(Optional< ProfilingGuid > guid, const std::string &label, const unsigned char *readableData, unsigned int &offset)
A NormalizationDescriptor for the NormalizationLayer.
ExternalProfilingOptions m_ProfilingOptions
static INetworkPtr Create(NetworkOptions networkOptions={})
float m_B
Beta lower bound value used by the activation functions. (BoundedReLu, Linear, TanH).
A SoftmaxDescriptor for the SoftmaxLayer.
#define ARMNN_BYTES_LEAKED_IN_SCOPE()
ActivationFunction m_Function
The activation function to use (Sigmoid, TanH, Linear, ReLu, BoundedReLu, SoftReLu, LeakyReLu, Abs, Sqrt, Square, Elu).