Compute Library
 21.02
CLHelpers.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2019-2020 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  */
24 
26 
28 #include "arm_compute/core/Error.h"
31 
32 namespace
33 {
34 #if defined(ARM_COMPUTE_ASSERTS_ENABLED)
35 void printf_callback(const char *buffer, unsigned int len, size_t complete, void *user_data)
36 {
37  ARM_COMPUTE_UNUSED(complete, user_data);
38  printf("%.*s", len, buffer);
39 }
40 #endif /* defined(ARM_COMPUTE_ASSERTS_ENABLED) */
41 
42 /** This initialises the properties vector with the configuration to be used when creating the opencl context
43  *
44  * @param[in] platform The opencl platform used to create the context
45  * @param[in] device The opencl device to be used to create the context
46  * @param[in] prop An array of properties to be initialised
47  *
48  * @note In debug builds, this function will enable cl_arm_printf if it's supported.
49  *
50  * @return A pointer to the context properties which can be used to create an opencl context
51  */
52 
53 void initialise_context_properties(const cl::Platform &platform, const cl::Device &device, std::array<cl_context_properties, 7> &prop)
54 {
55  ARM_COMPUTE_UNUSED(device);
56 #if defined(ARM_COMPUTE_ASSERTS_ENABLED)
57  // Query devices in the context for cl_arm_printf support
58  if(arm_compute::device_supports_extension(device, "cl_arm_printf"))
59  {
60  // Create a cl_context with a printf_callback and user specified buffer size.
61  std::array<cl_context_properties, 7> properties_printf =
62  {
63  CL_CONTEXT_PLATFORM, reinterpret_cast<cl_context_properties>(platform()),
64  // Enable a printf callback function for this context.
65  CL_PRINTF_CALLBACK_ARM, reinterpret_cast<cl_context_properties>(printf_callback),
66  // Request a minimum printf buffer size of 4MB for devices in the
67  // context that support this extension.
68  CL_PRINTF_BUFFERSIZE_ARM, 0x1000,
69  0
70  };
71  prop = properties_printf;
72  }
73  else
74 #endif // defined(ARM_COMPUTE_ASSERTS_ENABLED)
75  {
76  std::array<cl_context_properties, 3> properties =
77  {
78  CL_CONTEXT_PLATFORM, reinterpret_cast<cl_context_properties>(platform()),
79  0
80  };
81  std::copy(properties.begin(), properties.end(), prop.begin());
82  };
83 }
84 } //namespace
85 
86 namespace arm_compute
87 {
88 std::tuple<cl::Context, cl::Device, cl_int>
90 {
92  std::vector<cl::Platform> platforms;
93  cl::Platform::get(&platforms);
94  ARM_COMPUTE_ERROR_ON_MSG(platforms.size() == 0, "Couldn't find any OpenCL platform");
95  cl::Platform p = platforms[0];
96  cl::Device device;
97  std::vector<cl::Device> platform_devices;
98  p.getDevices(CL_DEVICE_TYPE_DEFAULT, &platform_devices);
99  ARM_COMPUTE_ERROR_ON_MSG(platform_devices.size() == 0, "Couldn't find any OpenCL device");
100  device = platform_devices[0];
101  cl_int err = CL_SUCCESS;
102  std::array<cl_context_properties, 7> properties = { 0, 0, 0, 0, 0, 0, 0 };
103  initialise_context_properties(p, device, properties);
104  cl::Context cl_context = cl::Context(device, properties.data(), nullptr, nullptr, &err);
105  ARM_COMPUTE_ERROR_ON_MSG(err != CL_SUCCESS, "Failed to create OpenCL context");
106  return std::make_tuple(cl_context, device, err);
107 }
108 
109 void schedule_kernel_on_ctx(CLRuntimeContext *ctx, ICLKernel *kernel, bool flush)
110 {
112  if(ctx)
113  {
114  ARM_COMPUTE_ERROR_ON(ctx->gpu_scheduler() == nullptr);
115  ctx->gpu_scheduler()->enqueue(*kernel, flush);
116  }
117  else
118  {
119  CLScheduler::get().enqueue(*kernel, flush);
120  }
121 }
122 
123 } // namespace arm_compute
static CLScheduler & get()
Access the scheduler singleton.
void schedule_kernel_on_ctx(CLRuntimeContext *ctx, ICLKernel *kernel, bool flush=true)
Schedules a kernel using the context if not nullptr else uses the legacy scheduling flow...
Definition: CLHelpers.cpp:109
#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
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
SimpleTensor< T > copy(const SimpleTensor< T > &src, const TensorShape &output_shape)
Definition: Copy.cpp:37
Common interface for all the OpenCL kernels.
Definition: ICLKernel.h:46
Copyright (c) 2017-2021 Arm Limited.
#define ARM_COMPUTE_UNUSED(...)
To avoid unused variables warnings.
Definition: Error.h:152
#define ARM_COMPUTE_ERROR_ON_MSG(cond, msg)
Definition: Error.h:456
void enqueue(ICLKernel &kernel, bool flush=true)
Schedule the execution of the passed kernel if possible.
bool device_supports_extension(const cl::Device &device, const char *extension_name)
Helper function to check whether a given extension is supported.
Definition: CLHelpers.cpp:277
#define ARM_COMPUTE_ERROR_ON_NULLPTR(...)
Definition: Validate.h:161
bool opencl_is_available()
Check if OpenCL is available.
Definition: OpenCL.cpp:152