clover: Accept CL_MEM_READ_WRITE flag
[mesa.git] / src / gallium / state_trackers / clover / api / memory.cpp
1 //
2 // Copyright 2012 Francisco Jerez
3 //
4 // Permission is hereby granted, free of charge, to any person obtaining a
5 // copy of this software and associated documentation files (the "Software"),
6 // to deal in the Software without restriction, including without limitation
7 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 // and/or sell copies of the Software, and to permit persons to whom the
9 // Software is furnished to do so, subject to the following conditions:
10 //
11 // The above copyright notice and this permission notice shall be included in
12 // all copies or substantial portions of the Software.
13 //
14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 // THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
18 // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
19 // OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 // SOFTWARE.
21 //
22
23 #include "api/util.hpp"
24 #include "core/memory.hpp"
25 #include "core/format.hpp"
26
27 using namespace clover;
28
29 PUBLIC cl_mem
30 clCreateBuffer(cl_context ctx, cl_mem_flags flags, size_t size,
31 void *host_ptr, cl_int *errcode_ret) try {
32 if (!ctx)
33 throw error(CL_INVALID_CONTEXT);
34
35 if (bool(host_ptr) != bool(flags & (CL_MEM_USE_HOST_PTR |
36 CL_MEM_COPY_HOST_PTR)))
37 throw error(CL_INVALID_HOST_PTR);
38
39 if (!size)
40 throw error(CL_INVALID_BUFFER_SIZE);
41
42 if (flags & ~(CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_READ_ONLY |
43 CL_MEM_USE_HOST_PTR | CL_MEM_ALLOC_HOST_PTR |
44 CL_MEM_COPY_HOST_PTR))
45 throw error(CL_INVALID_VALUE);
46
47 ret_error(errcode_ret, CL_SUCCESS);
48 return new root_buffer(*ctx, flags, size, host_ptr);
49
50 } catch (error &e) {
51 ret_error(errcode_ret, e);
52 return NULL;
53 }
54
55 PUBLIC cl_mem
56 clCreateSubBuffer(cl_mem obj, cl_mem_flags flags, cl_buffer_create_type op,
57 const void *op_info, cl_int *errcode_ret) try {
58 root_buffer *parent = dynamic_cast<root_buffer *>(obj);
59
60 if (!parent)
61 throw error(CL_INVALID_MEM_OBJECT);
62
63 if ((flags & (CL_MEM_USE_HOST_PTR |
64 CL_MEM_ALLOC_HOST_PTR |
65 CL_MEM_COPY_HOST_PTR)) ||
66 (~flags & parent->flags() & (CL_MEM_READ_ONLY |
67 CL_MEM_WRITE_ONLY)))
68 throw error(CL_INVALID_VALUE);
69
70 if (op == CL_BUFFER_CREATE_TYPE_REGION) {
71 const cl_buffer_region *reg = (const cl_buffer_region *)op_info;
72
73 if (!reg ||
74 reg->origin > parent->size() ||
75 reg->origin + reg->size > parent->size())
76 throw error(CL_INVALID_VALUE);
77
78 if (!reg->size)
79 throw error(CL_INVALID_BUFFER_SIZE);
80
81 ret_error(errcode_ret, CL_SUCCESS);
82 return new sub_buffer(*parent, flags, reg->origin, reg->size);
83
84 } else {
85 throw error(CL_INVALID_VALUE);
86 }
87
88 } catch (error &e) {
89 ret_error(errcode_ret, e);
90 return NULL;
91 }
92
93 PUBLIC cl_mem
94 clCreateImage2D(cl_context ctx, cl_mem_flags flags,
95 const cl_image_format *format,
96 size_t width, size_t height, size_t row_pitch,
97 void *host_ptr, cl_int *errcode_ret) try {
98 if (!ctx)
99 throw error(CL_INVALID_CONTEXT);
100
101 if (flags & ~(CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_READ_ONLY |
102 CL_MEM_USE_HOST_PTR | CL_MEM_ALLOC_HOST_PTR |
103 CL_MEM_COPY_HOST_PTR))
104 throw error(CL_INVALID_VALUE);
105
106 if (!format)
107 throw error(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR);
108
109 if (width < 1 || height < 1)
110 throw error(CL_INVALID_IMAGE_SIZE);
111
112 if (bool(host_ptr) != bool(flags & (CL_MEM_USE_HOST_PTR |
113 CL_MEM_COPY_HOST_PTR)))
114 throw error(CL_INVALID_HOST_PTR);
115
116 if (!supported_formats(ctx, CL_MEM_OBJECT_IMAGE2D).count(*format))
117 throw error(CL_IMAGE_FORMAT_NOT_SUPPORTED);
118
119 ret_error(errcode_ret, CL_SUCCESS);
120 return new image2d(*ctx, flags, format, width, height,
121 row_pitch, host_ptr);
122
123 } catch (error &e) {
124 ret_error(errcode_ret, e);
125 return NULL;
126 }
127
128 PUBLIC cl_mem
129 clCreateImage3D(cl_context ctx, cl_mem_flags flags,
130 const cl_image_format *format,
131 size_t width, size_t height, size_t depth,
132 size_t row_pitch, size_t slice_pitch,
133 void *host_ptr, cl_int *errcode_ret) try {
134 if (!ctx)
135 throw error(CL_INVALID_CONTEXT);
136
137 if (flags & ~(CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_READ_ONLY |
138 CL_MEM_USE_HOST_PTR | CL_MEM_ALLOC_HOST_PTR |
139 CL_MEM_COPY_HOST_PTR))
140 throw error(CL_INVALID_VALUE);
141
142 if (!format)
143 throw error(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR);
144
145 if (width < 1 || height < 1 || depth < 2)
146 throw error(CL_INVALID_IMAGE_SIZE);
147
148 if (bool(host_ptr) != bool(flags & (CL_MEM_USE_HOST_PTR |
149 CL_MEM_COPY_HOST_PTR)))
150 throw error(CL_INVALID_HOST_PTR);
151
152 if (!supported_formats(ctx, CL_MEM_OBJECT_IMAGE3D).count(*format))
153 throw error(CL_IMAGE_FORMAT_NOT_SUPPORTED);
154
155 ret_error(errcode_ret, CL_SUCCESS);
156 return new image3d(*ctx, flags, format, width, height, depth,
157 row_pitch, slice_pitch, host_ptr);
158
159 } catch (error &e) {
160 ret_error(errcode_ret, e);
161 return NULL;
162 }
163
164 PUBLIC cl_int
165 clGetSupportedImageFormats(cl_context ctx, cl_mem_flags flags,
166 cl_mem_object_type type, cl_uint count,
167 cl_image_format *buf, cl_uint *count_ret) try {
168 if (!ctx)
169 throw error(CL_INVALID_CONTEXT);
170
171 if (flags & ~(CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_READ_ONLY |
172 CL_MEM_USE_HOST_PTR | CL_MEM_ALLOC_HOST_PTR |
173 CL_MEM_COPY_HOST_PTR))
174 throw error(CL_INVALID_VALUE);
175
176 if (!count && buf)
177 throw error(CL_INVALID_VALUE);
178
179 auto formats = supported_formats(ctx, type);
180
181 if (buf)
182 std::copy_n(formats.begin(), std::min((cl_uint)formats.size(), count),
183 buf);
184 if (count_ret)
185 *count_ret = formats.size();
186
187 return CL_SUCCESS;
188
189 } catch (error &e) {
190 return e.get();
191 }
192
193 PUBLIC cl_int
194 clGetMemObjectInfo(cl_mem obj, cl_mem_info param,
195 size_t size, void *buf, size_t *size_ret) {
196 if (!obj)
197 return CL_INVALID_MEM_OBJECT;
198
199 switch (param) {
200 case CL_MEM_TYPE:
201 return scalar_property<cl_mem_object_type>(buf, size, size_ret,
202 obj->type());
203
204 case CL_MEM_FLAGS:
205 return scalar_property<cl_mem_flags>(buf, size, size_ret, obj->flags());
206
207 case CL_MEM_SIZE:
208 return scalar_property<size_t>(buf, size, size_ret, obj->size());
209
210 case CL_MEM_HOST_PTR:
211 return scalar_property<void *>(buf, size, size_ret, obj->host_ptr());
212
213 case CL_MEM_MAP_COUNT:
214 return scalar_property<cl_uint>(buf, size, size_ret, 0);
215
216 case CL_MEM_REFERENCE_COUNT:
217 return scalar_property<cl_uint>(buf, size, size_ret, obj->ref_count());
218
219 case CL_MEM_CONTEXT:
220 return scalar_property<cl_context>(buf, size, size_ret, &obj->ctx);
221
222 case CL_MEM_ASSOCIATED_MEMOBJECT: {
223 sub_buffer *sub = dynamic_cast<sub_buffer *>(obj);
224 return scalar_property<cl_mem>(buf, size, size_ret,
225 (sub ? &sub->parent : NULL));
226 }
227 case CL_MEM_OFFSET: {
228 sub_buffer *sub = dynamic_cast<sub_buffer *>(obj);
229 return scalar_property<size_t>(buf, size, size_ret,
230 (sub ? sub->offset() : 0));
231 }
232 default:
233 return CL_INVALID_VALUE;
234 }
235 }
236
237 PUBLIC cl_int
238 clGetImageInfo(cl_mem obj, cl_image_info param,
239 size_t size, void *buf, size_t *size_ret) {
240 image *img = dynamic_cast<image *>(obj);
241 if (!img)
242 return CL_INVALID_MEM_OBJECT;
243
244 switch (param) {
245 case CL_IMAGE_FORMAT:
246 return scalar_property<cl_image_format>(buf, size, size_ret,
247 img->format());
248
249 case CL_IMAGE_ELEMENT_SIZE:
250 return scalar_property<size_t>(buf, size, size_ret, 0);
251
252 case CL_IMAGE_ROW_PITCH:
253 return scalar_property<size_t>(buf, size, size_ret, img->row_pitch());
254
255 case CL_IMAGE_SLICE_PITCH:
256 return scalar_property<size_t>(buf, size, size_ret, img->slice_pitch());
257
258 case CL_IMAGE_WIDTH:
259 return scalar_property<size_t>(buf, size, size_ret, img->width());
260
261 case CL_IMAGE_HEIGHT:
262 return scalar_property<size_t>(buf, size, size_ret, img->height());
263
264 case CL_IMAGE_DEPTH:
265 return scalar_property<size_t>(buf, size, size_ret, img->depth());
266
267 default:
268 return CL_INVALID_VALUE;
269 }
270 }
271
272 PUBLIC cl_int
273 clRetainMemObject(cl_mem obj) {
274 if (!obj)
275 return CL_INVALID_MEM_OBJECT;
276
277 obj->retain();
278 return CL_SUCCESS;
279 }
280
281 PUBLIC cl_int
282 clReleaseMemObject(cl_mem obj) {
283 if (!obj)
284 return CL_INVALID_MEM_OBJECT;
285
286 if (obj->release())
287 delete obj;
288
289 return CL_SUCCESS;
290 }
291
292 PUBLIC cl_int
293 clSetMemObjectDestructorCallback(cl_mem obj,
294 void (CL_CALLBACK *pfn_notify)(cl_mem, void *),
295 void *user_data) {
296 if (!obj)
297 return CL_INVALID_MEM_OBJECT;
298
299 if (!pfn_notify)
300 return CL_INVALID_VALUE;
301
302 obj->destroy_notify([=]{ pfn_notify(obj, user_data); });
303
304 return CL_SUCCESS;
305 }