1 //
2 // Copyright © 2017, 2023 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5
6 #include "ClContextControl.hpp"
7
8 #include <armnn/Exceptions.hpp>
9
10 #include <LeakChecking.hpp>
11
12 #include <armnn/utility/Assert.hpp>
13 #include <armnn/utility/IgnoreUnused.hpp>
14
15 #include <arm_compute/core/CL/CLKernelLibrary.h>
16 #include <arm_compute/runtime/CL/CLScheduler.h>
17
18 #include <fmt/format.h>
19
20 namespace cl
21 {
22 class Context;
23 class CommandQueue;
24 class Device;
25 }
26
27 namespace armnn
28 {
29
ClContextControl(arm_compute::CLTuner * tuner,arm_compute::CLGEMMHeuristicsHandle * heuristicsHandle,bool profilingEnabled)30 ClContextControl::ClContextControl(arm_compute::CLTuner *tuner,
31 arm_compute::CLGEMMHeuristicsHandle* heuristicsHandle,
32 bool profilingEnabled)
33 : m_Tuner(tuner)
34 , m_HeuristicsHandle(heuristicsHandle)
35 , m_ProfilingEnabled(profilingEnabled)
36 {
37 // Ignore m_ProfilingEnabled if unused to avoid compiling problems when ArmCompute is disabled.
38 IgnoreUnused(m_ProfilingEnabled);
39
40 try
41 {
42 std::vector<cl::Platform> platforms;
43 cl::Platform::get(&platforms);
44
45 // Selects default platform for the first element.
46 cl::Platform::setDefault(platforms[0]);
47
48 std::vector<cl::Device> devices;
49 platforms[0].getDevices(CL_DEVICE_TYPE_GPU, &devices);
50
51 // Selects default device for the first element.
52 cl::Device::setDefault(devices[0]);
53 }
54 catch (const cl::Error& clError)
55 {
56 throw ClRuntimeUnavailableException(fmt::format(
57 "Could not initialize the CL runtime. Error description: {0}. CL error code: {1}",
58 clError.what(), clError.err()));
59 }
60
61 // Removes the use of global CL context.
62 cl::Context::setDefault(cl::Context{});
63 ARMNN_ASSERT(cl::Context::getDefault()() == NULL);
64
65 // Removes the use of global CL command queue.
66 cl::CommandQueue::setDefault(cl::CommandQueue{});
67 ARMNN_ASSERT(cl::CommandQueue::getDefault()() == NULL);
68
69 // Always load the OpenCL runtime.
70 LoadOpenClRuntime();
71 }
72
~ClContextControl()73 ClContextControl::~ClContextControl()
74 {
75 // Load the OpencCL runtime without the tuned parameters to free the memory for them.
76 try
77 {
78 UnloadOpenClRuntime();
79 }
80 catch (const cl::Error& clError)
81 {
82 // This should not happen, it is ignored if it does.
83
84 // Coverity fix: BOOST_LOG_TRIVIAL (previously used here to report the error) may throw an
85 // exception of type std::length_error.
86 // Using stderr instead in this context as there is no point in nesting try-catch blocks here.
87 std::cerr << "A CL error occurred unloading the runtime tuner parameters: "
88 << clError.what() << ". CL error code is: " << clError.err() << std::endl;
89 }
90 }
91
LoadOpenClRuntime()92 void ClContextControl::LoadOpenClRuntime()
93 {
94 DoLoadOpenClRuntime(true);
95 }
96
UnloadOpenClRuntime()97 void ClContextControl::UnloadOpenClRuntime()
98 {
99 DoLoadOpenClRuntime(false);
100 }
101
DoLoadOpenClRuntime(bool updateTunedParameters)102 void ClContextControl::DoLoadOpenClRuntime(bool updateTunedParameters)
103 {
104 cl::Device device = cl::Device::getDefault();
105 cl::Context context;
106 cl::CommandQueue commandQueue;
107
108 if (arm_compute::CLScheduler::get().is_initialised() && arm_compute::CLScheduler::get().context()() != NULL)
109 {
110 // Wait for all queued CL requests to finish before reinitialising it.
111 arm_compute::CLScheduler::get().sync();
112 }
113
114 try
115 {
116 arm_compute::CLKernelLibrary::get().clear_programs_cache();
117 // Initialise the scheduler with a dummy context to release the LLVM data (which only happens when there are no
118 // context references); it is initialised again, with a proper context, later.
119 arm_compute::CLScheduler::get().init(context, commandQueue, device);
120 arm_compute::CLKernelLibrary::get().init(".", context, device);
121
122 {
123 //
124 // Here we replace the context with a new one in which
125 // the memory leak checks show it as an extra allocation but
126 // because of the scope of the leak checks, it doesn't count
127 // the disposal of the original object. On the other hand it
128 // does count the creation of this context which it flags
129 // as a memory leak. By adding the following line we prevent
130 // this to happen.
131 //
132 ARMNN_DISABLE_LEAK_CHECKING_IN_SCOPE();
133 context = cl::Context(device);
134 }
135
136 // NOTE: In this specific case profiling has to be enabled on the command queue
137 // in order for the CLTuner to work.
138 bool profilingNeededForClTuner = updateTunedParameters && m_Tuner &&
139 m_Tuner->tune_new_kernels();
140
141 if (m_ProfilingEnabled || profilingNeededForClTuner)
142 {
143 // Create a new queue with profiling enabled.
144 commandQueue = cl::CommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE);
145 }
146 else
147 {
148 // Use default queue.
149 commandQueue = cl::CommandQueue(context, device);
150 }
151 }
152 catch (const cl::Error& clError)
153 {
154 throw ClRuntimeUnavailableException(fmt::format(
155 "Could not initialize the CL runtime. Error description: {0}. CL error code: {1}",
156 clError.what(), clError.err()));
157 }
158
159 // Note the first argument (path to cl source code) will be ignored as they should be embedded in the armcompute.
160 arm_compute::CLKernelLibrary::get().init(".", context, device);
161 arm_compute::CLScheduler::get().init(context, commandQueue, device, m_Tuner, m_HeuristicsHandle);
162 }
163
ClearClCache()164 void ClContextControl::ClearClCache()
165 {
166 DoLoadOpenClRuntime(true);
167 }
168
169 } // namespace armnn
170