diff options
Diffstat (limited to 'src/backends')
-rw-r--r-- | src/backends/cl/backend.mk | 1 | ||||
-rw-r--r-- | src/backends/cl/test/CMakeLists.txt | 1 | ||||
-rw-r--r-- | src/backends/cl/test/ClRuntimeTests.cpp | 151 | ||||
-rw-r--r-- | src/backends/neon/backend.mk | 1 | ||||
-rw-r--r-- | src/backends/neon/test/CMakeLists.txt | 1 | ||||
-rw-r--r-- | src/backends/neon/test/NeonRuntimeTests.cpp | 68 | ||||
-rw-r--r-- | src/backends/reference/backend.mk | 3 | ||||
-rw-r--r-- | src/backends/reference/test/CMakeLists.txt | 1 | ||||
-rw-r--r-- | src/backends/reference/test/RefRuntimeTests.cpp | 46 | ||||
-rw-r--r-- | src/backends/test/RuntimeTestImpl.hpp | 42 |
10 files changed, 314 insertions, 1 deletions
diff --git a/src/backends/cl/backend.mk b/src/backends/cl/backend.mk index c549c01c28..1f89f3b0a4 100644 --- a/src/backends/cl/backend.mk +++ b/src/backends/cl/backend.mk @@ -47,5 +47,6 @@ BACKEND_TEST_SOURCES := \ test/ClLayerSupportTests.cpp \ test/ClLayerTests.cpp \ test/ClMemCopyTests.cpp \ + test/ClRuntimeTests.cpp \ test/Fp16SupportTest.cpp \ test/OpenClTimerTest.cpp diff --git a/src/backends/cl/test/CMakeLists.txt b/src/backends/cl/test/CMakeLists.txt index 262e23a7c1..69aa08d42b 100644 --- a/src/backends/cl/test/CMakeLists.txt +++ b/src/backends/cl/test/CMakeLists.txt @@ -9,6 +9,7 @@ list(APPEND armnnClBackendUnitTests_sources ClLayerSupportTests.cpp ClLayerTests.cpp ClMemCopyTests.cpp + ClRuntimeTests.cpp OpenClTimerTest.cpp ) diff --git a/src/backends/cl/test/ClRuntimeTests.cpp b/src/backends/cl/test/ClRuntimeTests.cpp new file mode 100644 index 0000000000..d29cd5b1c2 --- /dev/null +++ b/src/backends/cl/test/ClRuntimeTests.cpp @@ -0,0 +1,151 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include <armnn/test/RuntimeTests.hpp> + +#include <armnnUtils/LeakChecking.hpp> + +#include <backends/test/RuntimeTestImpl.hpp> + +#include <boost/core/ignore_unused.hpp> +#include <boost/test/unit_test.hpp> + +#ifdef WITH_VALGRIND +#include <valgrind/memcheck.h> +#endif + +BOOST_AUTO_TEST_SUITE(ClRuntime) + +BOOST_AUTO_TEST_CASE(RuntimeValidateGpuDeviceSupportLayerNoFallback) +{ + // 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::GpuAcc }; + 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(RuntimeMemoryLeaksGpuAcc) +{ + 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::GpuAcc}; + { + // 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("LoadAndUnloadNetworkGpuAcc"); + 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 + +// Note: this part of the code is due to be removed when we fully trust the gperftools based results. +#if defined(WITH_VALGRIND) +BOOST_AUTO_TEST_CASE(RuntimeMemoryUsage) +{ + // From documentation: + + // This means that no pointer to the block can be found. The block is classified as "lost", + // because the programmer could not possibly have freed it at program exit, since no pointer to it exists. + unsigned long leakedBefore = 0; + unsigned long leakedAfter = 0; + + // A start-pointer or chain of start-pointers to the block is found. Since the block is still pointed at, + // the programmer could, at least in principle, have freed it before program exit. + // We want to test this in case memory is not freed as early as it could have been. + unsigned long reachableBefore = 0; + unsigned long reachableAfter = 0; + + // Needed as out params but we don't test them. + unsigned long dubious = 0; + unsigned long suppressed = 0; + + // Ensure that runtime is large enough before checking for memory leaks. + // Otherwise, when loading the network, it will automatically reserve memory that won't be released + // until destruction. + armnn::NetworkId networkIdentifier; + armnn::IRuntime::CreationOptions options; + armnn::Runtime runtime(options); + armnn::RuntimeLoadedNetworksReserve(&runtime); + + // Checks for leaks before we load the network and record them so that we can see the delta after unloading. + VALGRIND_DO_QUICK_LEAK_CHECK; + VALGRIND_COUNT_LEAKS(leakedBefore, dubious, reachableBefore, suppressed); + + // build a mock-network and load it into the runtime + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + { + armnn::TensorInfo inputTensorInfo(armnn::TensorShape({ 7, 7 }), armnn::DataType::Float32); + armnn::TensorInfo outputTensorInfo(armnn::TensorShape({ 7, 7 }), armnn::DataType::Float32); + + armnn::INetworkPtr mockNetwork(armnn::INetwork::Create()); + + armnn::IConnectableLayer* input = mockNetwork->AddInputLayer(0, "input"); + armnn::IConnectableLayer* layer = mockNetwork->AddActivationLayer(armnn::ActivationDescriptor(), "test"); + armnn::IConnectableLayer* output = mockNetwork->AddOutputLayer(0, "output"); + + input->GetOutputSlot(0).Connect(layer->GetInputSlot(0)); + layer->GetOutputSlot(0).Connect(output->GetInputSlot(0)); + + // Sets the tensors in the network. + input->GetOutputSlot(0).SetTensorInfo(inputTensorInfo); + layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo); + + // optimize the network + armnn::IOptimizedNetworkPtr optNet = Optimize(*mockNetwork, backends, runtime.GetDeviceSpec()); + + runtime.LoadNetwork(networkIdentifier, std::move(optNet)); + } + + runtime.UnloadNetwork(networkIdentifier); + + VALGRIND_DO_ADDED_LEAK_CHECK; + VALGRIND_COUNT_LEAKS(leakedAfter, dubious, reachableAfter, suppressed); + + // If we're not running under Valgrind, these vars will have been initialised to 0, so this will always pass. + BOOST_TEST(leakedBefore == leakedAfter); + + // Add resonable threshold after and before running valgrind with the ACL clear cache function. + // TODO Threshold set to 80k until the root cause of the memory leakage is found and fixed. Revert threshold + // value to 1024 when fixed. + BOOST_TEST(static_cast<long>(reachableAfter) - static_cast<long>(reachableBefore) < 81920); + + // These are needed because VALGRIND_COUNT_LEAKS is a macro that assigns to the parameters + // so they are assigned to, but still considered unused, causing a warning. + boost::ignore_unused(dubious); + boost::ignore_unused(suppressed); +} +#endif + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/neon/backend.mk b/src/backends/neon/backend.mk index 4cab9fbd71..a4e6db9610 100644 --- a/src/backends/neon/backend.mk +++ b/src/backends/neon/backend.mk @@ -44,4 +44,5 @@ BACKEND_TEST_SOURCES := \ test/NeonLayerSupportTests.cpp \ test/NeonLayerTests.cpp \ test/NeonMemCopyTests.cpp \ + test/NeonRuntimeTests.cpp \ test/NeonTimerTest.cpp diff --git a/src/backends/neon/test/CMakeLists.txt b/src/backends/neon/test/CMakeLists.txt index 384a5e1749..e6a28590b5 100644 --- a/src/backends/neon/test/CMakeLists.txt +++ b/src/backends/neon/test/CMakeLists.txt @@ -8,6 +8,7 @@ list(APPEND armnnNeonBackendUnitTests_sources NeonLayerSupportTests.cpp NeonLayerTests.cpp NeonMemCopyTests.cpp + NeonRuntimeTests.cpp NeonTimerTest.cpp ) diff --git a/src/backends/neon/test/NeonRuntimeTests.cpp b/src/backends/neon/test/NeonRuntimeTests.cpp new file mode 100644 index 0000000000..6e6b1e9148 --- /dev/null +++ b/src/backends/neon/test/NeonRuntimeTests.cpp @@ -0,0 +1,68 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include <armnn/test/RuntimeTests.hpp> + +#include <armnnUtils/LeakChecking.hpp> + +#include <backends/test/RuntimeTestImpl.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_SUITE_END()
\ No newline at end of file diff --git a/src/backends/reference/backend.mk b/src/backends/reference/backend.mk index 9ecb6d75b2..455ab4618e 100644 --- a/src/backends/reference/backend.mk +++ b/src/backends/reference/backend.mk @@ -66,4 +66,5 @@ BACKEND_SOURCES := \ BACKEND_TEST_SOURCES := \ test/RefCreateWorkloadTests.cpp \ test/RefLayerSupportTests.cpp \ - test/RefLayerTests.cpp + test/RefLayerTests.cpp \ + test/RefRuntimeTests.cpp diff --git a/src/backends/reference/test/CMakeLists.txt b/src/backends/reference/test/CMakeLists.txt index deee364a9a..dea0ef6498 100644 --- a/src/backends/reference/test/CMakeLists.txt +++ b/src/backends/reference/test/CMakeLists.txt @@ -7,6 +7,7 @@ list(APPEND armnnRefBackendUnitTests_sources RefCreateWorkloadTests.cpp RefLayerSupportTests.cpp RefLayerTests.cpp + RefRuntimeTests.cpp ) add_library(armnnRefBackendUnitTests OBJECT ${armnnRefBackendUnitTests_sources}) diff --git a/src/backends/reference/test/RefRuntimeTests.cpp b/src/backends/reference/test/RefRuntimeTests.cpp new file mode 100644 index 0000000000..2536627ea6 --- /dev/null +++ b/src/backends/reference/test/RefRuntimeTests.cpp @@ -0,0 +1,46 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include <armnn/test/RuntimeTests.hpp> + +#include <armnnUtils/LeakChecking.hpp> + +#include <backends/test/RuntimeTestImpl.hpp> + +#include <boost/test/unit_test.hpp> + +BOOST_AUTO_TEST_SUITE(RefRuntime) + +#ifdef ARMNN_LEAK_CHECKING_ENABLED +BOOST_AUTO_TEST_CASE(RuntimeMemoryLeaksCpuRef) +{ + 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::CpuRef}; + { + // 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("LoadAndUnloadNetworkCpuRef"); + 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_SUITE_END()
\ No newline at end of file diff --git a/src/backends/test/RuntimeTestImpl.hpp b/src/backends/test/RuntimeTestImpl.hpp new file mode 100644 index 0000000000..671f94b0bb --- /dev/null +++ b/src/backends/test/RuntimeTestImpl.hpp @@ -0,0 +1,42 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// +#pragma once + +#include <armnn/ArmNN.hpp> +#include <armnn/Runtime.hpp> + +namespace +{ + +inline void CreateAndDropDummyNetwork(const std::vector<armnn::BackendId>& backends, armnn::Runtime& runtime) +{ + armnn::NetworkId networkIdentifier; + { + armnn::TensorInfo inputTensorInfo(armnn::TensorShape({ 7, 7 }), armnn::DataType::Float32); + armnn::TensorInfo outputTensorInfo(armnn::TensorShape({ 7, 7 }), armnn::DataType::Float32); + + armnn::INetworkPtr network(armnn::INetwork::Create()); + + armnn::IConnectableLayer* input = network->AddInputLayer(0, "input"); + armnn::IConnectableLayer* layer = network->AddActivationLayer(armnn::ActivationDescriptor(), "test"); + armnn::IConnectableLayer* output = network->AddOutputLayer(0, "output"); + + input->GetOutputSlot(0).Connect(layer->GetInputSlot(0)); + layer->GetOutputSlot(0).Connect(output->GetInputSlot(0)); + + // Sets the tensors in the network. + input->GetOutputSlot(0).SetTensorInfo(inputTensorInfo); + layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo); + + // optimize the network + armnn::IOptimizedNetworkPtr optNet = Optimize(*network, backends, runtime.GetDeviceSpec()); + + runtime.LoadNetwork(networkIdentifier, std::move(optNet)); + } + + runtime.UnloadNetwork(networkIdentifier); +} + +} // anonymous namespace |