Compute Library
 21.05
CLDeviceBackend Class Referencefinal

OpenCL device backend. More...

#include <CLDeviceBackend.h>

Collaboration diagram for CLDeviceBackend:
[legend]

Public Member Functions

 CLDeviceBackend ()
 Default Constructor. More...
 
 ~CLDeviceBackend ()
 Destructor. More...
 
void set_kernel_tuning (bool enable_tuning)
 Switchs on or off the kernel tuning. More...
 
void set_kernel_tuning_mode (CLTunerMode tuning_mode)
 Set kernel tuning mode. More...
 
void initialize_backend () override
 Initializes the backend. More...
 
void setup_backend_context (GraphContext &ctx) override
 Setups the given graph context. More...
 
void release_backend_context (GraphContext &ctx) override
 Release the backend specific resources associated to a given graph context. More...
 
bool is_backend_supported () override
 Checks if an instantiated backend is actually supported. More...
 
IAllocatorbackend_allocator () override
 Gets a backend memory allocator. More...
 
std::unique_ptr< ITensorHandlecreate_tensor (const Tensor &tensor) override
 Create a backend Tensor. More...
 
std::unique_ptr< ITensorHandlecreate_subtensor (ITensorHandle *parent, TensorShape shape, Coordinates coords, bool extend_parent) override
 Create a backend Sub-Tensor. More...
 
std::unique_ptr< arm_compute::IFunctionconfigure_node (INode &node, GraphContext &ctx) override
 Configure a backend Node. More...
 
Status validate_node (INode &node) override
 Validate a node. More...
 
std::shared_ptr< arm_compute::IMemoryManagercreate_memory_manager (MemoryManagerAffinity affinity) override
 Create a backend memory manager given its affinity. More...
 
std::shared_ptr< arm_compute::IWeightsManagercreate_weights_manager () override
 Create a backend weights manager. More...
 
- Public Member Functions inherited from IDeviceBackend
virtual ~IDeviceBackend ()=default
 Virtual Destructor. More...
 

Detailed Description

OpenCL device backend.

Definition at line 41 of file CLDeviceBackend.h.

Constructor & Destructor Documentation

◆ CLDeviceBackend()

Default Constructor.

Definition at line 67 of file CLDeviceBackend.cpp.

68  : _context_count(0), _tuner(), _gemm_heuristics(), _allocator(nullptr), _tuner_file(), _backend_type(CLBackendType::Native)
69 {
70 }

References arm_compute::Native.

◆ ~CLDeviceBackend()

Destructor.

Definition at line 72 of file CLDeviceBackend.cpp.

73 {
74  _tuner.save_to_file(_tuner_file);
75 }
bool save_to_file(const std::string &filename) const
Save the content of the tuning parameters table to file.
Definition: CLTuner.cpp:332

References CLTuner::save_to_file().

Member Function Documentation

◆ backend_allocator()

IAllocator * backend_allocator ( )
overridevirtual

Gets a backend memory allocator.

Returns
Backend memory allocator

Implements IDeviceBackend.

Definition at line 160 of file CLDeviceBackend.cpp.

161 {
162  return _allocator.get();
163 }

◆ configure_node()

std::unique_ptr< arm_compute::IFunction > configure_node ( INode node,
GraphContext ctx 
)
overridevirtual

Configure a backend Node.

Note
This creates an appropriate configured backend function for the given node
Parameters
[in]nodeThe node we want to configure
[in]ctxContext to use
Returns
Backend execution function

Implements IDeviceBackend.

Definition at line 188 of file CLDeviceBackend.cpp.

189 {
190  ARM_COMPUTE_LOG_GRAPH_VERBOSE("Configuring CL node with ID : " << node.id() << std::endl);
191  ARM_COMPUTE_ERROR_ON(node.assigned_target() != Target::CL);
192 
193  // Configure node
194  return CLFunctionFactory::create(&node, ctx);
195 }
static std::unique_ptr< arm_compute::IFunction > create(INode *node, GraphContext &ctx)
Create a backend execution function depending on the node type.
#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
#define ARM_COMPUTE_LOG_GRAPH_VERBOSE(x)
Definition: Logger.h:50
OpenCL capable target device.

References ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_LOG_GRAPH_VERBOSE, INode::assigned_target(), arm_compute::graph::CL, CLFunctionFactory::create(), and INode::id().

◆ create_memory_manager()

std::shared_ptr< arm_compute::IMemoryManager > create_memory_manager ( MemoryManagerAffinity  affinity)
overridevirtual

Create a backend memory manager given its affinity.

Parameters
[in]affinityMemory Manager affinity
Returns
Memory manager

Implements IDeviceBackend.

Definition at line 205 of file CLDeviceBackend.cpp.

206 {
207  if(affinity == MemoryManagerAffinity::Offset)
208  {
209  ARM_COMPUTE_LOG_GRAPH_WARNING("CL Backend does not support offset affinity memory management!");
210  return nullptr;
211  }
212 
213  auto lifetime_mgr = std::make_shared<BlobLifetimeManager>();
214  auto pool_mgr = std::make_shared<PoolManager>();
215  auto mm = std::make_shared<MemoryManagerOnDemand>(lifetime_mgr, pool_mgr);
216 
217  return mm;
218 }
#define ARM_COMPUTE_LOG_GRAPH_WARNING(x)
Definition: Logger.h:58

References ARM_COMPUTE_LOG_GRAPH_WARNING, and arm_compute::graph::Offset.

Referenced by CLDeviceBackend::setup_backend_context().

◆ create_subtensor()

std::unique_ptr< ITensorHandle > create_subtensor ( ITensorHandle parent,
TensorShape  shape,
Coordinates  coords,
bool  extend_parent 
)
overridevirtual

Create a backend Sub-Tensor.

Parameters
[in]parentParent sub-tensor handle
[in]shapeShape of the sub-tensor
[in]coordsStarting coordinates of the sub-tensor
[in]extend_parentExtends parent shape if true
Returns
Backend sub-tensor handle

Implements IDeviceBackend.

Definition at line 178 of file CLDeviceBackend.cpp.

179 {
180  if(parent == nullptr)
181  {
182  return nullptr;
183  }
184 
185  return std::make_unique<CLSubTensorHandle>(parent, shape, coords, extend_parent);
186 }

References arm_compute::test::validation::shape.

◆ create_tensor()

std::unique_ptr< ITensorHandle > create_tensor ( const Tensor tensor)
overridevirtual

Create a backend Tensor.

Parameters
[in]tensorThe tensor we want to create a backend tensor for
Returns
Backend tensor handle

Implements IDeviceBackend.

Definition at line 165 of file CLDeviceBackend.cpp.

166 {
167  // Get tensor descriptor
168  const TensorDescriptor &tensor_desc = tensor.desc();
169  ARM_COMPUTE_ERROR_ON(tensor_desc.target != Target::CL);
170 
171  // Create backend tensor handle
172  TensorInfo info(tensor_desc.shape, 1, tensor_desc.data_type, tensor_desc.quant_info);
173  info.set_data_layout(tensor_desc.layout);
174 
175  return std::make_unique<CLTensorHandle>(info);
176 }
#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
ScaleKernelInfo info(interpolation_policy, default_border_mode, PixelValue(), sampling_policy, false)
OpenCL capable target device.

References ARM_COMPUTE_ERROR_ON, arm_compute::graph::CL, TensorDescriptor::data_type, Tensor::desc(), arm_compute::test::validation::info, TensorDescriptor::layout, TensorDescriptor::quant_info, TensorDescriptor::shape, and TensorDescriptor::target.

◆ create_weights_manager()

std::shared_ptr< arm_compute::IWeightsManager > create_weights_manager ( )
overridevirtual

Create a backend weights manager.

Returns
Weights manager

Implements IDeviceBackend.

Definition at line 220 of file CLDeviceBackend.cpp.

221 {
222  auto weights_mgr = std::make_shared<IWeightsManager>();
223  return weights_mgr;
224 }

Referenced by CLDeviceBackend::setup_backend_context().

◆ initialize_backend()

void initialize_backend ( )
overridevirtual

Initializes the backend.

Implements IDeviceBackend.

Definition at line 87 of file CLDeviceBackend.cpp.

88 {
89  // Setup Scheduler
90  CLScheduler::get().default_init(&_tuner, &_gemm_heuristics, _backend_type);
91  // Create allocator with new context
92  _allocator = std::make_unique<CLBufferAllocator>(nullptr /* legacy path for CLCoreRuntimeContext */);
93 }
static CLScheduler & get()
Access the scheduler singleton.
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 ...

References CLScheduler::default_init(), and CLScheduler::get().

Referenced by CLDeviceBackend::setup_backend_context().

◆ is_backend_supported()

bool is_backend_supported ( )
overridevirtual

Checks if an instantiated backend is actually supported.

Returns
True if the backend is supported else false

Implements IDeviceBackend.

Definition at line 155 of file CLDeviceBackend.cpp.

156 {
158 }
bool opencl_is_available()
Check if OpenCL is available.
Definition: OpenCL.cpp:154

References arm_compute::opencl_is_available().

◆ release_backend_context()

void release_backend_context ( GraphContext ctx)
overridevirtual

Release the backend specific resources associated to a given graph context.

Parameters
[in,out]ctxGraph context

Implements IDeviceBackend.

Definition at line 95 of file CLDeviceBackend.cpp.

96 {
97  ARM_COMPUTE_UNUSED(ctx);
98  _context_count--;
99  if(_context_count == 0) // No more context using the backend: free resources
100  {
101  _allocator = nullptr;
102  }
103 }
#define ARM_COMPUTE_UNUSED(...)
To avoid unused variables warnings.
Definition: Error.h:152

References ARM_COMPUTE_UNUSED.

◆ set_kernel_tuning()

void set_kernel_tuning ( bool  enable_tuning)

Switchs on or off the kernel tuning.

Note
When true the tuner set is used, if no tuner is set a new default one is created
Parameters
[in]enable_tuningEnables tuning if false else true

Definition at line 77 of file CLDeviceBackend.cpp.

78 {
79  _tuner.set_tune_new_kernels(enable_tuning);
80 }
void set_tune_new_kernels(bool tune_new_kernels)
Setter for tune_new_kernels option.
Definition: CLTuner.cpp:52

References CLTuner::set_tune_new_kernels().

Referenced by CLDeviceBackend::setup_backend_context().

◆ set_kernel_tuning_mode()

void set_kernel_tuning_mode ( CLTunerMode  tuning_mode)

Set kernel tuning mode.

Parameters
[in]tuning_modeIndicates how exhaustive the search for the optimal LWS should be while tuning

Definition at line 82 of file CLDeviceBackend.cpp.

83 {
84  _tuner.set_tuner_mode(tuning_mode);
85 }
void set_tuner_mode(CLTunerMode mode)
Set OpenCL tuner mode.
Definition: CLTuner.cpp:61

References CLTuner::set_tuner_mode().

Referenced by CLDeviceBackend::setup_backend_context().

◆ setup_backend_context()

void setup_backend_context ( GraphContext ctx)
overridevirtual

Setups the given graph context.

Parameters
[in,out]ctxGraph context

Implements IDeviceBackend.

Definition at line 105 of file CLDeviceBackend.cpp.

106 {
107  // Force backend initialization
108  _context_count++;
109  if(_context_count == 1)
110  {
111  _backend_type = ctx.config().backend_type;
113  }
114 
115  // Setup tuner
116  _tuner_file = ctx.config().tuner_file;
117 
118  // Load tuner data if available
119  if(file_exists(_tuner_file))
120  {
121  _tuner.load_from_file(_tuner_file);
122  }
123 
124  set_kernel_tuning(ctx.config().use_tuner);
125  set_kernel_tuning_mode(ctx.config().tuner_mode);
126 
127  // Attempt to load mlgo heuristics
128  ARM_COMPUTE_ERROR_ON(CLScheduler::get().gemm_heuristics() == nullptr);
129  CLScheduler::get().gemm_heuristics()->reload_from_file(ctx.config().mlgo_file);
130 
131  // Setup a management backend
132  if(ctx.memory_management_ctx(Target::CL) == nullptr)
133  {
134  MemoryManagerContext mm_ctx;
135  mm_ctx.target = Target::CL;
138  mm_ctx.cross_group = std::make_shared<MemoryGroup>(mm_ctx.cross_mm);
139  mm_ctx.allocator = _allocator.get();
140 
141  ctx.insert_memory_management_ctx(std::move(mm_ctx));
142  }
143 
144  // Create function level weights manager
145  if(ctx.weights_management_ctx(Target::CL) == nullptr)
146  {
147  WeightsManagerContext wm_ctx;
148  wm_ctx.target = Target::CL;
149  wm_ctx.wm = create_weights_manager();
150 
151  ctx.insert_weights_management_ctx(std::move(wm_ctx));
152  }
153 }
void set_kernel_tuning(bool enable_tuning)
Switchs on or off the kernel tuning.
static CLScheduler & get()
Access the scheduler singleton.
void set_kernel_tuning_mode(CLTunerMode tuning_mode)
Set kernel tuning mode.
void load_from_file(const std::string &filename)
Load the tuning parameters table from file.
Definition: CLTuner.cpp:280
#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
void initialize_backend() override
Initializes the backend.
CLGEMMHeuristicsHandle * gemm_heuristics() const
Accessor for the associated CLGEMMHeuristicsHandle.
Definition: CLScheduler.cpp:50
std::shared_ptr< arm_compute::IWeightsManager > create_weights_manager() override
Create a backend weights manager.
bool reload_from_file(const std::string &filename)
(Re)Load the heuristics from reading a dotmlgo file
std::shared_ptr< arm_compute::IMemoryManager > create_memory_manager(MemoryManagerAffinity affinity) override
Create a backend memory manager given its affinity.
OpenCL capable target device.

References MemoryManagerContext::allocator, ARM_COMPUTE_ERROR_ON, GraphConfig::backend_type, arm_compute::graph::Buffer, arm_compute::graph::CL, GraphContext::config(), CLDeviceBackend::create_memory_manager(), CLDeviceBackend::create_weights_manager(), MemoryManagerContext::cross_group, MemoryManagerContext::cross_mm, CLScheduler::gemm_heuristics(), CLScheduler::get(), CLDeviceBackend::initialize_backend(), GraphContext::insert_memory_management_ctx(), GraphContext::insert_weights_management_ctx(), MemoryManagerContext::intra_mm, CLTuner::load_from_file(), GraphContext::memory_management_ctx(), GraphConfig::mlgo_file, CLGEMMHeuristicsHandle::reload_from_file(), CLDeviceBackend::set_kernel_tuning(), CLDeviceBackend::set_kernel_tuning_mode(), MemoryManagerContext::target, WeightsManagerContext::target, GraphConfig::tuner_file, GraphConfig::tuner_mode, GraphConfig::use_tuner, GraphContext::weights_management_ctx(), and WeightsManagerContext::wm.

◆ validate_node()

arm_compute::Status validate_node ( INode node)
overridevirtual

Validate a node.

Parameters
[in]nodeThe node we want to validate
Returns
An error status

Implements IDeviceBackend.

Definition at line 197 of file CLDeviceBackend.cpp.

198 {
199  ARM_COMPUTE_LOG_GRAPH_VERBOSE("Validating CL node with ID : " << node.id() << std::endl);
200  ARM_COMPUTE_ERROR_ON(node.assigned_target() != Target::CL);
201 
202  return CLNodeValidator::validate(&node);
203 }
#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
static Status validate(INode *node)
Validate a node.
#define ARM_COMPUTE_LOG_GRAPH_VERBOSE(x)
Definition: Logger.h:50
OpenCL capable target device.

References ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_LOG_GRAPH_VERBOSE, INode::assigned_target(), arm_compute::graph::CL, INode::id(), and CLNodeValidator::validate().


The documentation for this class was generated from the following files: