libhb/opencl.c

   1 /* opencl.c
   2
   3    Copyright (c) 2003-2015 HandBrake Team
   4    This file is part of the HandBrake source code
   5    Homepage: <http://handbrake.fr/>.
   6    It may be used under the terms of the GNU General Public License v2.
   7    For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html
   8  */
   9
  10 #ifdef _WIN32
  11 #include <windows.h>
  12 #define HB_OCL_DLOPEN  LoadLibraryW(L"OpenCL")
  13 #define HB_OCL_DLSYM   GetProcAddress
  14 #define HB_OCL_DLCLOSE FreeLibrary
  15 #else
  16 #include <dlfcn.h>
  17 #ifdef __APPLE__
  18 #define HB_OCL_DLOPEN  dlopen("/System/Library/Frameworks/OpenCL.framework/OpenCL", RTLD_NOW)
  19 #else
  20 #define HB_OCL_DLOPEN  dlopen("libOpenCL.so", RTLD_NOW)
  21 #endif
  22 #define HB_OCL_DLSYM   dlsym
  23 #define HB_OCL_DLCLOSE dlclose
  24 #endif
  25
  26 #include "common.h"
  27 #include "opencl.h"
  28
  29 hb_opencl_library_t *hb_ocl = NULL;
  30
  31 int hb_ocl_init()
  32 {
  33     if (hb_ocl == NULL)
  34     {
  35         if ((hb_ocl = hb_opencl_library_init()) == NULL)
  36         {
  37             return -1;
  38         }
  39     }
  40     return 0;
  41 }
  42
  43 void hb_ocl_close()
  44 {
  45     hb_opencl_library_close(&hb_ocl);
  46 }
  47
  48 hb_opencl_library_t* hb_opencl_library_init()
  49 {
  50     hb_opencl_library_t *opencl;
  51     if ((opencl = calloc(1, sizeof(hb_opencl_library_t))) == NULL)
  52     {
  53         hb_error("hb_opencl_library_init: memory allocation failure");
  54         goto fail;
  55     }
  56
  57     opencl->library = HB_OCL_DLOPEN;
  58     if (opencl->library == NULL)
  59     {
  60         goto fail;
  61     }
  62
  63 #define HB_OCL_LOAD(func)                                                       \
  64 {                                                                               \
  65     if ((opencl->func = (void*)HB_OCL_DLSYM(opencl->library, #func)) == NULL)   \
  66     {                                                                           \
  67         hb_log("hb_opencl_library_init: failed to load function '%s'", #func);  \
  68         goto fail;                                                              \
  69     }                                                                           \
  70 }
  71     HB_OCL_LOAD(clBuildProgram);
  72     HB_OCL_LOAD(clCreateBuffer);
  73     HB_OCL_LOAD(clCreateCommandQueue);
  74     HB_OCL_LOAD(clCreateContextFromType);
  75     HB_OCL_LOAD(clCreateKernel);
  76     HB_OCL_LOAD(clCreateProgramWithBinary);
  77     HB_OCL_LOAD(clCreateProgramWithSource);
  78     HB_OCL_LOAD(clEnqueueCopyBuffer);
  79     HB_OCL_LOAD(clEnqueueMapBuffer);
  80     HB_OCL_LOAD(clEnqueueNDRangeKernel);
  81     HB_OCL_LOAD(clEnqueueReadBuffer);
  82     HB_OCL_LOAD(clEnqueueUnmapMemObject);
  83     HB_OCL_LOAD(clEnqueueWriteBuffer);
  84     HB_OCL_LOAD(clFlush);
  85     HB_OCL_LOAD(clGetCommandQueueInfo);
  86     HB_OCL_LOAD(clGetContextInfo);
  87     HB_OCL_LOAD(clGetDeviceIDs);
  88     HB_OCL_LOAD(clGetDeviceInfo);
  89     HB_OCL_LOAD(clGetPlatformIDs);
  90     HB_OCL_LOAD(clGetPlatformInfo);
  91     HB_OCL_LOAD(clGetProgramBuildInfo);
  92     HB_OCL_LOAD(clGetProgramInfo);
  93     HB_OCL_LOAD(clReleaseCommandQueue);
  94     HB_OCL_LOAD(clReleaseContext);
  95     HB_OCL_LOAD(clReleaseEvent);
  96     HB_OCL_LOAD(clReleaseKernel);
  97     HB_OCL_LOAD(clReleaseMemObject);
  98     HB_OCL_LOAD(clReleaseProgram);
  99     HB_OCL_LOAD(clSetKernelArg);
 100     HB_OCL_LOAD(clWaitForEvents);
 101
 102     //success
 103     return opencl;
 104
 105 fail:
 106     hb_opencl_library_close(&opencl);
 107     return NULL;
 108 }
 109
 110 void hb_opencl_library_close(hb_opencl_library_t **_opencl)
 111 {
 112     if (_opencl == NULL)
 113     {
 114         return;
 115     }
 116     hb_opencl_library_t *opencl = *_opencl;
 117
 118     if (opencl != NULL)
 119     {
 120         if (opencl->library != NULL)
 121         {
 122             HB_OCL_DLCLOSE(opencl->library);
 123         }
 124         free(opencl);
 125     }
 126     *_opencl = NULL;
 127 }
 128
 129 static int hb_opencl_device_is_supported(hb_opencl_device_t* device)
 130 {
 131     // we only support OpenCL on GPUs for now
 132     // Ivy Bridge supports OpenCL on GPU, but it's too slow to be usable
 133     // FIXME: disable on NVIDIA to to a bug
 134     if ((device != NULL) &&
 135         (device->type & CL_DEVICE_TYPE_GPU) &&
 136         (device->ocl_vendor != HB_OCL_VENDOR_NVIDIA) &&
 137         (device->ocl_vendor != HB_OCL_VENDOR_INTEL ||
 138          hb_get_cpu_platform() != HB_CPU_PLATFORM_INTEL_IVB))
 139     {
 140         int major, minor;
 141         // check OpenCL version:
 142         // OpenCL<space><major_version.minor_version><space><vendor-specific information>
 143         if (sscanf(device->version, "OpenCL %d.%d", &major, &minor) != 2)
 144         {
 145             return 0;
 146         }
 147         return (major > HB_OCL_MINVERSION_MAJOR) || (major == HB_OCL_MINVERSION_MAJOR &&
 148                                                      minor >= HB_OCL_MINVERSION_MINOR);
 149     }
 150     return 0;
 151 }
 152
 153 static hb_opencl_device_t* hb_opencl_device_get(hb_opencl_library_t *opencl,
 154                                                 cl_device_id device_id)
 155 {
 156     if (opencl == NULL || opencl->clGetDeviceInfo == NULL)
 157     {
 158         hb_error("hb_opencl_device_get: OpenCL support not available");
 159         return NULL;
 160     }
 161     else if (device_id == NULL)
 162     {
 163         hb_error("hb_opencl_device_get: invalid device ID");
 164         return NULL;
 165     }
 166
 167     hb_opencl_device_t *device = calloc(1, sizeof(hb_opencl_device_t));
 168     if (device == NULL)
 169     {
 170         hb_error("hb_opencl_device_get: memory allocation failure");
 171         return NULL;
 172     }
 173
 174     cl_int status = CL_SUCCESS;
 175     device->id    = device_id;
 176
 177     status |= opencl->clGetDeviceInfo(device->id, CL_DEVICE_VENDOR,   sizeof(device->vendor),
 178                                       device->vendor,    NULL);
 179     status |= opencl->clGetDeviceInfo(device->id, CL_DEVICE_NAME,     sizeof(device->name),
 180                                        device->name,      NULL);
 181     status |= opencl->clGetDeviceInfo(device->id, CL_DEVICE_VERSION,  sizeof(device->version),
 182                                       device->version,   NULL);
 183     status |= opencl->clGetDeviceInfo(device->id, CL_DEVICE_TYPE,     sizeof(device->type),
 184                                      &device->type,     NULL);
 185     status |= opencl->clGetDeviceInfo(device->id, CL_DEVICE_PLATFORM, sizeof(device->platform),
 186                                      &device->platform, NULL);
 187     status |= opencl->clGetDeviceInfo(device->id, CL_DRIVER_VERSION,  sizeof(device->driver),
 188                                       device->driver,    NULL);
 189     if (status != CL_SUCCESS)
 190     {
 191         free(device);
 192         return NULL;
 193     }
 194
 195     if (!strcmp(device->vendor, "Advanced Micro Devices, Inc.") ||
 196         !strcmp(device->vendor, "AMD"))
 197     {
 198         device->ocl_vendor = HB_OCL_VENDOR_AMD;
 199     }
 200     else if (!strncmp(device->vendor, "NVIDIA", 6 /* strlen("NVIDIA") */))
 201     {
 202         device->ocl_vendor = HB_OCL_VENDOR_NVIDIA;
 203     }
 204     else if (!strncmp(device->vendor, "Intel", 5 /* strlen("Intel") */))
 205     {
 206         device->ocl_vendor = HB_OCL_VENDOR_INTEL;
 207     }
 208     else
 209     {
 210         device->ocl_vendor = HB_OCL_VENDOR_OTHER;
 211     }
 212
 213     return device;
 214 }
 215
 216 static void hb_opencl_devices_list_close(hb_list_t **_list)
 217 {
 218     if (_list != NULL)
 219     {
 220         hb_list_t *list = *_list;
 221         hb_opencl_device_t *device;
 222         while (list != NULL && hb_list_count(list) > 0)
 223         {
 224             if ((device = hb_list_item(list, 0)) != NULL)
 225             {
 226                 hb_list_rem(list, device);
 227                 free(device);
 228             }
 229         }
 230     }
 231     hb_list_close(_list);
 232 }
 233
 234 static hb_list_t* hb_opencl_devices_list_get(hb_opencl_library_t *opencl,
 235                                              cl_device_type device_type)
 236 {
 237     if (opencl                   == NULL ||
 238         opencl->library          == NULL ||
 239         opencl->clGetDeviceIDs   == NULL ||
 240         opencl->clGetDeviceInfo  == NULL ||
 241         opencl->clGetPlatformIDs == NULL)
 242     {
 243         hb_error("hb_opencl_devices_list_get: OpenCL support not available");
 244         return NULL;
 245     }
 246
 247     hb_list_t *list = hb_list_init();
 248     if (list == NULL)
 249     {
 250         hb_error("hb_opencl_devices_list_get: memory allocation failure");
 251         return NULL;
 252     }
 253
 254     cl_device_id *device_ids = NULL;
 255     hb_opencl_device_t *device = NULL;
 256     cl_platform_id *platform_ids = NULL;
 257     cl_uint i, j, num_platforms, num_devices;
 258
 259     if (opencl->clGetPlatformIDs(0, NULL, &num_platforms) != CL_SUCCESS || !num_platforms)
 260     {
 261         goto fail;
 262     }
 263     if ((platform_ids = malloc(sizeof(cl_platform_id) * num_platforms)) == NULL)
 264     {
 265         hb_error("hb_opencl_devices_list_get: memory allocation failure");
 266         goto fail;
 267     }
 268     if (opencl->clGetPlatformIDs(num_platforms, platform_ids, NULL) != CL_SUCCESS)
 269     {
 270         goto fail;
 271     }
 272     for (i = 0; i < num_platforms; i++)
 273     {
 274         if (opencl->clGetDeviceIDs(platform_ids[i], device_type, 0, NULL, &num_devices) != CL_SUCCESS || !num_devices)
 275         {
 276             // non-fatal
 277             continue;
 278         }
 279         if ((device_ids = malloc(sizeof(cl_device_id) * num_devices)) == NULL)
 280         {
 281             hb_error("hb_opencl_devices_list_get: memory allocation failure");
 282             goto fail;
 283         }
 284         if (opencl->clGetDeviceIDs(platform_ids[i], device_type, num_devices, device_ids, NULL) != CL_SUCCESS)
 285         {
 286             // non-fatal
 287             continue;
 288         }
 289         for (j = 0; j < num_devices; j++)
 290         {
 291             if ((device = hb_opencl_device_get(opencl, device_ids[j])) != NULL)
 292             {
 293                 hb_list_add(list, device);
 294             }
 295         }
 296     }
 297
 298     goto end;
 299
 300 fail:
 301     hb_opencl_devices_list_close(&list);
 302
 303 end:
 304     free(platform_ids);
 305     free(device_ids);
 306     return list;
 307 }
 308
 309 int hb_opencl_available()
 310 {
 311     static int opencl_available = -1;
 312     if (opencl_available >= 0)
 313     {
 314         return opencl_available;
 315     }
 316     opencl_available = 0;
 317
 318     /*
 319      * Check whether we can load the OpenCL library, then check devices and make
 320      * sure we support running OpenCL code on at least one of them.
 321      */
 322     hb_opencl_library_t *opencl;
 323     if ((opencl = hb_opencl_library_init()) != NULL)
 324     {
 325         int i;
 326         hb_list_t *device_list;
 327         hb_opencl_device_t *device;
 328         if ((device_list = hb_opencl_devices_list_get(opencl, CL_DEVICE_TYPE_ALL)) != NULL)
 329         {
 330             for (i = 0; i < hb_list_count(device_list); i++)
 331             {
 332                 if ((device = hb_list_item(device_list, i)) != NULL &&
 333                     (hb_opencl_device_is_supported(device)))
 334                 {
 335                     opencl_available = 1;
 336                     break;
 337                 }
 338             }
 339             hb_opencl_devices_list_close(&device_list);
 340         }
 341         hb_opencl_library_close(&opencl);
 342     }
 343     return opencl_available;
 344 }
 345
 346 void hb_opencl_info_print()
 347 {
 348     /*
 349      * Note: this function should not log any warnings or errors.
 350      * Its only purpose is to list OpenCL-capable devices, so let's initialize
 351      * only what we absolutely need here, rather than calling library_open().
 352      */
 353     hb_opencl_library_t ocl, *opencl = &ocl;
 354     if ((opencl->library          = (void*)HB_OCL_DLOPEN)                                     == NULL ||
 355         (opencl->clGetDeviceIDs   = (void*)HB_OCL_DLSYM(opencl->library, "clGetDeviceIDs"  )) == NULL ||
 356         (opencl->clGetDeviceInfo  = (void*)HB_OCL_DLSYM(opencl->library, "clGetDeviceInfo" )) == NULL ||
 357         (opencl->clGetPlatformIDs = (void*)HB_OCL_DLSYM(opencl->library, "clGetPlatformIDs")) == NULL)
 358     {
 359         // zero or insufficient OpenCL support
 360         hb_log("OpenCL: library not available");
 361         goto end;
 362     }
 363
 364     int i, idx;
 365     hb_list_t *device_list;
 366     hb_opencl_device_t *device;
 367     if ((device_list = hb_opencl_devices_list_get(opencl, CL_DEVICE_TYPE_ALL)) != NULL)
 368     {
 369         for (i = 0, idx = 1; i < hb_list_count(device_list); i++)
 370         {
 371             if ((device = hb_list_item(device_list, i)) != NULL)
 372             {
 373                 // don't list CPU devices (always unsupported)
 374                 if (!(device->type & CL_DEVICE_TYPE_CPU))
 375                 {
 376                     hb_log("OpenCL device #%d: %s %s", idx++, device->vendor, device->name);
 377                     hb_log(" - OpenCL version: %s", device->version + 7 /* strlen("OpenCL ") */);
 378                     hb_log(" - driver version: %s", device->driver);
 379                     hb_log(" - device type:    %s%s",
 380                            device->type & CL_DEVICE_TYPE_CPU         ? "CPU"         :
 381                            device->type & CL_DEVICE_TYPE_GPU         ? "GPU"         :
 382                            device->type & CL_DEVICE_TYPE_CUSTOM      ? "Custom"      :
 383                            device->type & CL_DEVICE_TYPE_ACCELERATOR ? "Accelerator" : "Unknown",
 384                            device->type & CL_DEVICE_TYPE_DEFAULT     ? " (default)"  : "");
 385                     hb_log(" - supported:      %s",
 386                            hb_opencl_device_is_supported(device) ? "YES" : "no");
 387                 }
 388             }
 389         }
 390         hb_opencl_devices_list_close(&device_list);
 391     }
 392
 393 end:
 394     /*
 395      * Close only the initialized part
 396      */
 397     if (opencl->library != NULL)
 398     {
 399         HB_OCL_DLCLOSE(opencl->library);
 400     }
 401 }