Compute Library
 19.08
CLScheduler.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016-2019 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 
27 
31 
32 using namespace arm_compute;
33 
34 std::once_flag CLScheduler::_initialize_symbols;
35 
36 CLScheduler::CLScheduler()
37  : _context(), _queue(), _target(GPUTarget::MIDGARD), _is_initialised(false), _cl_tuner(nullptr), _cl_default_static_tuner(nullptr)
38 {
39 }
40 
42 {
43  std::call_once(_initialize_symbols, opencl_is_available);
44  static CLScheduler scheduler;
45  return scheduler;
46 }
47 
48 void CLScheduler::default_init_with_context(cl::Device &device, cl::Context &ctx, ICLTuner *cl_tuner)
49 {
50  if(!_is_initialised)
51  {
52  cl::CommandQueue queue = cl::CommandQueue(ctx, device);
53  CLKernelLibrary::get().init("./cl_kernels/", ctx, device);
54  init(ctx, queue, device, cl_tuner);
55  _cl_default_static_tuner = tuners::TunerFactory::create_tuner(_target);
56  _cl_tuner = (cl_tuner == nullptr) ? _cl_default_static_tuner.get() : cl_tuner;
57  }
58 }
59 
61 {
62  if(!_is_initialised)
63  {
64  cl::Context ctx;
65  cl::Device dev;
66  cl_int err;
67  std::tie(ctx, dev, err) = create_opencl_context_and_device();
68  ARM_COMPUTE_ERROR_ON_MSG(err != CL_SUCCESS, "Failed to create OpenCL context");
69  cl::CommandQueue queue = cl::CommandQueue(ctx, dev);
70  CLKernelLibrary::get().init("./cl_kernels/", ctx, dev);
71  init(ctx, queue, dev, cl_tuner);
72  // Create a default static tuner and set if none was provided
73  _cl_default_static_tuner = tuners::TunerFactory::create_tuner(_target);
74  }
75 
76  // Set CL tuner
77  _cl_tuner = (cl_tuner == nullptr) ? _cl_default_static_tuner.get() : cl_tuner;
78 }
79 
80 void CLScheduler::set_context(cl::Context context)
81 {
82  _context = std::move(context);
84 }
85 
86 void CLScheduler::init(cl::Context context, cl::CommandQueue queue, const cl::Device &device, ICLTuner *cl_tuner)
87 {
88  set_context(std::move(context));
89  _queue = std::move(queue);
90  _target = get_target_from_device(device);
91  _is_initialised = true;
92  _cl_tuner = cl_tuner;
93 }
94 
95 void CLScheduler::enqueue(ICLKernel &kernel, bool flush)
96 {
97  ARM_COMPUTE_ERROR_ON_MSG(!_is_initialised,
98  "The CLScheduler is not initialised yet! Please call the CLScheduler::get().default_init(), \
99  or CLScheduler::get()::init() and CLKernelLibrary::get()::init() function before running functions!");
100 
101  // Tune the kernel if the CLTuner has been provided
102  if(_cl_tuner != nullptr)
103  {
104  // Tune the OpenCL kernel
105  _cl_tuner->tune_kernel_dynamic(kernel);
106  }
107 
108  // Run kernel
109  kernel.run(kernel.window(), _queue);
110 
111  if(flush)
112  {
113  _queue.flush();
114  }
115 }
const Window & window() const
The maximum window the kernel can be executed on.
Definition: IKernel.cpp:28
static CLScheduler & get()
Access the scheduler singleton.
Definition: CLScheduler.cpp:41
void set_context(cl::Context context)
Accessor to set the CL context to be used by the scheduler.
Definition: CLScheduler.cpp:80
virtual void tune_kernel_dynamic(ICLKernel &kernel)=0
Tune OpenCL kernel dynamically.
static CLKernelLibrary & get()
Access the KernelLibrary singleton.
void init(cl::Context context, cl::CommandQueue queue, const cl::Device &device, ICLTuner *cl_tuner=nullptr)
Initialises the context and command queue to be used by the scheduler.
Definition: CLScheduler.cpp:86
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:86
void set_context(cl::Context context)
Sets the CL context used to create programs.
Common interface for all the OpenCL kernels.
Definition: ICLKernel.h:43
Copyright (c) 2017-2018 ARM Limited.
GPUTarget get_target_from_device(const cl::Device &device)
Helper function to get the GPU target from CL device.
Definition: CLHelpers.cpp:131
void init(std::string kernel_path, cl::Context context, cl::Device device)
Initialises the kernel library.
void enqueue(ICLKernel &kernel, bool flush=true)
Schedule the execution of the passed kernel if possible.
Definition: CLScheduler.cpp:95
cl::CommandQueue & queue()
Accessor for the associated CL command queue.
Definition: CLScheduler.h:102
virtual void run(const Window &window, cl::CommandQueue &queue)=0
Enqueue the OpenCL kernel to process the given window on the passed OpenCL command queue.
void default_init_with_context(cl::Device &device, cl::Context &ctx, ICLTuner *cl_tuner=nullptr)
Initialises the scheduler with context and device provided by the user.
Definition: CLScheduler.cpp:48
GPUTarget
Available GPU Targets.
Definition: GPUTarget.h:34
Provides global access to a CL context and command queue.
Definition: CLScheduler.h:40
Basic interface for tuning the OpenCL kernels.
Definition: ICLTuner.h:32
static std::unique_ptr< ICLTuner > create_tuner(GPUTarget target)
Definition: Tuners.h:40
void default_init(ICLTuner *cl_tuner=nullptr)
Initialises the context and command queue used by the scheduler to default values and sets a default ...
Definition: CLScheduler.cpp:60
bool opencl_is_available()
Check if OpenCL is available.
Definition: OpenCL.cpp:136
cl::Context & context()
Accessor for the associated CL context.
Definition: CLScheduler.h:91
#define ARM_COMPUTE_ERROR_ON_MSG(cond,...)
Definition: Error.h:328