include/armnn/ILayerSupport.hpp
include/armnn/INetwork.hpp
include/armnn/IProfiler.hpp
- include/armnn/IBackend.hpp
include/armnn/IRuntime.hpp
include/armnn/LayerSupport.hpp
include/armnn/LstmParams.hpp
#include "BackendId.hpp"
#include "Descriptors.hpp"
#include "Exceptions.hpp"
-#include "IBackend.hpp"
#include "IRuntime.hpp"
#include "INetwork.hpp"
#include "LayerSupport.hpp"
+++ /dev/null
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-#pragma once
-
-#include "BackendId.hpp"
-
-namespace armnn
-{
-
-class IBackend
-{
-protected:
- IBackend() {}
- virtual ~IBackend() {}
-
-public:
- virtual const BackendId& GetId() const = 0;
-};
-
-} // namespace armnn
\ No newline at end of file
Ceiling = 1
};
+/// Each backend should implement an IBackend.
+class IBackend
+{
+protected:
+ IBackend() {}
+ virtual ~IBackend() {}
+
+public:
+ virtual const BackendId& GetId() const = 0;
+};
+
+using IBackendSharedPtr = std::shared_ptr<IBackend>;
+using IBackendUniquePtr = std::unique_ptr<IBackend, void(*)(IBackend* backend)>;
+
/// Device specific knowledge to be passed to the optimizer.
class IDeviceSpec
{
/// Define LayerGuid type.
using LayerGuid = unsigned int;
-struct EmptyInitializer {};
-
} // namespace armnn
bool isSupported; \
try { \
auto factoryFunc = LayerSupportRegistryInstance().GetFactory(backendId); \
- auto layerSupportObject = factoryFunc(EmptyInitializer()); \
+ auto layerSupportObject = factoryFunc(); \
isSupported = layerSupportObject->func(__VA_ARGS__, Optional<std::string&>(reasonIfUnsupportedFull)); \
CopyErrorMessage(reasonIfUnsupported, reasonIfUnsupportedFull.c_str(), reasonIfUnsupportedMaxLength); \
} catch (InvalidArgumentException e) { \
} // anonymous
std::unique_ptr<LoadedNetwork> LoadedNetwork::MakeLoadedNetwork(std::unique_ptr<OptimizedNetwork> net,
- const IRuntime::CreationOptions& options,
std::string & errorMessage)
{
std::unique_ptr<LoadedNetwork> loadedNetwork;
try
{
- loadedNetwork.reset(new LoadedNetwork(std::move(net), options));
+ loadedNetwork.reset(new LoadedNetwork(std::move(net)));
}
catch (const armnn::RuntimeException& error)
{
return loadedNetwork;
}
-LoadedNetwork::LoadedNetwork(std::unique_ptr<OptimizedNetwork> net,
- const IRuntime::CreationOptions& options)
+LoadedNetwork::LoadedNetwork(std::unique_ptr<OptimizedNetwork> net)
: m_OptimizedNetwork(std::move(net))
, m_WorkingMemLock(m_WorkingMemMutex, std::defer_lock)
{
if (m_Backends.count(backend) == 0)
{
auto createBackend = BackendRegistryInstance().GetFactory(backend);
- auto it = m_Backends.emplace(std::make_pair(backend, createBackend(EmptyInitializer())));
+ auto it = m_Backends.emplace(std::make_pair(backend, createBackend()));
m_WorkloadFactories.emplace(std::make_pair(backend,
it.first->second->CreateWorkloadFactory()));
}
Status EnqueueWorkload(const InputTensors& inputTensors, const OutputTensors& outputTensors);
static std::unique_ptr<LoadedNetwork> MakeLoadedNetwork(std::unique_ptr<OptimizedNetwork> net,
- const IRuntime::CreationOptions& options,
std::string & errorMessage);
// NOTE we return by reference as the purpose of this method is only to provide
void FreeWorkingMemory();
private:
- LoadedNetwork(std::unique_ptr<OptimizedNetwork> net, const IRuntime::CreationOptions& options);
+ LoadedNetwork(std::unique_ptr<OptimizedNetwork> net);
void EnqueueInput(const BindableLayer& layer, ITensorHandle* tensorHandle, const TensorInfo& tensorInfo);
#include <armnn/Version.hpp>
#include <backendsCommon/BackendRegistry.hpp>
-#include <backendsCommon/BackendContextRegistry.hpp>
#include <iostream>
+#ifdef ARMCOMPUTECL_ENABLED
+#include <arm_compute/core/CL/OpenCL.h>
+#include <arm_compute/core/CL/CLKernelLibrary.h>
+#include <arm_compute/runtime/CL/CLScheduler.h>
+#endif
+
#include <boost/log/trivial.hpp>
#include <boost/polymorphic_cast.hpp>
IOptimizedNetwork* rawNetwork = inNetwork.release();
unique_ptr<LoadedNetwork> loadedNetwork = LoadedNetwork::MakeLoadedNetwork(
std::unique_ptr<OptimizedNetwork>(boost::polymorphic_downcast<OptimizedNetwork*>(rawNetwork)),
- m_Options,
errorMessage);
if (!loadedNetwork)
Status Runtime::UnloadNetwork(NetworkId networkId)
{
+#ifdef ARMCOMPUTECL_ENABLED
+ if (arm_compute::CLScheduler::get().context()() != NULL)
+ {
+ // Waits for all queued CL requests to finish before unloading the network they may be using.
+ try
+ {
+ // Coverity fix: arm_compute::CLScheduler::sync() may throw an exception of type cl::Error.
+ arm_compute::CLScheduler::get().sync();
+ }
+ catch (const cl::Error&)
+ {
+ BOOST_LOG_TRIVIAL(warning) << "WARNING: Runtime::UnloadNetwork(): an error occurred while waiting for "
+ "the queued CL requests to finish";
+ return Status::Failure;
+ }
+ }
+#endif
+
{
std::lock_guard<std::mutex> lockGuard(m_Mutex);
BOOST_LOG_TRIVIAL(warning) << "WARNING: Runtime::UnloadNetwork(): " << networkId << " not found!";
return Status::Failure;
}
+
+#ifdef ARMCOMPUTECL_ENABLED
+ if (arm_compute::CLScheduler::get().context()() != NULL && m_LoadedNetworks.empty())
+ {
+ // There are no loaded networks left, so clear the CL cache to free up memory
+ m_ClContextControl.ClearClCache();
+ }
+#endif
}
BOOST_LOG_TRIVIAL(debug) << "Runtime::UnloadNetwork(): Unloaded network with ID: " << networkId;
}
Runtime::Runtime(const CreationOptions& options)
- : m_Options{options}
+ : m_ClContextControl(options.m_GpuAccTunedParameters.get(),
+ options.m_EnableGpuProfiling)
, m_NetworkIdCounter(0)
, m_DeviceSpec{BackendRegistryInstance().GetBackendIds()}
{
BOOST_LOG_TRIVIAL(info) << "ArmNN v" << ARMNN_VERSION << "\n";
-
- for (const auto& id : BackendContextRegistryInstance().GetBackendIds())
- {
- // Store backend contexts for the supported ones
- if (m_DeviceSpec.GetSupportedBackends().count(id) > 0)
- {
- // Don't throw an exception, rather return a dummy factory if not
- // found.
- auto factoryFun = BackendContextRegistryInstance().GetFactory(
- id, [](const CreationOptions&) { return IBackendContextUniquePtr(); }
- );
-
- m_BackendContexts.emplace(std::make_pair(id, factoryFun(options)));
- }
- }
}
Runtime::~Runtime()
#include <armnn/IRuntime.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/BackendId.hpp>
-#include <backendsCommon/IBackendContext.hpp>
+
+#include <cl/ClContextControl.hpp>
#include <mutex>
#include <unordered_map>
}
mutable std::mutex m_Mutex;
+
std::unordered_map<NetworkId, std::unique_ptr<LoadedNetwork>> m_LoadedNetworks;
- CreationOptions m_Options;
+
+ ClContextControl m_ClContextControl;
+
int m_NetworkIdCounter;
- DeviceSpec m_DeviceSpec;
- using BackendContextMap = std::unordered_map<BackendId, IBackendContextUniquePtr>;
- BackendContextMap m_BackendContexts;
+ DeviceSpec m_DeviceSpec;
};
}
+++ /dev/null
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "BackendContextRegistry.hpp"
-
-namespace armnn
-{
-
-BackendContextRegistry& BackendContextRegistryInstance()
-{
- static BackendContextRegistry instance;
- return instance;
-}
-
-} // namespace armnn
+++ /dev/null
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-#pragma once
-
-#include "IBackendContext.hpp"
-#include "RegistryCommon.hpp"
-
-#include <armnn/IRuntime.hpp>
-#include <armnn/Types.hpp>
-
-namespace armnn
-{
-
-using BackendContextRegistry = RegistryCommon<IBackendContext,
- IBackendContextUniquePtr,
- IRuntime::CreationOptions>;
-
-BackendContextRegistry& BackendContextRegistryInstance();
-
-template <>
-struct RegisteredTypeName<IBackendContext>
-{
- static const char * Name() { return "IBackendContext"; }
-};
-
-} // namespace armnn
namespace armnn
{
-using BackendRegistry = RegistryCommon<IBackendInternal,
- IBackendInternalUniquePtr,
- EmptyInitializer>;
+using BackendRegistry = RegistryCommon<IBackendInternal, IBackendInternalUniquePtr>;
BackendRegistry& BackendRegistryInstance();
#
list(APPEND armnnBackendsCommon_sources
- BackendContextRegistry.cpp
- BackendContextRegistry.hpp
BackendRegistry.cpp
BackendRegistry.hpp
CpuTensorHandle.cpp
CpuTensorHandleFwd.hpp
CpuTensorHandle.hpp
- IBackendContext.hpp
IBackendInternal.hpp
ILayerSupport.cpp
ITensorHandle.hpp
+++ /dev/null
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-#pragma once
-
-#include <armnn/IRuntime.hpp>
-#include <memory>
-
-namespace armnn
-{
-
-class IBackendContext
-{
-public:
- virtual ~IBackendContext() {}
-
-protected:
- IBackendContext(const IRuntime::CreationOptions& options) {}
-
-private:
- IBackendContext() = delete;
-};
-
-using IBackendContextUniquePtr = std::unique_ptr<IBackendContext>;
-
-} // namespace armnn
//
#pragma once
-#include <armnn/IBackend.hpp>
-#include <memory>
+#include <armnn/Types.hpp>
namespace armnn
{
class IBackendInternal : public IBackend
{
protected:
+ // Creation must be done through a specific
+ // backend interface.
IBackendInternal() = default;
public:
#include "RegistryCommon.hpp"
#include <armnn/ILayerSupport.hpp>
-#include <armnn/Types.hpp>
namespace armnn
{
-using LayerSupportRegistry = RegistryCommon<ILayerSupport,
- ILayerSupportSharedPtr,
- EmptyInitializer>;
+
+using LayerSupportRegistry = RegistryCommon<ILayerSupport, ILayerSupportSharedPtr>;
LayerSupportRegistry& LayerSupportRegistryInstance();
static const char * Name() { return "UNKNOWN"; }
};
-template <typename RegisteredType, typename PointerType, typename ParamType>
+template <typename RegisteredType, typename PointerType>
class RegistryCommon
{
public:
- using FactoryFunction = std::function<PointerType(const ParamType&)>;
+ using FactoryFunction = std::function<PointerType()>;
void Register(const BackendId& id, FactoryFunction factory)
{
return it->second;
}
- FactoryFunction GetFactory(const BackendId& id,
- FactoryFunction defaultFactory) const
- {
- auto it = m_Factories.find(id);
- if (it == m_Factories.end())
- {
- return defaultFactory;
- }
- else
- {
- return it->second;
- }
- }
-
size_t Size() const
{
return m_Factories.size();
}
};
-} // namespace armnn
\ No newline at end of file
+} // namespace armnn
auto const& layerSupportRegistry = LayerSupportRegistryInstance();
auto layerSupportFactory = layerSupportRegistry.GetFactory(backendId);
- auto layerSupportObject = layerSupportFactory(EmptyInitializer());
+ auto layerSupportObject = layerSupportFactory();
switch(layer.GetType())
{
# file in the root of ArmNN
COMMON_SOURCES := \
- BackendContextRegistry.cpp \
BackendRegistry.cpp \
CpuTensorHandle.cpp \
ILayerSupport.cpp \
test/WorkloadDataValidation.cpp \
test/TensorCopyUtils.cpp \
test/LayerTests.cpp
-
StaticRegistryInitializer<BackendRegistry> factoryHelper(
BackendRegistryInstance(),
"HelloWorld",
- [&called](const EmptyInitializer&)
+ [&called]()
{
called = true;
return armnn::IBackendInternalUniquePtr(nullptr);
// sanity check: the factory still not called
BOOST_TEST(called == false);
- factoryFunction(EmptyInitializer());
+ factoryFunction();
BOOST_TEST(called == true);
}
bool called = false;
BackendRegistryInstance().Register(
"HelloWorld",
- [&called](const EmptyInitializer&)
+ [&called]()
{
called = true;
return armnn::IBackendInternalUniquePtr(nullptr);
// sanity check: the factory still not called
BOOST_TEST(called == false);
- factoryFunction(EmptyInitializer());
+ factoryFunction();
BOOST_TEST(called == true);
}
# SPDX-License-Identifier: MIT
#
-list(APPEND armnnClBackend_sources
- ClBackendId.hpp
- ClLayerSupport.cpp
- ClLayerSupport.hpp
- ClWorkloadFactory.cpp
- ClWorkloadFactory.hpp
-)
-
if(ARMCOMPUTECL)
list(APPEND armnnClBackend_sources
- ClBackendContext.cpp
- ClBackendContext.hpp
ClBackend.cpp
ClBackend.hpp
+ ClBackendId.hpp
ClContextControl.cpp
ClContextControl.hpp
+ ClLayerSupport.cpp
+ ClLayerSupport.hpp
ClTensorHandle.hpp
+ ClWorkloadFactory.cpp
+ ClWorkloadFactory.hpp
OpenClTimer.cpp
OpenClTimer.hpp
)
if(BUILD_UNIT_TESTS)
add_subdirectory(test)
endif()
+
+else()
+ list(APPEND armnnClBackend_sources
+ ClBackendId.hpp
+ ClContextControl.cpp
+ ClContextControl.hpp
+ ClLayerSupport.cpp
+ ClLayerSupport.hpp
+ ClWorkloadFactory.cpp
+ ClWorkloadFactory.hpp
+ )
endif()
add_library(armnnClBackend OBJECT ${armnnClBackend_sources})
target_include_directories(armnnClBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnClBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
target_include_directories(armnnClBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
-
#include "ClWorkloadFactory.hpp"
#include <backendsCommon/BackendRegistry.hpp>
-#include <boost/log/trivial.hpp>
namespace armnn
{
{
BackendRegistryInstance(),
ClBackend::GetIdStatic(),
- [](const EmptyInitializer&)
+ []()
{
return IBackendInternalUniquePtr(new ClBackend);
}
};
-} // anonymous namespace
+}
const BackendId& ClBackend::GetIdStatic()
{
return std::make_unique<ClWorkloadFactory>();
}
-} // namespace armnn
\ No newline at end of file
+} // namespace armnn
class ClBackend : public IBackendInternal
{
public:
- ClBackend() = default;
- ~ClBackend() override = default;
+ ClBackend() = default;
+ ~ClBackend() = default;
static const BackendId& GetIdStatic();
const BackendId& GetId() const override { return GetIdStatic(); }
+++ /dev/null
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "ClBackendContext.hpp"
-#include "ClBackendId.hpp"
-#include "ClContextControl.hpp"
-
-#include <backendsCommon/BackendContextRegistry.hpp>
-#include <boost/log/trivial.hpp>
-
-#include <mutex>
-
-#ifdef ARMCOMPUTECL_ENABLED
-// Needed for the CL scheduler calls
-#include <arm_compute/core/CL/OpenCL.h>
-#include <arm_compute/core/CL/CLKernelLibrary.h>
-#include <arm_compute/runtime/CL/CLScheduler.h>
-#endif
-
-namespace armnn
-{
-
-namespace
-{
-
-static StaticRegistryInitializer<BackendContextRegistry> g_RegisterHelper
-{
- BackendContextRegistryInstance(),
- ClBackendId(),
- [](const IRuntime::CreationOptions& options)
- {
- return IBackendContextUniquePtr(new ClBackendContext{options});
- }
-};
-
-static std::mutex g_ContextControlMutex;
-
-std::shared_ptr<ClBackendContext::ContextControlWrapper>
-GetContextControlWrapper(const IRuntime::CreationOptions& options)
-{
- static std::weak_ptr<ClBackendContext::ContextControlWrapper> contextControlWrapper;
-
- std::lock_guard<std::mutex> lockGuard(g_ContextControlMutex);
- std::shared_ptr<ClBackendContext::ContextControlWrapper> result;
-
- if (contextControlWrapper.expired())
- {
- result = std::make_shared<ClBackendContext::ContextControlWrapper>(options);
- contextControlWrapper = result;
- }
- else
- {
- result = contextControlWrapper.lock();
- }
-
- return result;
-}
-
-} // anonymous namespace
-
-
-#ifdef ARMCOMPUTECL_ENABLED
-struct ClBackendContext::ContextControlWrapper
-{
- ContextControlWrapper(const IRuntime::CreationOptions& options)
- : m_ClContextControl{options.m_GpuAccTunedParameters.get(),
- options.m_EnableGpuProfiling}
- {
- }
-
- ~ContextControlWrapper()
- {
- if (arm_compute::CLScheduler::get().context()() != NULL)
- {
- // Waits for all queued CL requests to finish before unloading the network they may be using.
- try
- {
- // Coverity fix: arm_compute::CLScheduler::sync() may throw an exception of type cl::Error.
- arm_compute::CLScheduler::get().sync();
- m_ClContextControl.ClearClCache();
- }
- catch (const cl::Error&)
- {
- BOOST_LOG_TRIVIAL(warning) << "WARNING: Runtime::UnloadNetwork(): an error occurred while waiting for "
- "the queued CL requests to finish";
- }
- }
- }
-
- ClContextControl m_ClContextControl;
-};
-#else //ARMCOMPUTECL_ENABLED
-struct ClBackendContext::ContextControlWrapper
-{
- ContextControlWrapper(const IRuntime::CreationOptions&){}
-};
-#endif //ARMCOMPUTECL_ENABLED
-
-ClBackendContext::ClBackendContext(const IRuntime::CreationOptions& options)
-: IBackendContext{options}
-, m_ContextControl{GetContextControlWrapper(options)}
-{
-}
-
-ClBackendContext::~ClBackendContext()
-{
-}
-
-} // namespace armnn
\ No newline at end of file
+++ /dev/null
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-#pragma once
-
-#include <backendsCommon/IBackendContext.hpp>
-
-namespace armnn
-{
-
-class ClBackendContext : public IBackendContext
-{
-public:
- ClBackendContext(const IRuntime::CreationOptions& options);
- ~ClBackendContext() override;
-
- struct ContextControlWrapper;
-private:
- std::shared_ptr<ContextControlWrapper> m_ContextControl;
-};
-
-} // namespace armnn
\ No newline at end of file
static StaticRegistryInitializer<LayerSupportRegistry> g_RegisterHelper{
LayerSupportRegistryInstance(),
ClBackendId(),
- [](const EmptyInitializer&)
+ []()
{
return GetLayerSupportPointer();
}
# file in the root of ArmNN
BACKEND_SOURCES := \
- ClBackendContext.cpp \
ClBackend.cpp \
ClContextControl.cpp \
ClLayerSupport.cpp \
test/ClRuntimeTests.cpp \
test/Fp16SupportTest.cpp \
test/OpenClTimerTest.cpp
-
# SPDX-License-Identifier: MIT
#
-list(APPEND armnnNeonBackend_sources
- NeonBackendId.hpp
- NeonLayerSupport.cpp
- NeonLayerSupport.hpp
- NeonWorkloadFactory.cpp
- NeonWorkloadFactory.hpp
-)
-
if(ARMCOMPUTENEON)
list(APPEND armnnNeonBackend_sources
NeonBackend.cpp
NeonBackend.hpp
+ NeonBackendId.hpp
NeonInterceptorScheduler.hpp
NeonInterceptorScheduler.cpp
+ NeonLayerSupport.cpp
+ NeonLayerSupport.hpp
+ NeonWorkloadFactory.cpp
+ NeonWorkloadFactory.hpp
NeonTensorHandle.hpp
NeonTimer.hpp
NeonTimer.cpp
if(BUILD_UNIT_TESTS)
add_subdirectory(test)
endif()
+
+else()
+ list(APPEND armnnNeonBackend_sources
+ NeonBackendId.hpp
+ NeonLayerSupport.cpp
+ NeonLayerSupport.hpp
+ NeonWorkloadFactory.cpp
+ NeonWorkloadFactory.hpp
+ )
endif()
add_library(armnnNeonBackend OBJECT ${armnnNeonBackend_sources})
target_include_directories(armnnNeonBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnn)
target_include_directories(armnnNeonBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/armnnUtils)
target_include_directories(armnnNeonBackend PRIVATE ${PROJECT_SOURCE_DIR}/src/backends)
-
#include <backendsCommon/BackendRegistry.hpp>
+#include <boost/cast.hpp>
+
namespace armnn
{
{
BackendRegistryInstance(),
NeonBackend::GetIdStatic(),
- [](const EmptyInitializer&)
+ []()
{
return IBackendInternalUniquePtr(new NeonBackend);
}
class NeonBackend : public IBackendInternal
{
public:
- NeonBackend() = default;
- ~NeonBackend() override = default;
+ NeonBackend() = default;
+ ~NeonBackend() = default;
static const BackendId& GetIdStatic();
const BackendId& GetId() const override { return GetIdStatic(); }
static StaticRegistryInitializer<LayerSupportRegistry> g_RegisterHelper{
LayerSupportRegistryInstance(),
NeonBackendId(),
- [](const EmptyInitializer&)
+ []()
{
return GetLayerSupportPointer();
}
test/NeonOptimizedNetworkTests.cpp \
test/NeonRuntimeTests.cpp \
test/NeonTimerTest.cpp
-
if(BUILD_UNIT_TESTS)
add_subdirectory(test)
endif()
-
#include <backendsCommon/BackendRegistry.hpp>
+#include <boost/cast.hpp>
+
namespace armnn
{
{
BackendRegistryInstance(),
RefBackend::GetIdStatic(),
- [](const EmptyInitializer&)
+ []()
{
return IBackendInternalUniquePtr(new RefBackend);
}
class RefBackend : public IBackendInternal
{
public:
- RefBackend() = default;
- ~RefBackend() override = default;
+ RefBackend() = default;
+ ~RefBackend() = default;
static const BackendId& GetIdStatic();
const BackendId& GetId() const override { return GetIdStatic(); }
static StaticRegistryInitializer<LayerSupportRegistry> g_RegisterHelper{
LayerSupportRegistryInstance(),
RefBackendId(),
- [](const EmptyInitializer&)
+ []()
{
return GetLayerSupportPointer();
}
test/RefLayerTests.cpp \
test/RefOptimizedNetworkTests.cpp \
test/RefRuntimeTests.cpp
-
projects / platform / upstream / armnn.git / commitdiff