src/gallium/state_trackers/clover/api/device.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/platform.hpp"
  25 #include "core/device.hpp"
  26
  27 using namespace clover;
  28
  29 CLOVER_API cl_int
  30 clGetDeviceIDs(cl_platform_id d_platform, cl_device_type device_type,
  31                cl_uint num_entries, cl_device_id *rd_devices,
  32                cl_uint *rnum_devices) try {
  33    auto &platform = obj(d_platform);
  34    std::vector<cl_device_id> d_devs;
  35
  36    if ((!num_entries && rd_devices) ||
  37        (!rnum_devices && !rd_devices))
  38       throw error(CL_INVALID_VALUE);
  39
  40    // Collect matching devices
  41    for (device &dev : platform) {
  42       if (((device_type & CL_DEVICE_TYPE_DEFAULT) &&
  43            dev == platform.front()) ||
  44           (device_type & dev.type()))
  45          d_devs.push_back(desc(dev));
  46    }
  47
  48    if (d_devs.empty())
  49       throw error(CL_DEVICE_NOT_FOUND);
  50
  51    // ...and return the requested data.
  52    if (rnum_devices)
  53       *rnum_devices = d_devs.size();
  54    if (rd_devices)
  55       copy(range(d_devs.begin(),
  56                  std::min((unsigned)d_devs.size(), num_entries)),
  57            rd_devices);
  58
  59    return CL_SUCCESS;
  60
  61 } catch (error &e) {
  62    return e.get();
  63 }
  64
  65 CLOVER_API cl_int
  66 clCreateSubDevices(cl_device_id d_dev,
  67                    const cl_device_partition_property *props,
  68                    cl_uint num_devs, cl_device_id *rd_devs,
  69                    cl_uint *rnum_devs) {
  70    // There are no currently supported partitioning schemes.
  71    return CL_INVALID_VALUE;
  72 }
  73
  74 CLOVER_API cl_int
  75 clRetainDevice(cl_device_id d_dev) try {
  76    obj(d_dev);
  77
  78    // The reference count doesn't change for root devices.
  79    return CL_SUCCESS;
  80
  81 } catch (error &e) {
  82    return e.get();
  83 }
  84
  85 CLOVER_API cl_int
  86 clReleaseDevice(cl_device_id d_dev) try {
  87    obj(d_dev);
  88
  89    // The reference count doesn't change for root devices.
  90    return CL_SUCCESS;
  91
  92 } catch (error &e) {
  93    return e.get();
  94 }
  95
  96 CLOVER_API cl_int
  97 clGetDeviceInfo(cl_device_id d_dev, cl_device_info param,
  98                 size_t size, void *r_buf, size_t *r_size) try {
  99    property_buffer buf { r_buf, size, r_size };
 100    auto &dev = obj(d_dev);
 101
 102    switch (param) {
 103    case CL_DEVICE_TYPE:
 104       buf.as_scalar<cl_device_type>() = dev.type();
 105       break;
 106
 107    case CL_DEVICE_VENDOR_ID:
 108       buf.as_scalar<cl_uint>() = dev.vendor_id();
 109       break;
 110
 111    case CL_DEVICE_MAX_COMPUTE_UNITS:
 112       buf.as_scalar<cl_uint>() = dev.max_compute_units();
 113       break;
 114
 115    case CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS:
 116       buf.as_scalar<cl_uint>() = dev.max_block_size().size();
 117       break;
 118
 119    case CL_DEVICE_MAX_WORK_ITEM_SIZES:
 120       buf.as_vector<size_t>() = dev.max_block_size();
 121       break;
 122
 123    case CL_DEVICE_MAX_WORK_GROUP_SIZE:
 124       buf.as_scalar<size_t>() = dev.max_threads_per_block();
 125       break;
 126
 127    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR:
 128       buf.as_scalar<cl_uint>() = 16;
 129       break;
 130
 131    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT:
 132       buf.as_scalar<cl_uint>() = 8;
 133       break;
 134
 135    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT:
 136       buf.as_scalar<cl_uint>() = 4;
 137       break;
 138
 139    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG:
 140       buf.as_scalar<cl_uint>() = 2;
 141       break;
 142
 143    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT:
 144       buf.as_scalar<cl_uint>() = 4;
 145       break;
 146
 147    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE:
 148       buf.as_scalar<cl_uint>() = 2;
 149       break;
 150
 151    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF:
 152       buf.as_scalar<cl_uint>() = 0;
 153       break;
 154
 155    case CL_DEVICE_MAX_CLOCK_FREQUENCY:
 156       buf.as_scalar<cl_uint>() = dev.max_clock_frequency();
 157       break;
 158
 159    case CL_DEVICE_ADDRESS_BITS:
 160       buf.as_scalar<cl_uint>() = 32;
 161       break;
 162
 163    case CL_DEVICE_MAX_READ_IMAGE_ARGS:
 164       buf.as_scalar<cl_uint>() = dev.max_images_read();
 165       break;
 166
 167    case CL_DEVICE_MAX_WRITE_IMAGE_ARGS:
 168       buf.as_scalar<cl_uint>() = dev.max_images_write();
 169       break;
 170
 171    case CL_DEVICE_MAX_MEM_ALLOC_SIZE:
 172       buf.as_scalar<cl_ulong>() = dev.max_mem_alloc_size();
 173       break;
 174
 175    case CL_DEVICE_IMAGE2D_MAX_WIDTH:
 176    case CL_DEVICE_IMAGE2D_MAX_HEIGHT:
 177       buf.as_scalar<size_t>() = 1 << dev.max_image_levels_2d();
 178       break;
 179
 180    case CL_DEVICE_IMAGE3D_MAX_WIDTH:
 181    case CL_DEVICE_IMAGE3D_MAX_HEIGHT:
 182    case CL_DEVICE_IMAGE3D_MAX_DEPTH:
 183       buf.as_scalar<size_t>() = 1 << dev.max_image_levels_3d();
 184       break;
 185
 186    case CL_DEVICE_IMAGE_SUPPORT:
 187       buf.as_scalar<cl_bool>() = dev.image_support();
 188       break;
 189
 190    case CL_DEVICE_MAX_PARAMETER_SIZE:
 191       buf.as_scalar<size_t>() = dev.max_mem_input();
 192       break;
 193
 194    case CL_DEVICE_MAX_SAMPLERS:
 195       buf.as_scalar<cl_uint>() = dev.max_samplers();
 196       break;
 197
 198    case CL_DEVICE_MEM_BASE_ADDR_ALIGN:
 199    case CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE:
 200       buf.as_scalar<cl_uint>() = 128;
 201       break;
 202
 203    case CL_DEVICE_SINGLE_FP_CONFIG:
 204       buf.as_scalar<cl_device_fp_config>() =
 205          CL_FP_DENORM | CL_FP_INF_NAN | CL_FP_ROUND_TO_NEAREST;
 206       break;
 207
 208    case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE:
 209       buf.as_scalar<cl_device_mem_cache_type>() = CL_NONE;
 210       break;
 211
 212    case CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE:
 213       buf.as_scalar<cl_uint>() = 0;
 214       break;
 215
 216    case CL_DEVICE_GLOBAL_MEM_CACHE_SIZE:
 217       buf.as_scalar<cl_ulong>() = 0;
 218       break;
 219
 220    case CL_DEVICE_GLOBAL_MEM_SIZE:
 221       buf.as_scalar<cl_ulong>() = dev.max_mem_global();
 222       break;
 223
 224    case CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE:
 225       buf.as_scalar<cl_ulong>() = dev.max_const_buffer_size();
 226       break;
 227
 228    case CL_DEVICE_MAX_CONSTANT_ARGS:
 229       buf.as_scalar<cl_uint>() = dev.max_const_buffers();
 230       break;
 231
 232    case CL_DEVICE_LOCAL_MEM_TYPE:
 233       buf.as_scalar<cl_device_local_mem_type>() = CL_LOCAL;
 234       break;
 235
 236    case CL_DEVICE_LOCAL_MEM_SIZE:
 237       buf.as_scalar<cl_ulong>() = dev.max_mem_local();
 238       break;
 239
 240    case CL_DEVICE_ERROR_CORRECTION_SUPPORT:
 241       buf.as_scalar<cl_bool>() = CL_FALSE;
 242       break;
 243
 244    case CL_DEVICE_PROFILING_TIMER_RESOLUTION:
 245       buf.as_scalar<size_t>() = 0;
 246       break;
 247
 248    case CL_DEVICE_ENDIAN_LITTLE:
 249       buf.as_scalar<cl_bool>() = (dev.endianness() == PIPE_ENDIAN_LITTLE);
 250       break;
 251
 252    case CL_DEVICE_AVAILABLE:
 253    case CL_DEVICE_COMPILER_AVAILABLE:
 254       buf.as_scalar<cl_bool>() = CL_TRUE;
 255       break;
 256
 257    case CL_DEVICE_EXECUTION_CAPABILITIES:
 258       buf.as_scalar<cl_device_exec_capabilities>() = CL_EXEC_KERNEL;
 259       break;
 260
 261    case CL_DEVICE_QUEUE_PROPERTIES:
 262       buf.as_scalar<cl_command_queue_properties>() = CL_QUEUE_PROFILING_ENABLE;
 263       break;
 264
 265    case CL_DEVICE_NAME:
 266       buf.as_string() = dev.device_name();
 267       break;
 268
 269    case CL_DEVICE_VENDOR:
 270       buf.as_string() = dev.vendor_name();
 271       break;
 272
 273    case CL_DRIVER_VERSION:
 274       buf.as_string() = PACKAGE_VERSION;
 275       break;
 276
 277    case CL_DEVICE_PROFILE:
 278       buf.as_string() = "FULL_PROFILE";
 279       break;
 280
 281    case CL_DEVICE_VERSION:
 282       buf.as_string() = "OpenCL 1.1 MESA " PACKAGE_VERSION;
 283       break;
 284
 285    case CL_DEVICE_EXTENSIONS:
 286       buf.as_string() = "";
 287       break;
 288
 289    case CL_DEVICE_PLATFORM:
 290       buf.as_scalar<cl_platform_id>() = desc(dev.platform);
 291       break;
 292
 293    case CL_DEVICE_HOST_UNIFIED_MEMORY:
 294       buf.as_scalar<cl_bool>() = CL_TRUE;
 295       break;
 296
 297    case CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR:
 298       buf.as_scalar<cl_uint>() = 16;
 299       break;
 300
 301    case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT:
 302       buf.as_scalar<cl_uint>() = 8;
 303       break;
 304
 305    case CL_DEVICE_NATIVE_VECTOR_WIDTH_INT:
 306       buf.as_scalar<cl_uint>() = 4;
 307       break;
 308
 309    case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG:
 310       buf.as_scalar<cl_uint>() = 2;
 311       break;
 312
 313    case CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT:
 314       buf.as_scalar<cl_uint>() = 4;
 315       break;
 316
 317    case CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE:
 318       buf.as_scalar<cl_uint>() = 2;
 319       break;
 320
 321    case CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF:
 322       buf.as_scalar<cl_uint>() = 0;
 323       break;
 324
 325    case CL_DEVICE_OPENCL_C_VERSION:
 326       buf.as_string() = "OpenCL C 1.1";
 327       break;
 328
 329    case CL_DEVICE_PARENT_DEVICE:
 330       buf.as_scalar<cl_device_id>() = NULL;
 331       break;
 332
 333    case CL_DEVICE_PARTITION_MAX_SUB_DEVICES:
 334       buf.as_scalar<cl_uint>() = 0;
 335       break;
 336
 337    case CL_DEVICE_PARTITION_PROPERTIES:
 338       buf.as_vector<cl_device_partition_property>() =
 339          desc(property_list<cl_device_partition_property>());
 340       break;
 341
 342    case CL_DEVICE_PARTITION_AFFINITY_DOMAIN:
 343       buf.as_scalar<cl_device_affinity_domain>() = 0;
 344       break;
 345
 346    case CL_DEVICE_PARTITION_TYPE:
 347       buf.as_vector<cl_device_partition_property>() =
 348          desc(property_list<cl_device_partition_property>());
 349       break;
 350
 351    case CL_DEVICE_REFERENCE_COUNT:
 352       buf.as_scalar<cl_uint>() = 1;
 353       break;
 354
 355    default:
 356       throw error(CL_INVALID_VALUE);
 357    }
 358
 359    return CL_SUCCESS;
 360
 361 } catch (error &e) {
 362    return e.get();
 363 }