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 */
24 #include "arm_compute/runtime/CL/CLMemoryRegion.h"
25
26 #include "arm_compute/core/Error.h"
27 #include "arm_compute/runtime/CL/CLScheduler.h"
28
29 namespace arm_compute
30 {
ICLMemoryRegion(size_t size)31 ICLMemoryRegion::ICLMemoryRegion(size_t size)
32 : IMemoryRegion(size),
33 _queue(CLScheduler::get().queue()),
34 _ctx(CLScheduler::get().context()),
35 _mapping(nullptr),
36 _mem()
37 {
38 }
39
cl_data() const40 const cl::Buffer &ICLMemoryRegion::cl_data() const
41 {
42 return _mem;
43 }
44
buffer()45 void *ICLMemoryRegion::buffer()
46 {
47 return _mapping;
48 }
49
buffer() const50 const void *ICLMemoryRegion::buffer() const
51 {
52 return _mapping;
53 }
54
extract_subregion(size_t offset,size_t size)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
CLBufferMemoryRegion(cl_mem_flags flags,size_t size)61 CLBufferMemoryRegion::CLBufferMemoryRegion(cl_mem_flags flags, size_t size)
62 : ICLMemoryRegion(size)
63 {
64 if(_size != 0)
65 {
66 _mem = cl::Buffer(CLScheduler::get().context(), flags, _size);
67 }
68 }
69
CLBufferMemoryRegion(const cl::Buffer & buffer)70 CLBufferMemoryRegion::CLBufferMemoryRegion(const cl::Buffer &buffer)
71 : ICLMemoryRegion(buffer.getInfo<CL_MEM_SIZE>())
72 {
73 _mem = buffer;
74 }
75
ptr()76 void *CLBufferMemoryRegion::ptr()
77 {
78 return nullptr;
79 }
80
map(cl::CommandQueue & q,bool blocking)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
unmap(cl::CommandQueue & q)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
ICLSVMMemoryRegion(cl_mem_flags flags,size_t size,size_t alignment)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
~ICLSVMMemoryRegion()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
ptr()124 void *ICLSVMMemoryRegion::ptr()
125 {
126 return _ptr;
127 }
128
CLCoarseSVMMemoryRegion(cl_mem_flags flags,size_t size,size_t alignment)129 CLCoarseSVMMemoryRegion::CLCoarseSVMMemoryRegion(cl_mem_flags flags, size_t size, size_t alignment)
130 : ICLSVMMemoryRegion(flags, size, alignment)
131 {
132 }
133
map(cl::CommandQueue & q,bool blocking)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
unmap(cl::CommandQueue & q)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
CLFineSVMMemoryRegion(cl_mem_flags flags,size_t size,size_t alignment)149 CLFineSVMMemoryRegion::CLFineSVMMemoryRegion(cl_mem_flags flags, size_t size, size_t alignment)
150 : ICLSVMMemoryRegion(flags, size, alignment)
151 {
152 }
153
map(cl::CommandQueue & q,bool blocking)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
unmap(cl::CommandQueue & q)164 void CLFineSVMMemoryRegion::unmap(cl::CommandQueue &q)
165 {
166 ARM_COMPUTE_UNUSED(q);
167 _mapping = nullptr;
168 }
169 } // namespace arm_compute
170