1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefBackend.hpp"
#include "RefBackendId.hpp"
#include "RefWorkloadFactory.hpp"
#include "RefLayerSupport.hpp"
#include "RefTensorHandleFactory.hpp"
#include <armnn/BackendRegistry.hpp>
#include <armnn/backends/IBackendContext.hpp>
#include <armnn/backends/IMemoryManager.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <backendsCommon/DefaultAllocator.hpp>
#include <backendsCommon/SubgraphUtils.hpp>
namespace armnn
{
const BackendId& RefBackend::GetIdStatic()
{
static const BackendId s_Id{RefBackendId()};
return s_Id;
}
IBackendInternal::IWorkloadFactoryPtr RefBackend::CreateWorkloadFactory(
const IBackendInternal::IMemoryManagerSharedPtr& memoryManager) const
{
return std::make_unique<RefWorkloadFactory>(PolymorphicPointerDowncast<RefMemoryManager>(memoryManager));
}
IBackendInternal::IWorkloadFactoryPtr RefBackend::CreateWorkloadFactory(
class TensorHandleFactoryRegistry& tensorHandleFactoryRegistry) const
{
auto memoryManager = std::make_shared<RefMemoryManager>();
tensorHandleFactoryRegistry.RegisterMemoryManager(memoryManager);
std::unique_ptr<RefTensorHandleFactory> factory = std::make_unique<RefTensorHandleFactory>(memoryManager);
// Register copy and import factory pair
tensorHandleFactoryRegistry.RegisterCopyAndImportFactoryPair(factory->GetId(), factory->GetId());
// Register the factory
tensorHandleFactoryRegistry.RegisterFactory(std::move(factory));
return std::make_unique<RefWorkloadFactory>(PolymorphicPointerDowncast<RefMemoryManager>(memoryManager));
}
IBackendInternal::IBackendContextPtr RefBackend::CreateBackendContext(const IRuntime::CreationOptions&) const
{
return IBackendContextPtr{};
}
IBackendInternal::IBackendProfilingContextPtr RefBackend::CreateBackendProfilingContext(
const IRuntime::CreationOptions&, IBackendProfilingPtr&)
{
return IBackendProfilingContextPtr{};
}
IBackendInternal::IMemoryManagerUniquePtr RefBackend::CreateMemoryManager() const
{
return std::make_unique<RefMemoryManager>();
}
IBackendInternal::ILayerSupportSharedPtr RefBackend::GetLayerSupport() const
{
static ILayerSupportSharedPtr layerSupport{new RefLayerSupport};
return layerSupport;
}
OptimizationViews RefBackend::OptimizeSubgraphView(const SubgraphView& subgraph,
const ModelOptions& modelOptions) const
{
OptimizationViews optimizationViews(modelOptions);
auto it = subgraph.endIConnectable();
std::map<LayerGuid, Layer*> untouched;
while (it != subgraph.beginIConnectable())
{
--it;
Layer& base = *(PolymorphicDowncast<Layer*>(*it));
untouched.insert({base.GetGuid(), &base});
}
it = subgraph.endIConnectable();
while (it != subgraph.beginIConnectable())
{
--it;
Layer& base = *(PolymorphicDowncast<Layer*>(*it));
// Special case to fuse padding into average pooling 2d for quantized datatype.
// Required to be done as a backend specific optimization as Neon does not support this special case.
if (base.GetType() == LayerType::Pooling2d)
{
Pooling2dLayer* baseLayer = PolymorphicDowncast<Pooling2dLayer*>(&base);
Pooling2dDescriptor poolingDescriptor = baseLayer->GetParameters();
if (baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetOwningLayer().GetType() == LayerType::Pad)
{
PadLayer* padLayer = PolymorphicDowncast<PadLayer*>(
&baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetOwningLayer());
if (padLayer->GetOutputSlot(0).GetNumConnections() == 1 &&
optimizations::pad_fold::TryFoldPadIntoLayer2d(padLayer->GetParameters(),
poolingDescriptor,
padLayer->GetOutputSlot().GetTensorInfo(),
true))
{
FoldPadIntoAveragePool2d<Pooling2dLayer>(optimizationViews, baseLayer,
poolingDescriptor, padLayer);
untouched.erase(baseLayer->GetGuid());
untouched.erase(padLayer->GetGuid());
}
}
}
// Remove Reshape where possible
if (base.GetType() == LayerType::Reshape)
{
ReshapeLayer* baseLayer = PolymorphicDowncast<ReshapeLayer*>(&base);
RemoveReshapeLayer(baseLayer, untouched, optimizationViews);
}
}
if (optimizationViews.GetSubstitutions().empty() && optimizationViews.GetDeletedSubgraphs().empty())
{
optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph));
}
else
{
ReportUntouchedLayers(optimizationViews, untouched);
}
return optimizationViews;
}
std::vector<ITensorHandleFactory::FactoryId> RefBackend::GetHandleFactoryPreferences() const
{
return std::vector<ITensorHandleFactory::FactoryId> { RefTensorHandleFactory::GetIdStatic() };
}
void RefBackend::RegisterTensorHandleFactories(class TensorHandleFactoryRegistry& registry)
{
auto memoryManager = std::make_shared<RefMemoryManager>();
registry.RegisterMemoryManager(memoryManager);
std::unique_ptr<RefTensorHandleFactory> factory = std::make_unique<RefTensorHandleFactory>(memoryManager);
// Register copy and import factory pair
registry.RegisterCopyAndImportFactoryPair(factory->GetId(), factory->GetId());
// Register the factory
registry.RegisterFactory(std::move(factory));
}
std::unique_ptr<ICustomAllocator> RefBackend::GetDefaultAllocator() const
{
return std::make_unique<DefaultAllocator>();
}
ExecutionData RefBackend::CreateExecutionData(WorkingMemDescriptor& workingMemDescriptor) const
{
ExecutionData executionData;
executionData.m_Data = &workingMemDescriptor;
return executionData;
}
void RefBackend::UpdateExecutionData(ExecutionData& executionData, WorkingMemDescriptor& workingMemDescriptor) const
{
executionData.m_Data = &workingMemDescriptor;
}
} // namespace armnn
|
