Compute Library
 21.02
CLScheduler.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016-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 
30 #include "src/core/CL/ICLKernel.h"
31 
32 namespace arm_compute
33 {
34 cl::Context &CLScheduler::context()
35 {
36  ARM_COMPUTE_ERROR_ON(!_is_initialised);
37  _context = CLKernelLibrary::get().context();
38  return _context;
39 }
40 
41 cl::CommandQueue &CLScheduler::queue()
42 {
43  ARM_COMPUTE_ERROR_ON(!_is_initialised);
44  return _queue;
45 }
46 
48 {
49  return _target;
50 }
51 
53 {
54  return _gemm_heuristics;
55 }
56 
57 void CLScheduler::set_queue(cl::CommandQueue queue)
58 {
59  _queue = std::move(queue);
60 }
61 
63 {
64  _target = target;
65 }
66 
68 {
69  _cl_tuner = tuner;
70 }
71 
73 {
74  _queue.finish();
75 }
76 
78 {
79  cl::Event event;
80  _queue.enqueueMarker(&event);
81  return event;
82 }
83 
85 {
86  if(_cl_tuner != nullptr)
87  {
88  _cl_tuner->tune_kernel_static(kernel);
89  }
90 }
91 
93 {
94  return _is_initialised;
95 }
96 
97 std::once_flag CLScheduler::_initialize_symbols;
98 
100  : _context(), _queue(), _target(GPUTarget::MIDGARD), _is_initialised(false), _cl_tuner(nullptr), _cl_default_static_tuner(nullptr), _gemm_heuristics(nullptr)
101 {
102 }
103 
105 {
106  std::call_once(_initialize_symbols, opencl_is_available);
107  static CLScheduler scheduler;
108  return scheduler;
109 }
110 
111 void CLScheduler::default_init_with_context(cl::Device &device, cl::Context &ctx, ICLTuner *cl_tuner, CLGEMMHeuristicsHandle *gemm_h)
112 {
113  if(!_is_initialised)
114  {
115  const std::string cl_kernels_folder("./cl_kernels/");
116  cl::CommandQueue queue = cl::CommandQueue(ctx, device);
117  CLKernelLibrary::get().init(cl_kernels_folder, ctx, device);
118  init(ctx, queue, device, cl_tuner, gemm_h);
119  _cl_default_static_tuner = tuners::TunerFactory::create_tuner(_target);
120  _cl_tuner = (cl_tuner == nullptr) ? _cl_default_static_tuner.get() : cl_tuner;
121  }
122 }
123 
125 {
126  if(!_is_initialised)
127  {
128  cl::Context ctx;
129  cl::Device dev;
130  cl_int err;
131  std::tie(ctx, dev, err) = create_opencl_context_and_device();
132  ARM_COMPUTE_ERROR_ON_MSG(err != CL_SUCCESS, "Failed to create OpenCL context");
133  cl::CommandQueue queue = cl::CommandQueue(ctx, dev);
134  CLKernelLibrary::get().init("./cl_kernels/", ctx, dev);
135  init(ctx, queue, dev, cl_tuner, gemm_h);
136  // Create a default static tuner and set if none was provided
137  _cl_default_static_tuner = tuners::TunerFactory::create_tuner(_target);
138  }
139 
140  // Set CL tuner
141  _cl_tuner = (cl_tuner == nullptr) ? _cl_default_static_tuner.get() : cl_tuner;
142 }
143 
145 {
146  _context = std::move(context);
147  CLKernelLibrary::get().set_context(_context);
148 }
149 
150 void CLScheduler::init(cl::Context context, cl::CommandQueue queue, const cl::Device &device, ICLTuner *cl_tuner, CLGEMMHeuristicsHandle *gemm_h)
151 {
152  set_context(std::move(context));
153  _queue = std::move(queue);
154  _target = get_target_from_device(device);
155  _is_initialised = true;
156  _cl_tuner = cl_tuner;
157  _gemm_heuristics = gemm_h;
158 }
159 
160 void CLScheduler::enqueue_common(ICLKernel &kernel, ITensorPack &tensors, bool flush)
161 {
162  ARM_COMPUTE_ERROR_ON_MSG(!_is_initialised,
163  "The CLScheduler is not initialised yet! Please call the CLScheduler::get().default_init(), \
164  or CLScheduler::get()::init() and CLKernelLibrary::get()::init() function before running functions!");
165 
166  const bool inject_memory = !tensors.empty();
167 
168  // Tune the kernel if the CLTuner has been provided
169  if(_cl_tuner != nullptr)
170  {
171  inject_memory ? _cl_tuner->tune_kernel_dynamic(kernel, tensors) : _cl_tuner->tune_kernel_dynamic(kernel);
172  }
173 
174  // Run kernel
175  inject_memory ? kernel.run_op(tensors, kernel.window(), _queue) : kernel.run(kernel.window(), _queue);
176 
177  if(flush)
178  {
179  _queue.flush();
180  }
181 }
182 
183 void CLScheduler::enqueue(ICLKernel &kernel, bool flush)
184 {
185  ITensorPack pack;
186  enqueue_common(kernel, pack, flush);
187 }
188 
189 void CLScheduler::enqueue_op(ICLKernel &kernel, ITensorPack &tensors, bool flush)
190 {
191  enqueue_common(kernel, tensors, flush);
192 }
193 } // namespace arm_compute
void set_target(GPUTarget target)
Accessor to set target GPU to be used by the scheduler.
Definition: CLScheduler.cpp:62
const Window & window() const
The maximum window the kernel can be executed on.
Definition: IKernel.cpp:28
virtual void run(const Window &window, cl::CommandQueue &queue)
Enqueue the OpenCL kernel to process the given window on the passed OpenCL command queue...
Definition: ICLKernel.h:233
static CLScheduler & get()
Access the scheduler singleton.
bool empty() const
Checks if pack is empty.
Definition: ITensorPack.cpp:61
GPUTarget target() const
Get the target GPU.
Definition: CLScheduler.cpp:47
void set_context(cl::Context context)
Accessor to set the CL context to be used by the scheduler.
void default_init_with_context(cl::Device &device, cl::Context &ctx, ICLTuner *cl_tuner=nullptr, CLGEMMHeuristicsHandle *gemm_h=nullptr)
Initialises the scheduler with context and device provided by the user.
#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
virtual void tune_kernel_dynamic(ICLKernel &kernel)=0
Tune OpenCL kernel dynamically.
static CLKernelLibrary & get()
Access the KernelLibrary singleton.
bool is_initialised() const
Definition: CLScheduler.cpp:92
std::tuple< cl::Context, cl::Device, cl_int > create_opencl_context_and_device()
This function creates an OpenCL context and a device.
Definition: CLHelpers.cpp:89
void set_context(cl::Context context)
Sets the CL context used to create programs.
Common interface for all the OpenCL kernels.
Definition: ICLKernel.h:46
CLGEMMHeuristicsHandle * gemm_heuristics() const
Accessor for the associated CLGEMMHeuristicsHandle.
Definition: CLScheduler.cpp:52
Copyright (c) 2017-2021 Arm Limited.
Interface to enqueue OpenCL kernels and get/set the OpenCL CommandQueue and ICLTuner.
cl::Context & context()
Accessor for the associated CL context.
Definition: CLScheduler.cpp:34
cl::Event enqueue_sync_event()
Enqueues a marker into the associated command queue and return the event.
Definition: CLScheduler.cpp:77
#define ARM_COMPUTE_ERROR_ON_MSG(cond, msg)
Definition: Error.h:456
void enqueue_op(ICLKernel &kernel, ITensorPack &tensors, bool flush=true)
Schedule the execution of the passed kernel if possible.
void init(cl::Context context, cl::CommandQueue queue, const cl::Device &device, ICLTuner *cl_tuner=nullptr, CLGEMMHeuristicsHandle *gemm_h=nullptr)
Initialises the context and command queue to be used by the scheduler.
GPUTarget get_target_from_device(const cl::Device &device)
Helper function to get the GPU target from CL device.
Definition: CLHelpers.cpp:221
void init(std::string kernel_path, cl::Context context, cl::Device device)
Initialises the kernel library.
void set_tuner(ICLTuner *tuner)
Accessor to set the CL tuner to be used by the scheduler.
Definition: CLScheduler.cpp:67
cl::CommandQueue & queue()
Accessor for the associated CL command queue.
Definition: CLScheduler.cpp:41
void enqueue(ICLKernel &kernel, bool flush=true)
Schedule the execution of the passed kernel if possible.
void set_queue(cl::CommandQueue queue)
Accessor to set the CL command queue to be used by the scheduler.
Definition: CLScheduler.cpp:57
CLScheduler()
Constructor.
Definition: CLScheduler.cpp:99
void sync()
Blocks until all commands in the associated command queue have finished.
Definition: CLScheduler.cpp:72
Handle for loading and retrieving GEMM heuristics.
GPUTarget
Available GPU Targets.
Definition: GPUTarget.h:34
Manages all the OpenCL kernels compilation and caching, provides accessors for the OpenCL Context...
virtual void tune_kernel_static(ICLKernel &kernel)=0
Tune OpenCL kernel statically.
Provides global access to a CL context and command queue.
Definition: CLScheduler.h:41
Tensor packing service.
Definition: ITensorPack.h:37
Basic interface for tuning the OpenCL kernels.
Definition: ICLTuner.h:34
void default_init(ICLTuner *cl_tuner=nullptr, CLGEMMHeuristicsHandle *gemm_h=nullptr)
Initialises the context and command queue used by the scheduler to default values and sets a default ...
static std::unique_ptr< ICLTuner > create_tuner(GPUTarget target)
Definition: Tuners.h:40
void tune_kernel_static(ICLKernel &kernel)
Tunes OpenCL kernel.
Definition: CLScheduler.cpp:84
virtual void run_op(ITensorPack &tensors, const Window &window, cl::CommandQueue &queue)
Enqueue the OpenCL kernel to process the given window on the passed OpenCL command queue...
Definition: ICLKernel.h:245
bool opencl_is_available()
Check if OpenCL is available.
Definition: OpenCL.cpp:152
cl::Context & context()
Accessor for the associated CL context.