gdb/testsuite/lib/cl_util.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2010-2019 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18    Contributed by Ken Werner <ken.werner@de.ibm.com>  */
  19
  20 /* Utility macros and functions for OpenCL applications.  */
  21
  22 #include "cl_util.h"
  23
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <sys/stat.h>
  27 #include <string.h>
  28
  29 const char *get_clerror_string (int errcode)
  30 {
  31   switch (errcode)
  32     {
  33     case CL_SUCCESS:
  34       return "CL_SUCCESS";
  35     case CL_DEVICE_NOT_FOUND:
  36       return "CL_DEVICE_NOT_FOUND";
  37     case CL_DEVICE_NOT_AVAILABLE:
  38       return "CL_DEVICE_NOT_AVAILABLE";
  39     case CL_COMPILER_NOT_AVAILABLE:
  40       return "CL_COMPILER_NOT_AVAILABLE";
  41     case CL_MEM_OBJECT_ALLOCATION_FAILURE:
  42       return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
  43     case CL_OUT_OF_RESOURCES:
  44       return "CL_OUT_OF_RESOURCES";
  45     case CL_OUT_OF_HOST_MEMORY:
  46       return "CL_OUT_OF_HOST_MEMORY";
  47     case CL_PROFILING_INFO_NOT_AVAILABLE:
  48       return "CL_PROFILING_INFO_NOT_AVAILABLE";
  49     case CL_MEM_COPY_OVERLAP:
  50       return "CL_MEM_COPY_OVERLAP";
  51     case CL_IMAGE_FORMAT_MISMATCH:
  52       return "CL_IMAGE_FORMAT_MISMATCH";
  53     case CL_IMAGE_FORMAT_NOT_SUPPORTED:
  54       return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
  55     case CL_BUILD_PROGRAM_FAILURE:
  56       return "CL_BUILD_PROGRAM_FAILURE";
  57     case CL_MAP_FAILURE:
  58       return "CL_MAP_FAILURE";
  59     case CL_INVALID_VALUE:
  60       return "CL_INVALID_VALUE";
  61     case CL_INVALID_DEVICE_TYPE:
  62       return "CL_INVALID_DEVICE_TYPE";
  63     case CL_INVALID_PLATFORM:
  64       return "CL_INVALID_PLATFORM";
  65     case CL_INVALID_DEVICE:
  66       return "CL_INVALID_DEVICE";
  67     case CL_INVALID_CONTEXT:
  68       return "CL_INVALID_CONTEXT";
  69     case CL_INVALID_QUEUE_PROPERTIES:
  70       return "CL_INVALID_QUEUE_PROPERTIES";
  71     case CL_INVALID_COMMAND_QUEUE:
  72       return "CL_INVALID_COMMAND_QUEUE";
  73     case CL_INVALID_HOST_PTR:
  74       return "CL_INVALID_HOST_PTR";
  75     case CL_INVALID_MEM_OBJECT:
  76       return "CL_INVALID_MEM_OBJECT";
  77     case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
  78       return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
  79     case CL_INVALID_IMAGE_SIZE:
  80       return "CL_INVALID_IMAGE_SIZE";
  81     case CL_INVALID_SAMPLER:
  82       return "CL_INVALID_SAMPLER";
  83     case CL_INVALID_BINARY:
  84       return "CL_INVALID_BINARY";
  85     case CL_INVALID_BUILD_OPTIONS:
  86       return "CL_INVALID_BUILD_OPTIONS";
  87     case CL_INVALID_PROGRAM:
  88       return "CL_INVALID_PROGRAM";
  89     case CL_INVALID_PROGRAM_EXECUTABLE:
  90       return "CL_INVALID_PROGRAM_EXECUTABLE";
  91     case CL_INVALID_KERNEL_NAME:
  92       return "CL_INVALID_KERNEL_NAME";
  93     case CL_INVALID_KERNEL_DEFINITION:
  94       return "CL_INVALID_KERNEL_DEFINITION";
  95     case CL_INVALID_KERNEL:
  96       return "CL_INVALID_KERNEL";
  97     case CL_INVALID_ARG_INDEX:
  98       return "CL_INVALID_ARG_INDEX";
  99     case CL_INVALID_ARG_VALUE:
 100       return "CL_INVALID_ARG_VALUE";
 101     case CL_INVALID_ARG_SIZE:
 102       return "CL_INVALID_ARG_SIZE";
 103     case CL_INVALID_KERNEL_ARGS:
 104       return "CL_INVALID_KERNEL_ARGS";
 105     case CL_INVALID_WORK_DIMENSION:
 106       return "CL_INVALID_WORK_DIMENSION";
 107     case CL_INVALID_WORK_GROUP_SIZE:
 108       return "CL_INVALID_WORK_GROUP_SIZE";
 109     case CL_INVALID_WORK_ITEM_SIZE:
 110       return "CL_INVALID_WORK_ITEM_SIZE";
 111     case CL_INVALID_GLOBAL_OFFSET:
 112       return "CL_INVALID_GLOBAL_OFFSET";
 113     case CL_INVALID_EVENT_WAIT_LIST:
 114       return "CL_INVALID_EVENT_WAIT_LIST";
 115     case CL_INVALID_EVENT:
 116       return "CL_INVALID_EVENT";
 117     case CL_INVALID_OPERATION:
 118       return "CL_INVALID_OPERATION";
 119     case CL_INVALID_GL_OBJECT:
 120       return "CL_INVALID_GL_OBJECT";
 121     case CL_INVALID_BUFFER_SIZE:
 122       return "CL_INVALID_BUFFER_SIZE";
 123     case CL_INVALID_MIP_LEVEL:
 124       return "CL_INVALID_MIP_LEVEL";
 125 #ifndef CL_PLATFORM_NVIDIA
 126     case CL_INVALID_GLOBAL_WORK_SIZE:
 127       return "CL_INVALID_GLOBAL_WORK_SIZE";
 128 #endif
 129     default:
 130       return "Unknown";
 131     };
 132 }
 133
 134
 135 void print_clinfo ()
 136 {
 137   char *s = NULL;
 138   size_t len;
 139   unsigned i, j;
 140   cl_uint platform_count;
 141   cl_platform_id *platforms;
 142
 143   /* Determine number of OpenCL Platforms available.  */
 144   clGetPlatformIDs (0, NULL, &platform_count);
 145   printf ("number of OpenCL Platforms available:\t%d\n", platform_count);
 146   /* Get platforms.  */
 147   platforms
 148     = (cl_platform_id*) malloc (sizeof (cl_platform_id) * platform_count);
 149   if (platforms == NULL)
 150     {
 151       fprintf (stderr, "malloc failed\n");
 152       exit (EXIT_FAILURE);
 153     }
 154   clGetPlatformIDs (platform_count, platforms, NULL);
 155
 156   /* Querying platforms.  */
 157   for (i = 0; i < platform_count; i++)
 158     {
 159       cl_device_id *devices;
 160       cl_uint device_count;
 161       cl_device_id default_dev;
 162       printf (" OpenCL Platform:                       %d\n", i);
 163
 164 #define PRINT_PF_INFO(PARM)\
 165       clGetPlatformInfo (platforms[i], PARM, 0, NULL, &len); \
 166       s = realloc (s, len); \
 167       clGetPlatformInfo (platforms[i], PARM, len, s, NULL); \
 168       printf ("  %-36s%s\n", #PARM ":", s);
 169
 170       PRINT_PF_INFO (CL_PLATFORM_PROFILE)
 171       PRINT_PF_INFO (CL_PLATFORM_VERSION)
 172       PRINT_PF_INFO (CL_PLATFORM_NAME)
 173       PRINT_PF_INFO (CL_PLATFORM_VENDOR)
 174       PRINT_PF_INFO (CL_PLATFORM_EXTENSIONS)
 175 #undef PRINT_PF_INFO
 176
 177       clGetDeviceIDs (platforms[i], CL_DEVICE_TYPE_DEFAULT, 1, &default_dev,
 178                       NULL);
 179       clGetDeviceInfo (default_dev, CL_DEVICE_NAME, 0, NULL, &len);
 180       s = realloc (s, len);
 181       clGetDeviceInfo (default_dev, CL_DEVICE_NAME, len, s, NULL);
 182       printf ("  CL_DEVICE_TYPE_DEFAULT:             %s\n", s);
 183
 184       /* Determine number of devices.  */
 185       clGetDeviceIDs (platforms[i], CL_DEVICE_TYPE_ALL, 0, NULL, &device_count);
 186       printf ("\n  number of OpenCL Devices available:   %d\n", device_count);
 187       /* Get devices.  */
 188       devices = (cl_device_id*) malloc (sizeof (cl_device_id) * device_count);
 189       if (devices == NULL)
 190         {
 191           fprintf (stderr, "malloc failed\n");
 192           exit (EXIT_FAILURE);
 193         }
 194       clGetDeviceIDs (platforms[i], CL_DEVICE_TYPE_ALL, device_count, devices,
 195                       NULL);
 196
 197       /* Querying devices.  */
 198       for (j = 0; j < device_count; j++)
 199         {
 200           cl_device_type dtype;
 201           cl_device_mem_cache_type mctype;
 202           cl_device_local_mem_type mtype;
 203           cl_device_fp_config fpcfg;
 204           cl_device_exec_capabilities xcap;
 205           cl_command_queue_properties qprops;
 206           cl_bool clbool;
 207           cl_uint cluint;
 208           cl_ulong clulong;
 209           size_t sizet;
 210           size_t workitem_size[3];
 211           printf ("   OpenCL Device:                       %d\n", j);
 212
 213 #define PRINT_DEV_INFO(PARM)\
 214           clGetDeviceInfo (devices[j], PARM, 0, NULL, &len); \
 215           s = realloc (s, len); \
 216           clGetDeviceInfo (devices[j], PARM, len, s, NULL); \
 217           printf ("    %-41s%s\n", #PARM ":", s);
 218
 219           PRINT_DEV_INFO (CL_DEVICE_NAME)
 220           PRINT_DEV_INFO (CL_DRIVER_VERSION)
 221           PRINT_DEV_INFO (CL_DEVICE_VENDOR)
 222           clGetDeviceInfo (devices[j], CL_DEVICE_VENDOR_ID, sizeof (cluint),
 223                            &cluint, NULL);
 224           printf ("    CL_DEVICE_VENDOR_ID:                     %d\n", cluint);
 225
 226           clGetDeviceInfo (devices[j], CL_DEVICE_TYPE, sizeof (dtype), &dtype, NULL);
 227           if (dtype & CL_DEVICE_TYPE_CPU)
 228             printf ("    CL_DEVICE_TYPE:                          CL_DEVICE_TYPE_CPU\n");
 229           if (dtype & CL_DEVICE_TYPE_GPU)
 230             printf ("    CL_DEVICE_TYPE:                          CL_DEVICE_TYPE_GPU\n");
 231           if (dtype & CL_DEVICE_TYPE_ACCELERATOR)
 232             printf ("    CL_DEVICE_TYPE:                          CL_DEVICE_TYPE_ACCELERATOR\n");
 233           if (dtype & CL_DEVICE_TYPE_DEFAULT)
 234             printf ("    CL_DEVICE_TYPE:                          CL_DEVICE_TYPE_DEFAULT\n");
 235
 236           clGetDeviceInfo (devices[j], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (cluint), &cluint, NULL);
 237           printf ("    CL_DEVICE_MAX_CLOCK_FREQUENCY:           %d\n", cluint);
 238
 239           PRINT_DEV_INFO (CL_DEVICE_PROFILE)
 240           PRINT_DEV_INFO (CL_DEVICE_EXTENSIONS)
 241
 242           clGetDeviceInfo (devices[j], CL_DEVICE_AVAILABLE, sizeof (clbool), &clbool, NULL);
 243           if (clbool == CL_TRUE)
 244             printf ("    CL_DEVICE_AVAILABLE:                     CL_TRUE\n");
 245           else
 246             printf ("    CL_DEVICE_AVAILABLE:                     CL_FALSE\n");
 247           clGetDeviceInfo (devices[j], CL_DEVICE_ENDIAN_LITTLE, sizeof (clbool), &clbool, NULL);
 248           if (clbool == CL_TRUE)
 249             printf ("    CL_DEVICE_ENDIAN_LITTLE:                 CL_TRUE\n");
 250           else
 251             printf ("    CL_DEVICE_ENDIAN_LITTLE:                 CL_FALSE\n");
 252
 253           clGetDeviceInfo (devices[j], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (cluint), &cluint, NULL);
 254           printf ("    CL_DEVICE_MAX_COMPUTE_UNITS:             %d\n", cluint);
 255           clGetDeviceInfo (devices[j], CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (sizet), &sizet, NULL);
 256           printf ("    CL_DEVICE_MAX_WORK_GROUP_SIZE:           %d\n", sizet);
 257           clGetDeviceInfo (devices[j], CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof (cluint), &cluint, NULL);
 258           printf ("    CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS:      %d\n", cluint);
 259           clGetDeviceInfo (devices[j], CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof (workitem_size), &workitem_size, NULL);
 260           printf ("    CL_DEVICE_MAX_WORK_ITEM_SIZES:           %d / %d / %d\n", workitem_size[0], workitem_size[1], workitem_size[2]);
 261
 262           clGetDeviceInfo (devices[j], CL_DEVICE_ADDRESS_BITS, sizeof (cluint), &cluint, NULL);
 263           printf ("    CL_DEVICE_ADDRESS_BITS:                  %d\n", cluint);
 264
 265           clGetDeviceInfo (devices[j], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (clulong), &clulong, NULL);
 266           printf ("    CL_DEVICE_MAX_MEM_ALLOC_SIZE:            %llu\n", clulong);
 267           clGetDeviceInfo (devices[j], CL_DEVICE_MEM_BASE_ADDR_ALIGN, sizeof (cluint), &cluint, NULL);
 268           printf ("    CL_DEVICE_MEM_BASE_ADDR_ALIGN:           %d\n", cluint);
 269           clGetDeviceInfo(devices[j], CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, sizeof (cluint), &cluint, NULL);
 270           printf ("    CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE:      %d\n", cluint);
 271           clGetDeviceInfo(devices[j], CL_DEVICE_MAX_PARAMETER_SIZE, sizeof (sizet), &sizet, NULL);
 272           printf ("    CL_DEVICE_MAX_PARAMETER_SIZE:            %d\n", sizet);
 273           clGetDeviceInfo(devices[j], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (clulong), &clulong, NULL);
 274           printf ("    CL_DEVICE_GLOBAL_MEM_SIZE:               %llu\n", clulong);
 275
 276           clGetDeviceInfo (devices[j], CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, sizeof (mctype), &mctype, NULL);
 277           if (mctype & CL_NONE)
 278             printf ("    CL_DEVICE_GLOBAL_MEM_CACHE_TYPE:         CL_NONE\n");
 279           if (mctype & CL_READ_ONLY_CACHE)
 280             printf ("    CL_DEVICE_GLOBAL_MEM_CACHE_TYPE:         CL_READ_ONLY_CACHE\n");
 281           if (mctype & CL_READ_WRITE_CACHE)
 282             printf ("    CL_DEVICE_GLOBAL_MEM_CACHE_TYPE:         CL_READ_WRITE_CACHE\n");
 283
 284           clGetDeviceInfo (devices[j], CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, sizeof (clulong), &clulong, NULL);
 285           printf ("    CL_DEVICE_GLOBAL_MEM_CACHE_SIZE:         %llu\n", clulong);
 286           clGetDeviceInfo (devices[j], CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, sizeof (cluint), &cluint, NULL);
 287           printf ("    CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE:     %d\n", cluint);
 288
 289           clGetDeviceInfo (devices[j], CL_DEVICE_LOCAL_MEM_TYPE, sizeof (mtype), &mtype, NULL);
 290           if (mtype & CL_LOCAL)
 291             printf ("    CL_DEVICE_LOCAL_MEM_TYPE:                CL_LOCAL\n");
 292           if (mtype & CL_GLOBAL)
 293             printf ("    CL_DEVICE_LOCAL_MEM_TYPE:                CL_GLOBAL\n");
 294
 295           clGetDeviceInfo (devices[j], CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, sizeof (cluint), &cluint, NULL);
 296           printf ("    CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE:      %d\n", cluint);
 297           clGetDeviceInfo (devices[j], CL_DEVICE_MEM_BASE_ADDR_ALIGN, sizeof (cluint), &cluint, NULL);
 298           printf ("    CL_DEVICE_MEM_BASE_ADDR_ALIGN:           %d\n", cluint);
 299           clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, sizeof (cluint), &cluint, NULL);
 300           printf ("    CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR:   %d\n", cluint);
 301           clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, sizeof (cluint), &cluint, NULL);
 302           printf ("    CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT:  %d\n", cluint);
 303           clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (cluint), &cluint, NULL);
 304           printf ("    CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT:    %d\n", cluint);
 305           clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (cluint), &cluint, NULL);
 306           printf ("    CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG:   %d\n", cluint);
 307           clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, sizeof (cluint), &cluint, NULL);
 308           printf ("    CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT:  %d\n", cluint);
 309           clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, sizeof (cluint), &cluint, NULL);
 310           printf ("    CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: %d\n", cluint);
 311
 312           clGetDeviceInfo (devices[j], CL_DEVICE_SINGLE_FP_CONFIG, sizeof (fpcfg), &fpcfg, NULL);
 313           if (fpcfg & CL_FP_DENORM)
 314             printf ("    CL_DEVICE_SINGLE_FP_CONFIG:              CL_FP_DENORM\n");
 315           if (fpcfg & CL_FP_INF_NAN)
 316             printf ("    CL_DEVICE_SINGLE_FP_CONFIG:              CL_FP_INF_NAN\n");
 317           if (fpcfg & CL_FP_ROUND_TO_NEAREST)
 318             printf ("    CL_DEVICE_SINGLE_FP_CONFIG:              CL_FP_ROUND_TO_NEAREST\n");
 319           if (fpcfg & CL_FP_ROUND_TO_ZERO)
 320             printf ("    CL_DEVICE_SINGLE_FP_CONFIG:              CL_FP_ROUND_TO_ZERO\n");
 321
 322           clGetDeviceInfo (devices[j], CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (xcap), &xcap, NULL);
 323           if (xcap & CL_EXEC_KERNEL )
 324             printf ("    CL_DEVICE_EXECUTION_CAPABILITIES:        CL_EXEC_KERNEL\n");
 325           if (xcap & CL_EXEC_NATIVE_KERNEL)
 326             printf ("    CL_DEVICE_EXECUTION_CAPABILITIES:        CL_EXEC_NATIVE_KERNEL\n");
 327
 328           clGetDeviceInfo (devices[j], CL_DEVICE_QUEUE_PROPERTIES, sizeof (qprops), &qprops, NULL);
 329           if (qprops & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)
 330             printf ("    CL_DEVICE_QUEUE_PROPERTIES:              CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE\n");
 331           if (qprops & CL_QUEUE_PROFILING_ENABLE)
 332             printf ("    CL_DEVICE_QUEUE_PROPERTIES:              CL_QUEUE_PROFILING_ENABLE\n");
 333
 334           clGetDeviceInfo (devices[j], CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof (sizet), &sizet, NULL);
 335           printf ("    CL_DEVICE_PROFILING_TIMER_RESOLUTION:    %d\n", sizet);
 336
 337           clGetDeviceInfo (devices[j], CL_DEVICE_COMPILER_AVAILABLE, sizeof (clbool), &clbool, NULL);
 338           if (clbool == CL_TRUE)
 339             printf ("    CL_DEVICE_COMPILER_AVAILABLE:            CL_TRUE\n");
 340           else
 341             printf ("    CL_DEVICE_COMPILER_AVAILABLE:            CL_FALSE\n");
 342           clGetDeviceInfo (devices[j], CL_DEVICE_ERROR_CORRECTION_SUPPORT, sizeof (clbool), &clbool, NULL);
 343           if (clbool == CL_TRUE)
 344             printf ("    CL_DEVICE_ERROR_CORRECTION_SUPPORT:      CL_TRUE\n");
 345           else
 346             printf ("    CL_DEVICE_ERROR_CORRECTION_SUPPORT:      CL_FALSE\n");
 347
 348           clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE_SUPPORT, sizeof (clbool), &clbool, NULL);
 349           if (clbool == CL_FALSE)
 350             {
 351               printf ("    CL_DEVICE_IMAGE_SUPPORT:                 CL_FALSE\n");
 352             }
 353           else
 354             {
 355               printf ("    CL_DEVICE_IMAGE_SUPPORT:                 CL_TRUE\n");
 356               clGetDeviceInfo (devices[j], CL_DEVICE_MAX_SAMPLERS, sizeof (cluint), &cluint, NULL);
 357               printf ("    CL_DEVICE_MAX_SAMPLERS:                  %d\n", cluint);
 358               clGetDeviceInfo (devices[j], CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof (cluint), &cluint, NULL);
 359               printf ("    CL_DEVICE_MAX_READ_IMAGE_ARGS:           %d\n", cluint);
 360               clGetDeviceInfo (devices[j], CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof (cluint), &cluint, NULL);
 361               printf ("    CL_DEVICE_MAX_WRITE_IMAGE_ARGS:          %d\n", cluint);
 362               clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof (sizet), &sizet, NULL);
 363               printf ("    CL_DEVICE_IMAGE2D_MAX_WIDTH:             %d\n", sizet);
 364               clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof (sizet), &sizet, NULL);
 365               printf ("    CL_DEVICE_IMAGE2D_MAX_HEIGHT:            %d\n", sizet);
 366               clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof (sizet), &sizet, NULL);
 367               printf ("    CL_DEVICE_IMAGE3D_MAX_WIDTH:             %d\n", sizet);
 368               clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof (sizet), &sizet, NULL);
 369               printf ("    CL_DEVICE_IMAGE3D_MAX_HEIGHT:            %d\n", sizet);
 370               clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof (sizet), &sizet, NULL);
 371               printf ("    CL_DEVICE_IMAGE3D_MAX_DEPTH:             %d\n", sizet);
 372             }
 373 #undef PRINT_DEV_INFO
 374         } /* devices */
 375       free (devices);
 376     } /* platforms */
 377   free (s);
 378   free (platforms);
 379 }
 380
 381
 382 const char *
 383 read_file (const char * const filename, size_t *size)
 384 {
 385   char *buf = NULL;
 386   FILE *fd;
 387   struct stat st;
 388   if (stat (filename, &st) == -1)
 389     {
 390       /* Check if the file exists.  */
 391       if (errno == ENOENT)
 392         return buf;
 393       perror ("stat failed");
 394       exit (EXIT_FAILURE);
 395     }
 396   buf = (char *) malloc (st.st_size);
 397   if (buf == NULL)
 398     {
 399       fprintf (stderr, "malloc failed\n");
 400       exit (EXIT_FAILURE);
 401     }
 402   fd = fopen (filename, "r");
 403   if (fd == NULL)
 404     {
 405       perror ("fopen failed");
 406       free (buf);
 407       exit (EXIT_FAILURE);
 408     }
 409   if (fread (buf, st.st_size, 1, fd) != 1)
 410     {
 411       fprintf (stderr, "fread failed\n");
 412       free (buf);
 413       fclose (fd);
 414       exit (EXIT_FAILURE);
 415     }
 416   fclose (fd);
 417   *size = st.st_size;
 418   return buf;
 419 }
 420
 421
 422 void
 423 save_program_binaries (cl_program program)
 424 {
 425   cl_device_id *devices;
 426   cl_uint device_count;
 427   size_t *sizes;
 428   unsigned char **binaries;
 429   unsigned i, j;
 430
 431   /* Query the amount of devices for the given program.  */
 432   CHK (clGetProgramInfo (program, CL_PROGRAM_NUM_DEVICES, sizeof (cl_uint),
 433                         &device_count, NULL));
 434
 435   /* Get the sizes of the binaries.  */
 436   sizes = (size_t*) malloc (sizeof (size_t) * device_count);
 437   if (sizes == NULL)
 438     {
 439       fprintf (stderr, "malloc failed\n");
 440       exit (EXIT_FAILURE);
 441     }
 442   CHK (clGetProgramInfo (program, CL_PROGRAM_BINARY_SIZES, sizeof (sizes),
 443                          sizes, NULL));
 444
 445   /* Get the binaries.  */
 446   binaries
 447     = (unsigned char **) malloc (sizeof (unsigned char *) * device_count);
 448   if (binaries == NULL)
 449     {
 450       fprintf (stderr, "malloc failed\n");
 451       exit (EXIT_FAILURE);
 452     }
 453   for (i = 0; i < device_count; i++)
 454     {
 455       binaries[i] = (unsigned char *) malloc (sizes[i]);
 456       if (binaries[i] == NULL)
 457         {
 458           fprintf (stderr, "malloc failed\n");
 459           exit (EXIT_FAILURE);
 460         }
 461     }
 462   CHK (clGetProgramInfo (program, CL_PROGRAM_BINARIES, sizeof (binaries),
 463                          binaries, NULL));
 464
 465   /* Get the devices for the given program to extract the file names.  */
 466   devices = (cl_device_id*) malloc (sizeof (cl_device_id) * device_count);
 467   if (devices == NULL)
 468     {
 469       fprintf (stderr, "malloc failed\n");
 470       exit (EXIT_FAILURE);
 471     }
 472   CHK (clGetProgramInfo (program, CL_PROGRAM_DEVICES, sizeof (devices),
 473                          devices, NULL));
 474
 475   for (i = 0; i < device_count; i++)
 476     {
 477       FILE *fd;
 478       char *dev_name = NULL;
 479       size_t len;
 480       CHK (clGetDeviceInfo (devices[i], CL_DEVICE_NAME, 0, NULL, &len));
 481       dev_name = malloc (len);
 482       if (dev_name == NULL)
 483         {
 484           fprintf (stderr, "malloc failed\n");
 485           exit (EXIT_FAILURE);
 486         }
 487       CHK (clGetDeviceInfo (devices[i], CL_DEVICE_NAME, len, dev_name, NULL));
 488       /* Convert spaces to underscores.  */
 489       for (j = 0; j < strlen (dev_name); j++)
 490         {
 491           if (dev_name[j] == ' ')
 492             dev_name[j] = '_';
 493         }
 494
 495       /*  Save the binaries.  */
 496       printf ("saving program binary for device: %s\n", dev_name);
 497       /* Save binaries[i].  */
 498       fd = fopen (dev_name, "w");
 499       if (fd == NULL)
 500         {
 501           perror ("fopen failed");
 502           exit (EXIT_FAILURE);
 503         }
 504       if (fwrite (binaries[i], sizes[i], 1, fd) != 1)
 505         {
 506           fprintf (stderr, "fwrite failed\n");
 507           for (j = i; j < device_count; j++)
 508             free (binaries[j]);
 509           fclose (fd);
 510           exit (EXIT_FAILURE);
 511         }
 512       fclose (fd);
 513       free (binaries[i]);
 514       free (dev_name);
 515       free (sizes);
 516     }
 517   free (devices);
 518   free (binaries);
 519 }