5 #include <boost/test/unit_test.hpp> 22 #include <boost/core/ignore_unused.hpp> 24 using namespace armnn;
29 TestMemMgr() =
default;
31 void Acquire()
override {}
32 void Release()
override {}
43 std::unique_ptr<ITensorHandle> CreateSubTensorHandle(
ITensorHandle& parent,
45 unsigned int const* subTensorOrigin)
const override 47 boost::ignore_unused(parent, subTensorShape, subTensorOrigin);
51 std::unique_ptr<ITensorHandle> CreateTensorHandle(
const TensorInfo& tensorInfo)
const override 53 boost::ignore_unused(tensorInfo);
57 std::unique_ptr<ITensorHandle> CreateTensorHandle(
const TensorInfo& tensorInfo,
60 boost::ignore_unused(tensorInfo, dataLayout);
64 const FactoryId& GetId()
const override {
return m_Id; }
66 bool SupportsSubTensors()
const override {
return true; }
73 std::weak_ptr<IMemoryManager> m_MemMgr;
84 std::unique_ptr<ITensorHandle> CreateSubTensorHandle(
ITensorHandle& parent,
86 unsigned int const* subTensorOrigin)
const override 88 boost::ignore_unused(parent, subTensorShape, subTensorOrigin);
92 std::unique_ptr<ITensorHandle> CreateTensorHandle(
const TensorInfo& tensorInfo)
const override 94 boost::ignore_unused(tensorInfo);
98 std::unique_ptr<ITensorHandle> CreateTensorHandle(
const TensorInfo& tensorInfo,
101 boost::ignore_unused(tensorInfo, dataLayout);
105 const FactoryId& GetId()
const override {
return m_Id; }
107 bool SupportsSubTensors()
const override {
return true; }
114 std::weak_ptr<IMemoryManager> m_MemMgr;
120 TestBackendA() =
default;
122 const BackendId& GetId()
const override {
return m_Id; }
124 IWorkloadFactoryPtr CreateWorkloadFactory(
const IMemoryManagerSharedPtr& memoryManager =
nullptr)
const override 126 boost::ignore_unused(memoryManager);
127 return IWorkloadFactoryPtr{};
135 std::vector<ITensorHandleFactory::FactoryId> GetHandleFactoryPreferences()
const override 137 return std::vector<ITensorHandleFactory::FactoryId>
139 "TestHandleFactoryA1",
140 "TestHandleFactoryA2",
141 "TestHandleFactoryB1" 147 auto mgr = std::make_shared<TestMemMgr>();
150 registry.
RegisterFactory(std::make_unique<TestFactory1>(mgr,
"TestHandleFactoryA1"));
151 registry.
RegisterFactory(std::make_unique<TestFactory1>(mgr,
"TestHandleFactoryA2"));
161 TestBackendB() =
default;
163 const BackendId& GetId()
const override {
return m_Id; }
165 IWorkloadFactoryPtr CreateWorkloadFactory(
const IMemoryManagerSharedPtr& memoryManager =
nullptr)
const override 167 boost::ignore_unused(memoryManager);
168 return IWorkloadFactoryPtr{};
176 std::vector<ITensorHandleFactory::FactoryId> GetHandleFactoryPreferences()
const override 178 return std::vector<ITensorHandleFactory::FactoryId>
180 "TestHandleFactoryB1" 186 auto mgr = std::make_shared<TestMemMgr>();
189 registry.
RegisterFactory(std::make_unique<TestFactory1>(mgr,
"TestHandleFactoryB1"));
199 TestBackendC() =
default;
201 const BackendId& GetId()
const override {
return m_Id; }
203 IWorkloadFactoryPtr CreateWorkloadFactory(
const IMemoryManagerSharedPtr& memoryManager =
nullptr)
const override 205 boost::ignore_unused(memoryManager);
206 return IWorkloadFactoryPtr{};
214 std::vector<ITensorHandleFactory::FactoryId> GetHandleFactoryPreferences()
const override 216 return std::vector<ITensorHandleFactory::FactoryId>{
217 "TestHandleFactoryC1" 223 auto mgr = std::make_shared<TestMemMgr>();
226 registry.
RegisterFactory(std::make_unique<TestFactory1>(mgr,
"TestHandleFactoryC1"));
236 TestBackendD() =
default;
238 const BackendId& GetId()
const override {
return m_Id; }
240 IWorkloadFactoryPtr CreateWorkloadFactory(
const IMemoryManagerSharedPtr& memoryManager =
nullptr)
const override 242 boost::ignore_unused(memoryManager);
243 return IWorkloadFactoryPtr{};
251 std::vector<ITensorHandleFactory::FactoryId> GetHandleFactoryPreferences()
const override 253 return std::vector<ITensorHandleFactory::FactoryId>{
254 "TestHandleFactoryD1" 260 auto mgr = std::make_shared<TestMemMgr>();
263 registry.
RegisterFactory(std::make_unique<TestFactoryImport>(mgr,
"TestHandleFactoryD1"));
275 TestBackendA backendA;
276 TestBackendB backendB;
278 BOOST_TEST(backendA.GetHandleFactoryPreferences()[0] ==
"TestHandleFactoryA1");
279 BOOST_TEST(backendA.GetHandleFactoryPreferences()[1] ==
"TestHandleFactoryA2");
280 BOOST_TEST(backendA.GetHandleFactoryPreferences()[2] ==
"TestHandleFactoryB1");
283 backendA.RegisterTensorHandleFactories(registry);
284 backendB.RegisterTensorHandleFactories(registry);
286 BOOST_TEST((registry.GetFactory(
"Non-existing Backend") ==
nullptr));
287 BOOST_TEST((registry.GetFactory(
"TestHandleFactoryA1") !=
nullptr));
288 BOOST_TEST((registry.GetFactory(
"TestHandleFactoryA2") !=
nullptr));
289 BOOST_TEST((registry.GetFactory(
"TestHandleFactoryB1") !=
nullptr));
294 auto backendA = std::make_unique<TestBackendA>();
295 auto backendB = std::make_unique<TestBackendB>();
296 auto backendC = std::make_unique<TestBackendC>();
297 auto backendD = std::make_unique<TestBackendD>();
300 backendA->RegisterTensorHandleFactories(registry);
301 backendB->RegisterTensorHandleFactories(registry);
302 backendC->RegisterTensorHandleFactories(registry);
303 backendD->RegisterTensorHandleFactories(registry);
306 backends[
"BackendA"] = std::move(backendA);
307 backends[
"BackendB"] = std::move(backendB);
308 backends[
"BackendC"] = std::move(backendC);
309 backends[
"BackendD"] = std::move(backendD);
340 std::vector<std::string> errors;
343 BOOST_TEST(result.m_Error ==
false);
344 BOOST_TEST(result.m_Warning ==
false);
377 BOOST_TEST(copyCount == 1);
388 BOOST_TEST(importCount == 1);
LayerType GetType() const
Graph & TopologicalSort()
Sorts layers in topological order and return this.
void RegisterFactory(std::unique_ptr< ITensorHandleFactory > allocator)
Register a TensorHandleFactory and transfer ownership.
No strategy has been defined. Used internally to verify integrity of optimizations.
This layer represents a softmax operation.
BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
ITensorHandleFactory::FactoryId GetTensorHandleFactoryId() const
LayerT * AddLayer(Args &&... args)
Adds a new layer, of type LayerType, to the graph constructed with the arguments passed.
Source backends tensor data can be exported to destination backend tensor without copy...
int Connect(InputSlot &destination)
EdgeStrategy GetEdgeStrategyForConnection(unsigned int connectionIdx) const
std::shared_ptr< ILayerSupport > ILayerSupportSharedPtr
OptimizationResult SelectTensorHandleStrategy(Graph &optGraph, BackendsMap &backends, TensorHandleFactoryRegistry ®istry, Optional< std::vector< std::string > &> errMessages)
void AddCompatibilityLayers(std::map< BackendId, std::unique_ptr< class IBackendInternal >> &backends, TensorHandleFactoryRegistry ®istry)
ITensorHandleFactory::FactoryId FactoryId
void SetBackendId(const BackendId &id)
std::map< BackendId, std::unique_ptr< class IBackendInternal > > BackendsMap
unsigned int MemorySourceFlags
Destination backend can work directly with tensors on source backend.
void ForEachLayer(Func func) const
A layer user-provided data can be bound to (e.g. inputs, outputs).
BOOST_AUTO_TEST_SUITE_END()
A SoftmaxDescriptor for the SoftmaxLayer.
std::shared_ptr< ILayerSupport > ILayerSupportSharedPtr
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
void RegisterMemoryManager(std::shared_ptr< IMemoryManager > memoryManger)
Register a memory manager with shared ownership.
const OutputSlot & GetOutputSlot(unsigned int index=0) const override
const InputSlot & GetInputSlot(unsigned int index) const override