blob: c548683e3e947f516a5856271ae365eea8e4407b (
plain)
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
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Types.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/Deprecated.hpp>
#include <ISubgraphViewConverter.hpp>
#include <SubgraphView.hpp>
#include <optimizations/Optimization.hpp>
#include "IBackendContext.hpp"
#include "IMemoryManager.hpp"
#include "ITensorHandleFactory.hpp"
#include "OptimizationViews.hpp"
#include <vector>
namespace armnn
{
class IWorkloadFactory;
class IMemoryManager;
class ILayerSupport;
struct BackendVersion
{
uint32_t m_Major;
uint32_t m_Minor;
BackendVersion()
: m_Major(0)
, m_Minor(0)
{}
BackendVersion(uint32_t major, uint32_t minor)
: m_Major(major)
, m_Minor(minor)
{}
bool operator==(const BackendVersion& other) const
{
return this == &other ||
(this->m_Major == other.m_Major &&
this->m_Minor == other.m_Minor);
}
bool operator<=(const BackendVersion& other) const
{
return this->m_Major < other.m_Major ||
(this->m_Major == other.m_Major &&
this->m_Minor <= other.m_Minor);
}
};
inline std::ostream& operator<<(std::ostream& os, const BackendVersion& backendVersion)
{
os << "[" << backendVersion.m_Major << "." << backendVersion.m_Minor << "]";
return os;
}
class IBackendInternal : public IBackend
{
protected:
// Creation must be done through a specific
// backend interface.
IBackendInternal() = default;
public:
// Allow backends created by the factory function
// to be destroyed through IBackendInternal.
~IBackendInternal() override = default;
using IWorkloadFactoryPtr = std::unique_ptr<IWorkloadFactory>;
using IBackendContextPtr = std::unique_ptr<IBackendContext>;
using OptimizationPtr = std::unique_ptr<Optimization>;
using Optimizations = std::vector<OptimizationPtr>;
using ILayerSupportSharedPtr = std::shared_ptr<ILayerSupport>;
using IMemoryManagerUniquePtr = std::unique_ptr<IMemoryManager>;
using IMemoryManagerSharedPtr = std::shared_ptr<IMemoryManager>;
using GraphUniquePtr = std::unique_ptr<Graph>;
using SubgraphViewUniquePtr = std::unique_ptr<SubgraphView>;
ARMNN_NO_DEPRECATE_WARN_BEGIN
using ISubGraphConverterPtr ARMNN_DEPRECATED_MSG("This type is no longer supported")
= std::unique_ptr<ISubGraphConverter>;
using SubGraphUniquePtr ARMNN_DEPRECATED_MSG("SubGraph is deprecated, use SubgraphView instead")
= std::unique_ptr<SubGraph>;
ARMNN_DEPRECATED_MSG("This method is no longer supported")
virtual ISubGraphConverterPtr CreateSubGraphConverter(const std::shared_ptr<SubGraph>& subGraph) const
{
return ISubGraphConverterPtr{};
}
ARMNN_DEPRECATED_MSG("Use \"OptimizationViews OptimizeSubgraphView(const SubgraphView&)\" instead")
virtual Optimizations GetOptimizations() const
{
return Optimizations{};
}
ARMNN_DEPRECATED_MSG("Use \"OptimizationViews OptimizeSubgraphView(const SubgraphView&)\" instead")
virtual SubGraphUniquePtr OptimizeSubGraph(const SubGraph& subGraph, bool& optimizationAttempted) const
{
optimizationAttempted = false;
return nullptr;
}
ARMNN_NO_DEPRECATE_WARN_END
virtual IMemoryManagerUniquePtr CreateMemoryManager() const
{
return IMemoryManagerUniquePtr();
}
virtual IWorkloadFactoryPtr CreateWorkloadFactory(
const IMemoryManagerSharedPtr& memoryManager = nullptr) const = 0;
virtual IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const
{
return IBackendContextPtr{};
}
virtual ILayerSupportSharedPtr GetLayerSupport() const = 0;
// Default implementation of OptimizeSubgraphView for backward compatibility with the old API.
// Override this method with a custom optimization implementation.
virtual OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph) const
{
bool optimizationAttempted = false;
ARMNN_NO_DEPRECATE_WARN_BEGIN
SubGraphUniquePtr optSubgraph = OptimizeSubGraph(subgraph, optimizationAttempted);
ARMNN_NO_DEPRECATE_WARN_END
OptimizationViews result;
if (!optimizationAttempted)
{
result.AddUntouchedSubgraph(SubgraphView(subgraph));
}
else
{
if (optSubgraph)
{
result.AddSubstitution({subgraph, SubgraphView(*optSubgraph.get())});
}
else
{
result.AddFailedSubgraph(SubgraphView(subgraph));
}
}
return result;
}
bool SupportsTensorAllocatorAPI() const { return GetHandleFactoryPreferences().empty() == false; }
ITensorHandleFactory::FactoryId GetBackwardCompatibleFavoriteHandleFactory()
{
auto favorites = GetHandleFactoryPreferences();
if (favorites.empty())
{
return ITensorHandleFactory::LegacyFactoryId;
}
return favorites[0];
}
/// (Optional) Returns a vector of supported TensorHandleFactory ids in preference order.
virtual std::vector<ITensorHandleFactory::FactoryId> GetHandleFactoryPreferences() const
{
return std::vector<ITensorHandleFactory::FactoryId>();
}
/// (Optional) Register TensorHandleFactories
/// Either this method or CreateMemoryManager() and
/// IWorkloadFactory::CreateTensor()/IWorkloadFactory::CreateSubtensor() methods must be implemented.
virtual void RegisterTensorHandleFactories(class TensorHandleFactoryRegistry& registry) {}
/// Returns the version of the Backend API
static BackendVersion GetApiVersion() { return { 1, 0 }; }
};
using IBackendInternalUniquePtr = std::unique_ptr<IBackendInternal>;
} // namespace armnn
|
