src/gallium/frontends/clover/api/platform.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 <unordered_map>
  24
  25 #include "api/dispatch.hpp"
  26 #include "api/util.hpp"
  27 #include "core/platform.hpp"
  28 #include "git_sha1.h"
  29 #include "util/u_debug.h"
  30
  31 using namespace clover;
  32
  33 namespace {
  34    platform _clover_platform;
  35 }
  36
  37 CLOVER_API cl_int
  38 clGetPlatformIDs(cl_uint num_entries, cl_platform_id *rd_platforms,
  39                  cl_uint *rnum_platforms) {
  40    if ((!num_entries && rd_platforms) ||
  41        (!rnum_platforms && !rd_platforms))
  42       return CL_INVALID_VALUE;
  43
  44    if (rnum_platforms)
  45       *rnum_platforms = 1;
  46    if (rd_platforms)
  47       *rd_platforms = desc(_clover_platform);
  48
  49    return CL_SUCCESS;
  50 }
  51
  52 cl_int
  53 clover::GetPlatformInfo(cl_platform_id d_platform, cl_platform_info param,
  54                         size_t size, void *r_buf, size_t *r_size) try {
  55    property_buffer buf { r_buf, size, r_size };
  56
  57    auto &platform = obj(d_platform);
  58
  59    switch (param) {
  60    case CL_PLATFORM_PROFILE:
  61       buf.as_string() = "FULL_PROFILE";
  62       break;
  63
  64    case CL_PLATFORM_VERSION: {
  65       static const std::string version_string =
  66             debug_get_option("CLOVER_PLATFORM_VERSION_OVERRIDE", "1.1");
  67
  68       buf.as_string() = "OpenCL " + version_string + " Mesa " PACKAGE_VERSION MESA_GIT_SHA1;
  69       break;
  70    }
  71    case CL_PLATFORM_NAME:
  72       buf.as_string() = "Clover";
  73       break;
  74
  75    case CL_PLATFORM_VENDOR:
  76       buf.as_string() = "Mesa";
  77       break;
  78
  79    case CL_PLATFORM_EXTENSIONS:
  80       buf.as_string() = platform.supported_extensions();
  81       break;
  82
  83    case CL_PLATFORM_ICD_SUFFIX_KHR:
  84       buf.as_string() = "MESA";
  85       break;
  86
  87    default:
  88       throw error(CL_INVALID_VALUE);
  89    }
  90
  91    return CL_SUCCESS;
  92
  93 } catch (error &e) {
  94    return e.get();
  95 }
  96
  97 void *
  98 clover::GetExtensionFunctionAddressForPlatform(cl_platform_id d_platform,
  99                                                const char *p_name) try {
 100    obj(d_platform);
 101    return GetExtensionFunctionAddress(p_name);
 102
 103 } catch (error &e) {
 104    return NULL;
 105 }
 106
 107 namespace {
 108
 109 cl_int
 110 enqueueSVMFreeARM(cl_command_queue command_queue,
 111                   cl_uint num_svm_pointers,
 112                   void *svm_pointers[],
 113                   void (CL_CALLBACK *pfn_free_func) (
 114                     cl_command_queue queue, cl_uint num_svm_pointers,
 115                     void *svm_pointers[], void *user_data),
 116                   void *user_data,
 117                   cl_uint num_events_in_wait_list,
 118                   const cl_event *event_wait_list,
 119                   cl_event *event) {
 120
 121    return EnqueueSVMFree(command_queue, num_svm_pointers, svm_pointers,
 122                          pfn_free_func, user_data, num_events_in_wait_list,
 123                          event_wait_list, event, CL_COMMAND_SVM_FREE_ARM);
 124 }
 125
 126 cl_int
 127 enqueueSVMMapARM(cl_command_queue command_queue,
 128                  cl_bool blocking_map,
 129                  cl_map_flags map_flags,
 130                  void *svm_ptr,
 131                  size_t size,
 132                  cl_uint num_events_in_wait_list,
 133                  const cl_event *event_wait_list,
 134                  cl_event *event) {
 135
 136    return EnqueueSVMMap(command_queue, blocking_map, map_flags, svm_ptr, size,
 137                         num_events_in_wait_list, event_wait_list, event,
 138                         CL_COMMAND_SVM_MAP_ARM);
 139 }
 140
 141 cl_int
 142 enqueueSVMMemcpyARM(cl_command_queue command_queue,
 143                     cl_bool blocking_copy,
 144                     void *dst_ptr,
 145                     const void *src_ptr,
 146                     size_t size,
 147                     cl_uint num_events_in_wait_list,
 148                     const cl_event *event_wait_list,
 149                     cl_event *event) {
 150
 151    return EnqueueSVMMemcpy(command_queue, blocking_copy, dst_ptr, src_ptr,
 152                            size, num_events_in_wait_list, event_wait_list,
 153                            event, CL_COMMAND_SVM_MEMCPY_ARM);
 154 }
 155
 156 cl_int
 157 enqueueSVMMemFillARM(cl_command_queue command_queue,
 158                      void *svm_ptr,
 159                      const void *pattern,
 160                      size_t pattern_size,
 161                      size_t size,
 162                      cl_uint num_events_in_wait_list,
 163                      const cl_event *event_wait_list,
 164                      cl_event *event) {
 165
 166    return EnqueueSVMMemFill(command_queue, svm_ptr, pattern, pattern_size,
 167                             size, num_events_in_wait_list, event_wait_list,
 168                             event, CL_COMMAND_SVM_MEMFILL_ARM);
 169 }
 170
 171 cl_int
 172 enqueueSVMUnmapARM(cl_command_queue command_queue,
 173                    void *svm_ptr,
 174                    cl_uint num_events_in_wait_list,
 175                    const cl_event *event_wait_list,
 176                    cl_event *event) {
 177
 178    return EnqueueSVMUnmap(command_queue, svm_ptr, num_events_in_wait_list,
 179                           event_wait_list, event, CL_COMMAND_SVM_UNMAP_ARM);
 180 }
 181
 182 const std::unordered_map<std::string, void *>
 183 ext_funcs = {
 184    // cl_arm_shared_virtual_memory
 185    { "clEnqueueSVMFreeARM", reinterpret_cast<void *>(enqueueSVMFreeARM) },
 186    { "clEnqueueSVMMapARM", reinterpret_cast<void *>(enqueueSVMMapARM) },
 187    { "clEnqueueSVMMemcpyARM", reinterpret_cast<void *>(enqueueSVMMemcpyARM) },
 188    { "clEnqueueSVMMemFillARM", reinterpret_cast<void *>(enqueueSVMMemFillARM) },
 189    { "clEnqueueSVMUnmapARM", reinterpret_cast<void *>(enqueueSVMUnmapARM) },
 190    { "clSetKernelArgSVMPointerARM", reinterpret_cast<void *>(clSetKernelArgSVMPointer) },
 191    { "clSetKernelExecInfoARM", reinterpret_cast<void *>(clSetKernelExecInfo) },
 192    { "clSVMAllocARM", reinterpret_cast<void *>(clSVMAlloc) },
 193    { "clSVMFreeARM", reinterpret_cast<void *>(clSVMFree) },
 194
 195    // cl_khr_icd
 196    { "clIcdGetPlatformIDsKHR", reinterpret_cast<void *>(IcdGetPlatformIDsKHR) },
 197 };
 198
 199 } // anonymous namespace
 200
 201 void *
 202 clover::GetExtensionFunctionAddress(const char *p_name) try {
 203    return ext_funcs.at(p_name);
 204 } catch (...) {
 205    return nullptr;
 206 }
 207
 208 cl_int
 209 clover::IcdGetPlatformIDsKHR(cl_uint num_entries, cl_platform_id *rd_platforms,
 210                              cl_uint *rnum_platforms) {
 211    return clGetPlatformIDs(num_entries, rd_platforms, rnum_platforms);
 212 }
 213
 214 CLOVER_ICD_API cl_int
 215 clGetPlatformInfo(cl_platform_id d_platform, cl_platform_info param,
 216                   size_t size, void *r_buf, size_t *r_size) {
 217    return GetPlatformInfo(d_platform, param, size, r_buf, r_size);
 218 }
 219
 220 CLOVER_ICD_API void *
 221 clGetExtensionFunctionAddress(const char *p_name) {
 222    return GetExtensionFunctionAddress(p_name);
 223 }
 224
 225 CLOVER_ICD_API void *
 226 clGetExtensionFunctionAddressForPlatform(cl_platform_id d_platform,
 227                                          const char *p_name) {
 228    return GetExtensionFunctionAddressForPlatform(d_platform, p_name);
 229 }
 230
 231 CLOVER_ICD_API cl_int
 232 clIcdGetPlatformIDsKHR(cl_uint num_entries, cl_platform_id *rd_platforms,
 233                        cl_uint *rnum_platforms) {
 234    return IcdGetPlatformIDsKHR(num_entries, rd_platforms, rnum_platforms);
 235 }