Compute Library
 22.08
CLDeviceBackend.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018-2021 Arm Limited.
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to
8  * deal in the Software without restriction, including without limitation the
9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10  * sell copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
25 
36 
45 
47 
48 namespace arm_compute
49 {
50 namespace graph
51 {
52 namespace backends
53 {
54 namespace
55 {
56 bool file_exists(const std::string &filename)
57 {
58  std::ifstream file(filename);
59  return file.good();
60 }
61 } // namespace
62 
63 /** Register CL backend */
64 static detail::BackendRegistrar<CLDeviceBackend> CLDeviceBackend_registrar(Target::CL);
65 
67  : _context_count(0), _tuner(), _gemm_heuristics(), _allocator(nullptr), _tuner_file(), _backend_type(CLBackendType::Native)
68 {
69 }
70 
72 {
73  _tuner.save_to_file(_tuner_file);
74 }
75 
76 void CLDeviceBackend::set_kernel_tuning(bool enable_tuning)
77 {
78  _tuner.set_tune_new_kernels(enable_tuning);
79 }
80 
82 {
83  _tuner.set_tuner_mode(tuning_mode);
84 }
85 
87 {
88  // Setup Scheduler
89  CLScheduler::get().default_init(&_tuner, &_gemm_heuristics, _backend_type);
90  // Create allocator with new context
91  _allocator = std::make_unique<CLBufferAllocator>();
92 }
93 
95 {
96  ARM_COMPUTE_UNUSED(ctx);
97  _context_count--;
98  if(_context_count == 0) // No more context using the backend: free resources
99  {
100  _allocator = nullptr;
101  }
102 }
103 
105 {
106  // Force backend initialization
107  _context_count++;
108  if(_context_count == 1)
109  {
110  _backend_type = ctx.config().backend_type;
112  }
113 
114  // Setup tuner
115  _tuner_file = ctx.config().tuner_file;
116 
117  // Load tuner data if available
118  if(file_exists(_tuner_file))
119  {
120  _tuner.load_from_file(_tuner_file);
121  }
122 
125 
126  // Attempt to load mlgo heuristics
127  ARM_COMPUTE_ERROR_ON(CLScheduler::get().gemm_heuristics() == nullptr);
129 
130  // Setup a management backend
131  if(ctx.memory_management_ctx(Target::CL) == nullptr)
132  {
133  MemoryManagerContext mm_ctx;
134  mm_ctx.target = Target::CL;
137  mm_ctx.cross_group = std::make_shared<MemoryGroup>(mm_ctx.cross_mm);
138  mm_ctx.allocator = _allocator.get();
139 
140  ctx.insert_memory_management_ctx(std::move(mm_ctx));
141  }
142 
143  // Create function level weights manager
144  if(ctx.weights_management_ctx(Target::CL) == nullptr)
145  {
146  WeightsManagerContext wm_ctx;
147  wm_ctx.target = Target::CL;
148  wm_ctx.wm = create_weights_manager();
149 
150  ctx.insert_weights_management_ctx(std::move(wm_ctx));
151  }
152 }
153 
155 {
157 }
158 
160 {
161  return _allocator.get();
162 }
163 
164 std::unique_ptr<ITensorHandle> CLDeviceBackend::create_tensor(const Tensor &tensor)
165 {
166  // Get tensor descriptor
167  const TensorDescriptor &tensor_desc = tensor.desc();
168  ARM_COMPUTE_ERROR_ON(tensor_desc.target != Target::CL);
169 
170  // Create backend tensor handle
171  TensorInfo info(tensor_desc.shape, 1, tensor_desc.data_type, tensor_desc.quant_info);
172  info.set_data_layout(tensor_desc.layout);
173 
174  return std::make_unique<CLTensorHandle>(info);
175 }
176 
177 std::unique_ptr<ITensorHandle> CLDeviceBackend::create_subtensor(ITensorHandle *parent, TensorShape shape, Coordinates coords, bool extend_parent)
178 {
179  if(parent == nullptr)
180  {
181  return nullptr;
182  }
183 
184  return std::make_unique<CLSubTensorHandle>(parent, shape, coords, extend_parent);
185 }
186 
187 std::unique_ptr<arm_compute::IFunction> CLDeviceBackend::configure_node(INode &node, GraphContext &ctx)
188 {
189  ARM_COMPUTE_LOG_GRAPH_VERBOSE("Configuring CL node with ID : " << node.id() << std::endl);
191 
192  // Configure node
193  return CLFunctionFactory::create(&node, ctx);
194 }
195 
197 {
198  ARM_COMPUTE_LOG_GRAPH_VERBOSE("Validating CL node with ID : " << node.id() << std::endl);
200 
201  return CLNodeValidator::validate(&node);
202 }
203 
204 std::shared_ptr<arm_compute::IMemoryManager> CLDeviceBackend::create_memory_manager(MemoryManagerAffinity affinity)
205 {
206  if(affinity == MemoryManagerAffinity::Offset)
207  {
208  ARM_COMPUTE_LOG_GRAPH_WARNING("CL Backend does not support offset affinity memory management!");
209  return nullptr;
210  }
211 
212  auto lifetime_mgr = std::make_shared<BlobLifetimeManager>();
213  auto pool_mgr = std::make_shared<PoolManager>();
214  auto mm = std::make_shared<MemoryManagerOnDemand>(lifetime_mgr, pool_mgr);
215 
216  return mm;
217 }
218 
219 std::shared_ptr<arm_compute::IWeightsManager> CLDeviceBackend::create_weights_manager()
220 {
221  auto weights_mgr = std::make_shared<IWeightsManager>();
222  return weights_mgr;
223 }
224 
226 {
228 }
229 } // namespace backends
230 } // namespace graph
231 } // namespace arm_compute
void setup_backend_context(GraphContext &ctx) override
Setups the given graph context.
void set_tuner_mode(CLTunerMode mode)
Set OpenCL tuner mode.
Definition: CLTuner.cpp:106
Shape of a tensor.
Definition: TensorShape.h:39
CLTunerMode tuner_mode
Tuner mode to be used by the CL tuner.
Definition: Types.h:92
void set_kernel_tuning(bool enable_tuning)
Switchs on or off the kernel tuning.
std::unique_ptr< ITensorHandle > create_subtensor(ITensorHandle *parent, TensorShape shape, Coordinates coords, bool extend_parent) override
Create a backend Sub-Tensor.
static CLScheduler & get()
Access the scheduler singleton.
void set_kernel_tuning_mode(CLTunerMode tuning_mode)
Set kernel tuning mode.
Target assigned_target() const
Returns assigned target for this node.
Definition: INode.cpp:199
bool insert_weights_management_ctx(WeightsManagerContext &&weights_ctx)
Inserts a weights manager context.
std::shared_ptr< arm_compute::IMemoryGroup > cross_group
Cross-function memory group.
Definition: GraphContext.h:45
static std::unique_ptr< arm_compute::IFunction > create(INode *node, GraphContext &ctx)
Create a backend execution function depending on the node type.
void load_from_file(const std::string &filename)
Load the tuning parameters table from file.
Definition: CLTuner.cpp:310
void default_init(ICLTuner *cl_tuner=nullptr, CLGEMMHeuristicsHandle *gemm_h=nullptr, CLBackendType cl_backend_type=CLBackendType::Native)
Initialises the context and command queue used by the scheduler to default values and sets a default ...
OpenCL native backend.
bool insert_memory_management_ctx(MemoryManagerContext &&memory_ctx)
Inserts a memory manager context.
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:466
Status class.
Definition: Error.h:52
WeightsManagerContext * weights_management_ctx(Target target)
Gets a weights manager context for a given target.
void initialize_backend() override
Initializes the backend.
std::unique_ptr< arm_compute::IFunction > configure_node(INode &node, GraphContext &ctx) override
Configure a backend Node.
CLGEMMHeuristicsHandle * gemm_heuristics() const
Accessor for the associated CLGEMMHeuristicsHandle.
Definition: CLScheduler.cpp:54
void sync() override
Synchronize kernels execution on the backend.
Copyright (c) 2017-2022 Arm Limited.
std::string mlgo_file
Filename to load MLGO heuristics from.
Definition: Types.h:95
std::string tuner_file
File to load/store tuning values from.
Definition: Types.h:94
bool is_backend_supported() override
Checks if an instantiated backend is actually supported.
TensorDescriptor & desc()
TensorInfo metadata accessor.
Definition: Tensor.cpp:40
std::shared_ptr< arm_compute::IWeightsManager > create_weights_manager() override
Create a backend weights manager.
Interface to enqueue OpenCL kernels and get/set the OpenCL CommandQueue and ICLTuner.
QuantizationInfo quant_info
Quantization info.
Node interface.
Definition: INode.h:46
ITensorInfo & set_data_layout(const DataLayout &data_layout) override
Set the data layout of the tensor.
Definition: TensorInfo.cpp:352
#define ARM_COMPUTE_UNUSED(...)
To avoid unused variables warnings.
Definition: Error.h:152
bool save_to_file(const std::string &filename) const
Save the content of the tuning parameters table to file.
Definition: CLTuner.cpp:362
bool reload_from_file(const std::string &filename)
(Re)Load the heuristics from reading a dotmlgo file
Coordinates of an item.
Definition: Coordinates.h:37
void set_tune_new_kernels(bool tune_new_kernels)
Setter for tune_new_kernels option.
Definition: CLTuner.cpp:97
void release_backend_context(GraphContext &ctx) override
Release the backend specific resources associated to a given graph context.
NodeID id() const
Returns node&#39;s ID.
Definition: INode.cpp:103
Status validate_node(INode &node) override
Validate a node.
std::shared_ptr< arm_compute::IMemoryManager > create_memory_manager(MemoryManagerAffinity affinity) override
Create a backend memory manager given its affinity.
Tensor handle interface object.
Definition: ITensorHandle.h:38
void sync()
Blocks until all commands in the associated command queue have finished.
Definition: CLScheduler.cpp:74
std::shared_ptr< arm_compute::IMemoryManager > intra_mm
Intra-function memory manager.
Definition: GraphContext.h:43
static Status validate(INode *node)
Validate a node.
ScaleKernelInfo info(interpolation_policy, default_border_mode, PixelValue(), sampling_policy, false)
#define ARM_COMPUTE_LOG_GRAPH_WARNING(x)
Definition: Logger.h:58
CLBackendType
List the possible OpenCL backends.
Definition: CLTypes.h:55
const GraphConfig & config() const
Graph configuration accessor.
std::shared_ptr< arm_compute::IMemoryManager > cross_mm
Cross-function memory manager.
Definition: GraphContext.h:44
CLTunerMode
< OpenCL tuner modes
Definition: CLTunerTypes.h:35
bool use_tuner
Use a tuner in tunable backends.
Definition: Types.h:89
Contains structs required for weights management.
Definition: GraphContext.h:50
#define ARM_COMPUTE_LOG_GRAPH_VERBOSE(x)
Definition: Logger.h:50
IAllocator * backend_allocator() override
Gets a backend memory allocator.
Contains structs required for memory management.
Definition: GraphContext.h:40
Allocator interface.
Definition: IAllocator.h:35
Store the tensor&#39;s metadata.
Definition: TensorInfo.h:43
std::unique_ptr< ITensorHandle > create_tensor(const Tensor &tensor) override
Create a backend Tensor.
IAllocator * allocator
Backend allocator to use.
Definition: GraphContext.h:46
MemoryManagerContext * memory_management_ctx(Target target)
Gets a memory manager context for a given target.
OpenCL capable target device.
CLBackendType backend_type
CL backend type to use.
Definition: Types.h:96
MemoryManagerAffinity
Backend Memory Manager affinity.
Definition: Types.h:253
std::shared_ptr< arm_compute::IWeightsManager > wm
Weights manager.
Definition: GraphContext.h:53
Tensor object.
Definition: Tensor.h:41
bool opencl_is_available()
Check if OpenCL is available.
Definition: OpenCL.cpp:188