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 OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 // OTHER DEALINGS IN THE 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 *r_buf, size_t *r_size) try {
 196    property_buffer buf { r_buf, size, r_size };
 197
 198    if (!obj)
 199       return CL_INVALID_MEM_OBJECT;
 200
 201    switch (param) {
 202    case CL_MEM_TYPE:
 203       buf.as_scalar<cl_mem_object_type>() = obj->type();
 204       break;
 205
 206    case CL_MEM_FLAGS:
 207       buf.as_scalar<cl_mem_flags>() = obj->flags();
 208       break;
 209
 210    case CL_MEM_SIZE:
 211       buf.as_scalar<size_t>() = obj->size();
 212       break;
 213
 214    case CL_MEM_HOST_PTR:
 215       buf.as_scalar<void *>() = obj->host_ptr();
 216       break;
 217
 218    case CL_MEM_MAP_COUNT:
 219       buf.as_scalar<cl_uint>() = 0;
 220       break;
 221
 222    case CL_MEM_REFERENCE_COUNT:
 223       buf.as_scalar<cl_uint>() = obj->ref_count();
 224       break;
 225
 226    case CL_MEM_CONTEXT:
 227       buf.as_scalar<cl_context>() = &obj->ctx;
 228       break;
 229
 230    case CL_MEM_ASSOCIATED_MEMOBJECT: {
 231       sub_buffer *sub = dynamic_cast<sub_buffer *>(obj);
 232       buf.as_scalar<cl_mem>() = (sub ? &sub->parent : NULL);
 233       break;
 234    }
 235    case CL_MEM_OFFSET: {
 236       sub_buffer *sub = dynamic_cast<sub_buffer *>(obj);
 237       buf.as_scalar<size_t>() = (sub ? sub->offset() : 0);
 238       break;
 239    }
 240    default:
 241       throw error(CL_INVALID_VALUE);
 242    }
 243
 244    return CL_SUCCESS;
 245
 246 } catch (error &e) {
 247    return e.get();
 248 }
 249
 250 PUBLIC cl_int
 251 clGetImageInfo(cl_mem obj, cl_image_info param,
 252                size_t size, void *r_buf, size_t *r_size) try {
 253    property_buffer buf { r_buf, size, r_size };
 254    image *img = dynamic_cast<image *>(obj);
 255
 256    if (!img)
 257       return CL_INVALID_MEM_OBJECT;
 258
 259    switch (param) {
 260    case CL_IMAGE_FORMAT:
 261       buf.as_scalar<cl_image_format>() = img->format();
 262       break;
 263
 264    case CL_IMAGE_ELEMENT_SIZE:
 265       buf.as_scalar<size_t>() = 0;
 266       break;
 267
 268    case CL_IMAGE_ROW_PITCH:
 269       buf.as_scalar<size_t>() = img->row_pitch();
 270       break;
 271
 272    case CL_IMAGE_SLICE_PITCH:
 273       buf.as_scalar<size_t>() = img->slice_pitch();
 274       break;
 275
 276    case CL_IMAGE_WIDTH:
 277       buf.as_scalar<size_t>() = img->width();
 278       break;
 279
 280    case CL_IMAGE_HEIGHT:
 281       buf.as_scalar<size_t>() = img->height();
 282       break;
 283
 284    case CL_IMAGE_DEPTH:
 285       buf.as_scalar<size_t>() = img->depth();
 286       break;
 287
 288    default:
 289       throw error(CL_INVALID_VALUE);
 290    }
 291
 292    return CL_SUCCESS;
 293
 294 } catch (error &e) {
 295    return e.get();
 296 }
 297
 298 PUBLIC cl_int
 299 clRetainMemObject(cl_mem obj) {
 300    if (!obj)
 301       return CL_INVALID_MEM_OBJECT;
 302
 303    obj->retain();
 304    return CL_SUCCESS;
 305 }
 306
 307 PUBLIC cl_int
 308 clReleaseMemObject(cl_mem obj) {
 309    if (!obj)
 310       return CL_INVALID_MEM_OBJECT;
 311
 312    if (obj->release())
 313       delete obj;
 314
 315    return CL_SUCCESS;
 316 }
 317
 318 PUBLIC cl_int
 319 clSetMemObjectDestructorCallback(cl_mem obj,
 320                                  void (CL_CALLBACK *pfn_notify)(cl_mem, void *),
 321                                  void *user_data) {
 322    if (!obj)
 323       return CL_INVALID_MEM_OBJECT;
 324
 325    if (!pfn_notify)
 326       return CL_INVALID_VALUE;
 327
 328    obj->destroy_notify([=]{ pfn_notify(obj, user_data); });
 329
 330    return CL_SUCCESS;
 331 }