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 PUBLIC cl_int
  30 clGetDeviceIDs(cl_platform_id d_platform, cl_device_type device_type,
  31                cl_uint num_entries, cl_device_id *devices,
  32                cl_uint *num_devices) {
  33    auto &platform = obj(d_platform);
  34    std::vector<cl_device_id> devs;
  35
  36    if ((!num_entries && devices) ||
  37        (!num_devices && !devices))
  38       return 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          devs.push_back(&dev);
  46    }
  47
  48    if (devs.empty())
  49       return CL_DEVICE_NOT_FOUND;
  50
  51    // ...and return the requested data.
  52    if (num_devices)
  53       *num_devices = devs.size();
  54    if (devices)
  55       std::copy_n(devs.begin(),
  56                   std::min((cl_uint)devs.size(), num_entries),
  57                   devices);
  58
  59    return CL_SUCCESS;
  60 }
  61
  62 PUBLIC cl_int
  63 clGetDeviceInfo(cl_device_id dev, cl_device_info param,
  64                 size_t size, void *r_buf, size_t *r_size) try {
  65    property_buffer buf { r_buf, size, r_size };
  66
  67    if (!dev)
  68       return CL_INVALID_DEVICE;
  69
  70    switch (param) {
  71    case CL_DEVICE_TYPE:
  72       buf.as_scalar<cl_device_type>() = dev->type();
  73       break;
  74
  75    case CL_DEVICE_VENDOR_ID:
  76       buf.as_scalar<cl_uint>() = dev->vendor_id();
  77       break;
  78
  79    case CL_DEVICE_MAX_COMPUTE_UNITS:
  80       buf.as_scalar<cl_uint>() = 1;
  81       break;
  82
  83    case CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS:
  84       buf.as_scalar<cl_uint>() = dev->max_block_size().size();
  85       break;
  86
  87    case CL_DEVICE_MAX_WORK_ITEM_SIZES:
  88       buf.as_vector<size_t>() = dev->max_block_size();
  89       break;
  90
  91    case CL_DEVICE_MAX_WORK_GROUP_SIZE:
  92       buf.as_scalar<size_t>() = dev->max_threads_per_block();
  93       break;
  94
  95    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR:
  96       buf.as_scalar<cl_uint>() = 16;
  97       break;
  98
  99    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT:
 100       buf.as_scalar<cl_uint>() = 8;
 101       break;
 102
 103    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT:
 104       buf.as_scalar<cl_uint>() = 4;
 105       break;
 106
 107    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG:
 108       buf.as_scalar<cl_uint>() = 2;
 109       break;
 110
 111    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT:
 112       buf.as_scalar<cl_uint>() = 4;
 113       break;
 114
 115    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE:
 116       buf.as_scalar<cl_uint>() = 2;
 117       break;
 118
 119    case CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF:
 120       buf.as_scalar<cl_uint>() = 0;
 121       break;
 122
 123    case CL_DEVICE_MAX_CLOCK_FREQUENCY:
 124       buf.as_scalar<cl_uint>() = 0;
 125       break;
 126
 127    case CL_DEVICE_ADDRESS_BITS:
 128       buf.as_scalar<cl_uint>() = 32;
 129       break;
 130
 131    case CL_DEVICE_MAX_READ_IMAGE_ARGS:
 132       buf.as_scalar<cl_uint>() = dev->max_images_read();
 133       break;
 134
 135    case CL_DEVICE_MAX_WRITE_IMAGE_ARGS:
 136       buf.as_scalar<cl_uint>() = dev->max_images_write();
 137       break;
 138
 139    case CL_DEVICE_MAX_MEM_ALLOC_SIZE:
 140       buf.as_scalar<cl_ulong>() = dev->max_mem_alloc_size();
 141       break;
 142
 143    case CL_DEVICE_IMAGE2D_MAX_WIDTH:
 144    case CL_DEVICE_IMAGE2D_MAX_HEIGHT:
 145       buf.as_scalar<size_t>() = 1 << dev->max_image_levels_2d();
 146       break;
 147
 148    case CL_DEVICE_IMAGE3D_MAX_WIDTH:
 149    case CL_DEVICE_IMAGE3D_MAX_HEIGHT:
 150    case CL_DEVICE_IMAGE3D_MAX_DEPTH:
 151       buf.as_scalar<size_t>() = 1 << dev->max_image_levels_3d();
 152       break;
 153
 154    case CL_DEVICE_IMAGE_SUPPORT:
 155       buf.as_scalar<cl_bool>() = CL_TRUE;
 156       break;
 157
 158    case CL_DEVICE_MAX_PARAMETER_SIZE:
 159       buf.as_scalar<size_t>() = dev->max_mem_input();
 160       break;
 161
 162    case CL_DEVICE_MAX_SAMPLERS:
 163       buf.as_scalar<cl_uint>() = dev->max_samplers();
 164       break;
 165
 166    case CL_DEVICE_MEM_BASE_ADDR_ALIGN:
 167    case CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE:
 168       buf.as_scalar<cl_uint>() = 128;
 169       break;
 170
 171    case CL_DEVICE_SINGLE_FP_CONFIG:
 172       buf.as_scalar<cl_device_fp_config>() =
 173          CL_FP_DENORM | CL_FP_INF_NAN | CL_FP_ROUND_TO_NEAREST;
 174       break;
 175
 176    case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE:
 177       buf.as_scalar<cl_device_mem_cache_type>() = CL_NONE;
 178       break;
 179
 180    case CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE:
 181       buf.as_scalar<cl_uint>() = 0;
 182       break;
 183
 184    case CL_DEVICE_GLOBAL_MEM_CACHE_SIZE:
 185       buf.as_scalar<cl_ulong>() = 0;
 186       break;
 187
 188    case CL_DEVICE_GLOBAL_MEM_SIZE:
 189       buf.as_scalar<cl_ulong>() = dev->max_mem_global();
 190       break;
 191
 192    case CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE:
 193       buf.as_scalar<cl_ulong>() = dev->max_const_buffer_size();
 194       break;
 195
 196    case CL_DEVICE_MAX_CONSTANT_ARGS:
 197       buf.as_scalar<cl_uint>() = dev->max_const_buffers();
 198       break;
 199
 200    case CL_DEVICE_LOCAL_MEM_TYPE:
 201       buf.as_scalar<cl_device_local_mem_type>() = CL_LOCAL;
 202       break;
 203
 204    case CL_DEVICE_LOCAL_MEM_SIZE:
 205       buf.as_scalar<cl_ulong>() = dev->max_mem_local();
 206       break;
 207
 208    case CL_DEVICE_ERROR_CORRECTION_SUPPORT:
 209       buf.as_scalar<cl_bool>() = CL_FALSE;
 210       break;
 211
 212    case CL_DEVICE_PROFILING_TIMER_RESOLUTION:
 213       buf.as_scalar<size_t>() = 0;
 214       break;
 215
 216    case CL_DEVICE_ENDIAN_LITTLE:
 217       buf.as_scalar<cl_bool>() = (dev->endianness() == PIPE_ENDIAN_LITTLE);
 218       break;
 219
 220    case CL_DEVICE_AVAILABLE:
 221    case CL_DEVICE_COMPILER_AVAILABLE:
 222       buf.as_scalar<cl_bool>() = CL_TRUE;
 223       break;
 224
 225    case CL_DEVICE_EXECUTION_CAPABILITIES:
 226       buf.as_scalar<cl_device_exec_capabilities>() = CL_EXEC_KERNEL;
 227       break;
 228
 229    case CL_DEVICE_QUEUE_PROPERTIES:
 230       buf.as_scalar<cl_command_queue_properties>() = CL_QUEUE_PROFILING_ENABLE;
 231       break;
 232
 233    case CL_DEVICE_NAME:
 234       buf.as_string() = dev->device_name();
 235       break;
 236
 237    case CL_DEVICE_VENDOR:
 238       buf.as_string() = dev->vendor_name();
 239       break;
 240
 241    case CL_DRIVER_VERSION:
 242       buf.as_string() = PACKAGE_VERSION;
 243       break;
 244
 245    case CL_DEVICE_PROFILE:
 246       buf.as_string() = "FULL_PROFILE";
 247       break;
 248
 249    case CL_DEVICE_VERSION:
 250       buf.as_string() = "OpenCL 1.1 MESA " PACKAGE_VERSION;
 251       break;
 252
 253    case CL_DEVICE_EXTENSIONS:
 254       buf.as_string() = "";
 255       break;
 256
 257    case CL_DEVICE_PLATFORM:
 258       buf.as_scalar<cl_platform_id>() = desc(dev->platform);
 259       break;
 260
 261    case CL_DEVICE_HOST_UNIFIED_MEMORY:
 262       buf.as_scalar<cl_bool>() = CL_TRUE;
 263       break;
 264
 265    case CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR:
 266       buf.as_scalar<cl_uint>() = 16;
 267       break;
 268
 269    case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT:
 270       buf.as_scalar<cl_uint>() = 8;
 271       break;
 272
 273    case CL_DEVICE_NATIVE_VECTOR_WIDTH_INT:
 274       buf.as_scalar<cl_uint>() = 4;
 275       break;
 276
 277    case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG:
 278       buf.as_scalar<cl_uint>() = 2;
 279       break;
 280
 281    case CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT:
 282       buf.as_scalar<cl_uint>() = 4;
 283       break;
 284
 285    case CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE:
 286       buf.as_scalar<cl_uint>() = 2;
 287       break;
 288
 289    case CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF:
 290       buf.as_scalar<cl_uint>() = 0;
 291       break;
 292
 293    case CL_DEVICE_OPENCL_C_VERSION:
 294       buf.as_string() = "OpenCL C 1.1";
 295       break;
 296
 297    default:
 298       throw error(CL_INVALID_VALUE);
 299    }
 300
 301    return CL_SUCCESS;
 302
 303 } catch (error &e) {
 304    return e.get();
 305 }