Compute Library
 22.08
CLMemoryRegion.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018-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 
26 #include "arm_compute/core/Error.h"
28 
29 namespace arm_compute
30 {
32  : IMemoryRegion(size),
33  _queue(CLScheduler::get().queue()),
34  _ctx(CLScheduler::get().context()),
35  _mapping(nullptr),
36  _mem()
37 {
38 }
39 
40 const cl::Buffer &ICLMemoryRegion::cl_data() const
41 {
42  return _mem;
43 }
44 
46 {
47  return _mapping;
48 }
49 
50 const void *ICLMemoryRegion::buffer() const
51 {
52  return _mapping;
53 }
54 
55 std::unique_ptr<IMemoryRegion> ICLMemoryRegion::extract_subregion(size_t offset, size_t size)
56 {
57  ARM_COMPUTE_UNUSED(offset, size);
58  return nullptr;
59 }
60 
62  : ICLMemoryRegion(size)
63 {
64  if(_size != 0)
65  {
66  _mem = cl::Buffer(CLScheduler::get().context(), flags, _size);
67  }
68 }
69 
71  : ICLMemoryRegion(buffer.getInfo<CL_MEM_SIZE>())
72 {
73  _mem = buffer;
74 }
75 
77 {
78  return nullptr;
79 }
80 
81 void *CLBufferMemoryRegion::map(cl::CommandQueue &q, bool blocking)
82 {
83  ARM_COMPUTE_ERROR_ON(_mem.get() == nullptr);
84  _mapping = q.enqueueMapBuffer(_mem, blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ | CL_MAP_WRITE, 0, _size);
85  return _mapping;
86 }
87 
88 void CLBufferMemoryRegion::unmap(cl::CommandQueue &q)
89 {
90  ARM_COMPUTE_ERROR_ON(_mem.get() == nullptr);
91  q.enqueueUnmapMemObject(_mem, _mapping);
92  _mapping = nullptr;
93 }
94 
95 ICLSVMMemoryRegion::ICLSVMMemoryRegion(cl_mem_flags flags, size_t size, size_t alignment)
96  : ICLMemoryRegion(size), _ptr(nullptr)
97 {
98  if(size != 0)
99  {
100  _ptr = clSVMAlloc(CLScheduler::get().context().get(), flags, size, alignment);
101  if(_ptr != nullptr)
102  {
103  _mem = cl::Buffer(CLScheduler::get().context(), CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, _size, _ptr);
104  }
105  }
106 }
107 
108 ICLSVMMemoryRegion::~ICLSVMMemoryRegion()
109 {
110  if(_ptr != nullptr)
111  {
112  try
113  {
114  clFinish(_queue.get());
115  _mem = cl::Buffer();
116  clSVMFree(_ctx.get(), _ptr);
117  }
118  catch(...)
119  {
120  }
121  }
122 }
123 
124 void *ICLSVMMemoryRegion::ptr()
125 {
126  return _ptr;
127 }
128 
129 CLCoarseSVMMemoryRegion::CLCoarseSVMMemoryRegion(cl_mem_flags flags, size_t size, size_t alignment)
130  : ICLSVMMemoryRegion(flags, size, alignment)
131 {
132 }
133 
134 void *CLCoarseSVMMemoryRegion::map(cl::CommandQueue &q, bool blocking)
135 {
136  ARM_COMPUTE_ERROR_ON(_ptr == nullptr);
137  clEnqueueSVMMap(q.get(), blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ | CL_MAP_WRITE, _ptr, _size, 0, nullptr, nullptr);
138  _mapping = _ptr;
139  return _mapping;
140 }
141 
142 void CLCoarseSVMMemoryRegion::unmap(cl::CommandQueue &q)
143 {
144  ARM_COMPUTE_ERROR_ON(_ptr == nullptr);
145  clEnqueueSVMUnmap(q.get(), _ptr, 0, nullptr, nullptr);
146  _mapping = nullptr;
147 }
148 
149 CLFineSVMMemoryRegion::CLFineSVMMemoryRegion(cl_mem_flags flags, size_t size, size_t alignment)
150  : ICLSVMMemoryRegion(flags, size, alignment)
151 {
152 }
153 
154 void *CLFineSVMMemoryRegion::map(cl::CommandQueue &q, bool blocking)
155 {
156  if(blocking)
157  {
158  clFinish(q.get());
159  }
160  _mapping = _ptr;
161  return _mapping;
162 }
163 
164 void CLFineSVMMemoryRegion::unmap(cl::CommandQueue &q)
165 {
167  _mapping = nullptr;
168 }
169 } // namespace arm_compute
__global uchar * offset(const Image *img, int x, int y)
Get the pointer position of a Image.
Definition: helpers.h:1084
void * map(cl::CommandQueue &q, bool blocking) final
Enqueue a map operation of the allocated buffer on the given queue.
static CLScheduler & get()
Access the scheduler singleton.
OpenCL SVM memory region interface.
void unmap(cl::CommandQueue &q) final
Enqueue an unmap operation of the allocated buffer on the given queue.
#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
Memory region interface.
Definition: IMemoryRegion.h:33
OpenCL memory region interface.
Copyright (c) 2017-2022 Arm Limited.
const cl::Buffer & cl_data() const
Returns the underlying CL buffer.
void clSVMFree(cl_context context, void *svm_pointer)
Definition: OpenCL.cpp:286
Interface to enqueue OpenCL kernels and get/set the OpenCL CommandQueue and ICLTuner.
void unmap(cl::CommandQueue &q) final
Enqueue an unmap operation of the allocated buffer on the given queue.
#define ARM_COMPUTE_UNUSED(...)
To avoid unused variables warnings.
Definition: Error.h:152
ICLMemoryRegion(size_t size)
Constructor.
cl_int clEnqueueSVMUnmap(cl_command_queue command_queue, void *svm_ptr, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event)
Definition: OpenCL.cpp:257
void * buffer() override
Returns the pointer to the allocated data.
CLBufferMemoryRegion(cl_mem_flags flags, size_t size)
Constructor.
cl_int clEnqueueSVMMap(cl_command_queue command_queue, cl_bool blocking_map, cl_map_flags flags, void *svm_ptr, size_t size, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event)
Definition: OpenCL.cpp:242
void unmap(cl::CommandQueue &q) final
Enqueue an unmap operation of the allocated buffer on the given queue.
void * map(cl::CommandQueue &q, bool blocking) final
Enqueue a map operation of the allocated buffer on the given queue.
CLCoarseSVMMemoryRegion(cl_mem_flags flags, size_t size, size_t alignment)
Constructor.
void * clSVMAlloc(cl_context context, cl_svm_mem_flags_arm flags, size_t size, cl_uint alignment)
Definition: OpenCL.cpp:272
CLFineSVMMemoryRegion(cl_mem_flags flags, size_t size, size_t alignment)
Constructor.
Provides global access to a CL context and command queue.
Definition: CLScheduler.h:56
std::unique_ptr< IMemoryRegion > extract_subregion(size_t offset, size_t size) override
Extract a sub-region from the memory.
void * ptr() final
Host/SVM pointer accessor.
void * map(cl::CommandQueue &q, bool blocking) final
Enqueue a map operation of the allocated buffer on the given queue.
cl_int clFinish(cl_command_queue command_queue)
Definition: OpenCL.cpp:725
size_t size() const
Memory region size accessor.
Definition: IMemoryRegion.h:73