patch/20.02/_neon_runtime_tests_8cpp_source.xhtml

 //
 // Copyright © 2017 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //

 #include <test/RuntimeTests.hpp>

 #include <LeakChecking.hpp>

 #include <backendsCommon/test/RuntimeTestImpl.hpp>
 #include <test/ProfilingTestUtils.hpp>

 #include <boost/test/unit_test.hpp>

 BOOST_AUTO_TEST_SUITE(NeonRuntime)

 BOOST_AUTO_TEST_CASE(RuntimeValidateCpuAccDeviceSupportLayerNoFallback)
 {
     // build up the structure of the network
     armnn::INetworkPtr net(armnn::INetwork::Create());

     armnn::IConnectableLayer* input = net->AddInputLayer(0);
     armnn::IConnectableLayer* output = net->AddOutputLayer(0);

     input->GetOutputSlot(0).Connect(output->GetInputSlot(0));
     input->GetOutputSlot(0).SetTensorInfo(armnn::TensorInfo({ 1, 1, 4, 4 }, armnn::DataType::Float32));

     armnn::IRuntime::CreationOptions options;
     armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));

     std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
     armnn::IOptimizedNetworkPtr optNet = armnn::Optimize(*net, backends, runtime->GetDeviceSpec());
     BOOST_CHECK(optNet);

     // Load it into the runtime. It should success.
     armnn::NetworkId netId;
     BOOST_TEST(runtime->LoadNetwork(netId, std::move(optNet)) == armnn::Status::Success);
 }

 #ifdef ARMNN_LEAK_CHECKING_ENABLED
 BOOST_AUTO_TEST_CASE(RuntimeMemoryLeaksCpuAcc)
 {
     BOOST_TEST(ARMNN_LEAK_CHECKER_IS_ACTIVE());
     armnn::IRuntime::CreationOptions options;
     armnn::Runtime runtime(options);
     armnn::RuntimeLoadedNetworksReserve(&runtime);

     std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
     {
         // Do a warmup of this so we make sure that all one-time
         // initialization happens before we do the leak checking.
         CreateAndDropDummyNetwork(backends, runtime);
     }

     {
         ARMNN_SCOPED_LEAK_CHECKER("LoadAndUnloadNetworkCpuAcc");
         BOOST_TEST(ARMNN_NO_LEAKS_IN_SCOPE());
         // In the second run we check for all remaining memory
         // in use after the network was unloaded. If there is any
         // then it will be treated as a memory leak.
         CreateAndDropDummyNetwork(backends, runtime);
         BOOST_TEST(ARMNN_NO_LEAKS_IN_SCOPE());
         BOOST_TEST(ARMNN_BYTES_LEAKED_IN_SCOPE() == 0);
         BOOST_TEST(ARMNN_OBJECTS_LEAKED_IN_SCOPE() == 0);
     }
 }
 #endif

 BOOST_AUTO_TEST_CASE(ProfilingPostOptimisationStructureCpuAcc)
 {
     VerifyPostOptimisationStructureTestImpl(armnn::Compute::CpuAcc);
 }

 BOOST_AUTO_TEST_SUITE_END()
ARMNN_SCOPED_LEAK_CHECKER
#define ARMNN_SCOPED_LEAK_CHECKER(TAG)
Definition: LeakChecking.hpp:88

+BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)

+armnn::IRuntime::Create
static IRuntimePtr Create(const CreationOptions &options)
Definition: Runtime.cpp:32

+armnn::IConnectableLayer
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
Definition: INetwork.hpp:61

+VerifyPostOptimisationStructureTestImpl
void VerifyPostOptimisationStructureTestImpl(armnn::BackendId backendId)
Definition: ProfilingTestUtils.cpp:290

+armnn::TensorInfo
Definition: Tensor.hpp:53

+armnn::IRuntimePtr
std::unique_ptr< IRuntime, void(*)(IRuntime *runtime)> IRuntimePtr
Definition: IRuntime.hpp:24

+armnn::NetworkId
int NetworkId
Definition: IRuntime.hpp:19

+RuntimeTests.hpp

+BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)

+armnn::IOutputSlot::SetTensorInfo
virtual void SetTensorInfo(const TensorInfo &tensorInfo)=0

+ARMNN_LEAK_CHECKER_IS_ACTIVE
#define ARMNN_LEAK_CHECKER_IS_ACTIVE()
Definition: LeakChecking.hpp:89

+ARMNN_OBJECTS_LEAKED_IN_SCOPE
#define ARMNN_OBJECTS_LEAKED_IN_SCOPE()
Definition: LeakChecking.hpp:92

+armnn::Status::Success

+armnn::Optimize
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.
Definition: Network.cpp:890

+armnn::IOptimizedNetworkPtr
std::unique_ptr< IOptimizedNetwork, void(*)(IOptimizedNetwork *network)> IOptimizedNetworkPtr
Definition: INetwork.hpp:566

+RuntimeTestImpl.hpp

+armnn::IRuntime::CreationOptions
Definition: IRuntime.hpp:41

+LeakChecking.hpp

+BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()

+BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(RuntimeValidateCpuAccDeviceSupportLayerNoFallback)
Definition: NeonRuntimeTests.cpp:17

+armnn::Compute::CpuAcc
CPU Execution: NEON: ArmCompute.

+ARMNN_NO_LEAKS_IN_SCOPE
#define ARMNN_NO_LEAKS_IN_SCOPE()
Definition: LeakChecking.hpp:90

+armnn::Runtime
Definition: Runtime.hpp:23

+armnn::IConnectableLayer::GetInputSlot
virtual const IInputSlot & GetInputSlot(unsigned int index) const =0
Get a const input slot handle by slot index.

+armnn::DataType::Float32

+armnn::IConnectableLayer::GetOutputSlot
virtual const IOutputSlot & GetOutputSlot(unsigned int index) const =0
Get the const output slot handle by slot index.

+ProfilingTestUtils.hpp

+armnn::INetworkPtr
std::unique_ptr< INetwork, void(*)(INetwork *network)> INetworkPtr
Definition: INetwork.hpp:101

+armnn::IOutputSlot::Connect
virtual int Connect(IInputSlot &destination)=0

+options
armnn::Runtime::CreationOptions::ExternalProfilingOptions options
Definition: FileOnlyProfilingDecoratorTests.cpp:45

+ARMNN_BYTES_LEAKED_IN_SCOPE
#define ARMNN_BYTES_LEAKED_IN_SCOPE()
Definition: LeakChecking.hpp:91

+armnn::INetwork::Create
static INetworkPtr Create()
Definition: Network.cpp:49

+armnn::RuntimeLoadedNetworksReserve
void RuntimeLoadedNetworksReserve(armnn::Runtime *runtime)
Definition: RuntimeTests.cpp:28

+