Compute Library
 21.05
CLMemoryRegion.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018-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  */
25 
27 #include "arm_compute/core/Error.h"
29 
30 namespace arm_compute
31 {
33  : IMemoryRegion(size),
34  _queue((ctx != nullptr) ? ctx->queue() : CLScheduler::get().queue()),
35  _ctx((ctx != nullptr) ? ctx->context() : CLScheduler::get().context()),
36  _mapping(nullptr),
37  _mem()
38 {
39 }
40 
41 const cl::Buffer &ICLMemoryRegion::cl_data() const
42 {
43  return _mem;
44 }
45 
47 {
48  return _mapping;
49 }
50 
51 const void *ICLMemoryRegion::buffer() const
52 {
53  return _mapping;
54 }
55 
56 std::unique_ptr<IMemoryRegion> ICLMemoryRegion::extract_subregion(size_t offset, size_t size)
57 {
59  return nullptr;
60 }
61 
63  : ICLMemoryRegion(ctx, size)
64 {
65  if(_size != 0)
66  {
67  _mem = cl::Buffer((ctx != nullptr) ? ctx->context() : CLScheduler::get().context(), flags, _size);
68  }
69 }
70 
72  : ICLMemoryRegion(ctx, buffer.getInfo<CL_MEM_SIZE>())
73 {
74  _mem = buffer;
75 }
76 
78 {
79  return nullptr;
80 }
81 
82 void *CLBufferMemoryRegion::map(cl::CommandQueue &q, bool blocking)
83 {
84  ARM_COMPUTE_ERROR_ON(_mem.get() == nullptr);
85  _mapping = q.enqueueMapBuffer(_mem, blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ | CL_MAP_WRITE, 0, _size);
86  return _mapping;
87 }
88 
89 void CLBufferMemoryRegion::unmap(cl::CommandQueue &q)
90 {
91  ARM_COMPUTE_ERROR_ON(_mem.get() == nullptr);
92  q.enqueueUnmapMemObject(_mem, _mapping);
93  _mapping = nullptr;
94 }
95 
96 ICLSVMMemoryRegion::ICLSVMMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, size_t size, size_t alignment)
97  : ICLMemoryRegion(ctx, size), _ptr(nullptr)
98 {
99  if(size != 0)
100  {
101  _ptr = clSVMAlloc((ctx != nullptr) ? ctx->context().get() : CLScheduler::get().context().get(), flags, size, alignment);
102  if(_ptr != nullptr)
103  {
104  _mem = cl::Buffer((ctx != nullptr) ? ctx->context() : CLScheduler::get().context(), CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, _size, _ptr);
105  }
106  }
107 }
108 
109 ICLSVMMemoryRegion::~ICLSVMMemoryRegion()
110 {
111  if(_ptr != nullptr)
112  {
113  try
114  {
115  clFinish(_queue.get());
116  _mem = cl::Buffer();
117  clSVMFree(_ctx.get(), _ptr);
118  }
119  catch(...)
120  {
121  }
122  }
123 }
124 
125 void *ICLSVMMemoryRegion::ptr()
126 {
127  return _ptr;
128 }
129 
130 CLCoarseSVMMemoryRegion::CLCoarseSVMMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, size_t size, size_t alignment)
131  : ICLSVMMemoryRegion(ctx, flags, size, alignment)
132 {
133 }
134 
135 void *CLCoarseSVMMemoryRegion::map(cl::CommandQueue &q, bool blocking)
136 {
137  ARM_COMPUTE_ERROR_ON(_ptr == nullptr);
138  clEnqueueSVMMap(q.get(), blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ | CL_MAP_WRITE, _ptr, _size, 0, nullptr, nullptr);
139  _mapping = _ptr;
140  return _mapping;
141 }
142 
143 void CLCoarseSVMMemoryRegion::unmap(cl::CommandQueue &q)
144 {
145  ARM_COMPUTE_ERROR_ON(_ptr == nullptr);
146  clEnqueueSVMUnmap(q.get(), _ptr, 0, nullptr, nullptr);
147  _mapping = nullptr;
148 }
149 
150 CLFineSVMMemoryRegion::CLFineSVMMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, size_t size, size_t alignment)
151  : ICLSVMMemoryRegion(ctx, flags, size, alignment)
152 {
153 }
154 
155 void *CLFineSVMMemoryRegion::map(cl::CommandQueue &q, bool blocking)
156 {
157  if(blocking)
158  {
159  clFinish(q.get());
160  }
161  _mapping = _ptr;
162  return _mapping;
163 }
164 
165 void CLFineSVMMemoryRegion::unmap(cl::CommandQueue &q)
166 {
168  _mapping = nullptr;
169 }
170 } // namespace arm_compute
__global uchar * offset(const Image *img, int x, int y)
Get the pointer position of a Image.
Definition: helpers.h:861
CLCoarseSVMMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, size_t size, size_t alignment)
Constructor.
cl::Context context()
OpenCL context accessor.
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.
ICLMemoryRegion(CLCoreRuntimeContext *ctx, size_t size)
Constructor.
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-2021 Arm Limited.
const cl::Buffer & cl_data() const
Returns the underlying CL buffer.
void clSVMFree(cl_context context, void *svm_pointer)
Definition: OpenCL.cpp:252
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
cl::Context & context()
Accessor for the associated CL context.
Definition: CLScheduler.cpp:32
Core runtime context for OpenCL.
CLBufferMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, 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:223
void * buffer() override
Returns the pointer to the allocated data.
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:208
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.
void * clSVMAlloc(cl_context context, cl_svm_mem_flags_arm flags, size_t size, cl_uint alignment)
Definition: OpenCL.cpp:238
Provides global access to a CL context and command queue.
Definition: CLScheduler.h:43
CLFineSVMMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, size_t size, size_t alignment)
Constructor.
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:691
size_t size() const
Memory region size accessor.
Definition: IMemoryRegion.h:73