blob: a0d6569949052123de837fc9e94d00ffe953c4c3 (
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
|
//
// 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;
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) {}
};
using IBackendInternalUniquePtr = std::unique_ptr<IBackendInternal>;
} // namespace armnn
|
