Medical Imaging Interaction Toolkit  2016.11.0
Medical Imaging Interaction Toolkit
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
mitkOclUtils.cpp
Go to the documentation of this file.
1 /*===================================================================
2 
3 The Medical Imaging Interaction Toolkit (MITK)
4 
5 Copyright (c) German Cancer Research Center,
6 Division of Medical and Biological Informatics.
7 All rights reserved.
8 
9 This software is distributed WITHOUT ANY WARRANTY; without
10 even the implied warranty of MERCHANTABILITY or FITNESS FOR
11 A PARTICULAR PURPOSE.
12 
13 See LICENSE.txt or http://www.mitk.org for details.
14 
15 ===================================================================*/
16 
17 #include "mitkOclUtils.h"
18 #include "mitkLogMacros.h"
19 #include <cstdio>
20 #include <cstring>
21 
22 
23 unsigned int iDivUp(unsigned int dividend, unsigned int divisor){
24  return (dividend % divisor == 0) ? (dividend / divisor) : (dividend / divisor + 1);
25 }
26 
27 cl_int oclGetPlatformID(cl_platform_id* selectedPlatform)
28 {
29  cl_uint num_platforms = 0;
30  cl_platform_id* clPlatformIDs;
31  cl_int ciErrNum = 0;
32 
33  ciErrNum = clGetPlatformIDs( 0, NULL, &num_platforms);
34  if ( ciErrNum != CL_SUCCESS)
35  {
36  MITK_ERROR<<" Error " << ciErrNum << " in clGetPlatformIDs() \n";
37  throw std::bad_exception();
38  }
39  else
40  {
41  clPlatformIDs = new cl_platform_id[num_platforms];
42 
43  ciErrNum = clGetPlatformIDs( num_platforms, clPlatformIDs, NULL);
44  if(ciErrNum == CL_SUCCESS)
45  {
46  *selectedPlatform = clPlatformIDs[0];
47  }
48  }
49 
50  return CL_SUCCESS;
51 
52 }
53 
54 void oclPrintMemObjectInfo(cl_mem memobj)
55 {
56  cl_int clErr = 0;
57 
58  MITK_INFO << "Examining cl_mem object: " << memobj
59  << "\n------------------\n";
60 
61  // CL_MEM_TYPE
62  cl_mem_object_type objtype;
63  clErr = clGetMemObjectInfo( memobj, CL_MEM_TYPE, sizeof(cl_mem_object_type),&objtype, NULL);
64  CHECK_OCL_ERR( clErr );
65 
66  switch(objtype)
67  {
68  case CL_MEM_OBJECT_BUFFER:
69  MITK_INFO << "CL_MEM_TYPE \t" << "BUFFER_OBJ" << "\n";
70  break;
71  case CL_MEM_OBJECT_IMAGE2D:
72  MITK_INFO << "CL_MEM_TYPE \t" << "2D IMAGE" << "\n";
73  break;
74  case CL_MEM_OBJECT_IMAGE3D:
75  MITK_INFO << "CL_MEM_TYPE \t" << "3D IMAGE" << "\n";
76  break;
77  default:
78  MITK_INFO << "CL_MEM_TYPE \t" << "[could not resolve]" << "\n";
79  break;
80  }
81 
82  // CL_MEM_FLAGS
83  cl_mem_flags flags;
84  clErr = clGetMemObjectInfo( memobj, CL_MEM_FLAGS, sizeof(cl_mem_flags),&flags, NULL);
85  CHECK_OCL_ERR( clErr );
86 
87  switch(flags)
88  {
89  case CL_MEM_READ_ONLY:
90  MITK_INFO << "CL_MEM_FLAGS \t" << "CL_MEM_READ_ONLY" << "\n";
91  break;
92  case CL_MEM_WRITE_ONLY:
93  MITK_INFO << "CL_MEM_FLAGS \t" << "CL_MEM_WRITE_ONLY" << "\n";
94  break;
95  case CL_MEM_READ_WRITE:
96  MITK_INFO << "CL_MEM_FLAGS \t" << "CL_MEM_READ_WRITE" << "\n";
97  break;
98  default:
99  MITK_INFO << "CL_MEM_FLAGS \t" << "not resolved, " << flags << "\n";
100  break;
101  }
102 
103  // get CL_MEM_SIZE
104  size_t memsize;
105  clErr = clGetMemObjectInfo( memobj, CL_MEM_SIZE, sizeof(memsize),&memsize, NULL);
106  CHECK_OCL_ERR( clErr );
107 
108  MITK_INFO << "CL_MEM_SIZE \t" << memsize << "\n";
109 
110  // get CL_MEM_HOST_PTR
111  float *hostptr;
112  clErr = clGetMemObjectInfo( memobj, CL_MEM_HOST_PTR, sizeof(void*), (void*) &hostptr, NULL);
113  CHECK_OCL_ERR( clErr );
114 
115  MITK_INFO << "CL_MEM_HOST_PTR \t" << hostptr << "\n";
116 
117  // get CL_CONTEXT
118  cl_context gpuctxt;
119  clErr = clGetMemObjectInfo( memobj, CL_MEM_CONTEXT, sizeof(cl_context), &gpuctxt, NULL);
120  CHECK_OCL_ERR( clErr );
121 
122  MITK_INFO << "CL_CONTEXT \t\t" << gpuctxt << "\n";
123 
124  // get CL_MEM_REFERENCE_COUNT
125  cl_uint refs;
126  clErr = clGetMemObjectInfo( memobj, CL_MEM_REFERENCE_COUNT, sizeof(cl_uint), &refs, NULL);
127  CHECK_OCL_ERR(clErr);
128 
129  MITK_INFO << "CL_REF_COUNT \t" << refs << "\n";
130 
131  MITK_INFO << "================== \n" << std::endl;
132 }
133 
134 void oclPrintDeviceInfo(cl_device_id device)
135 {
136  char device_string[1024];
137 
138  clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(device_string), &device_string, NULL);
139  MITK_INFO("ocl.log")<< " Device : " << device_string;
140 
141  // CL_DEVICE_INFO
142  cl_device_type type;
143  clGetDeviceInfo(device, CL_DEVICE_TYPE, sizeof(type), &type, NULL);
144  if( type & CL_DEVICE_TYPE_CPU )
145  MITK_INFO("ocl.log")<<" CL_DEVICE_TYPE: CL_DEVICE_TYPE_CPU";
146  if( type & CL_DEVICE_TYPE_GPU )
147  MITK_INFO("ocl.log")<<" CL_DEVICE_TYPE: CL_DEVICE_TYPE_GPU";
148  if( type & CL_DEVICE_TYPE_ACCELERATOR )
149  MITK_INFO("ocl.log")<<" CL_DEVICE_TYPE: CL_DEVICE_TYPE_ACCELERATOR";
150  if( type & CL_DEVICE_TYPE_DEFAULT )
151  MITK_INFO("ocl.log")<<" CL_DEVICE_TYPE: CL_DEVICE_TYPE_DEFAULT";
152 
153  // CL_DEVICE_MAX_COMPUTE_UNITS
154  cl_uint compute_units;
155  clGetDeviceInfo(device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(compute_units), &compute_units, NULL);
156  MITK_INFO("ocl.log")<<" CL_DEVICE_MAX_COMPUTE_UNITS:" << compute_units;
157 
158  // CL_DEVICE_MAX_WORK_GROUP_SIZE
159  size_t workitem_size[3];
160  clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(workitem_size), &workitem_size, NULL);
161  MITK_INFO("ocl.log")<<" CL_DEVICE_MAX_WORK_ITEM_SIZES:\t"<< workitem_size[0]<< workitem_size[1]<< workitem_size[2];
162 
163  // CL_DEVICE_MAX_WORK_GROUP_SIZE
164  size_t workgroup_size;
165  clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(workgroup_size), &workgroup_size, NULL);
166  MITK_INFO("ocl.log")<<" CL_DEVICE_MAX_WORK_GROUP_SIZE:" << workgroup_size;
167 
168  // CL_DEVICE_MAX_CLOCK_FREQUENCY
169  cl_uint clock_frequency;
170  clGetDeviceInfo(device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(clock_frequency), &clock_frequency, NULL);
171  MITK_INFO("ocl.log")<<" CL_DEVICE_MAX_CLOCK_FREQUENCY:"<< clock_frequency / 1000;
172 
173  // CL_DEVICE_IMAGE_SUPPORT
174  cl_bool image_support;
175  clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof(image_support), &image_support, NULL);
176  MITK_INFO("ocl.log")<<" CL_DEVICE_IMAGE_SUPPORT:\t" << image_support;
177 
178  // CL_DEVICE_GLOBAL_MEM_SIZE
179  cl_ulong mem_size;
180  clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(mem_size), &mem_size, NULL);
181  MITK_INFO("ocl.log")<<" CL_DEVICE_GLOBAL_MEM_SIZE:\t\t"<<(unsigned int)(mem_size / (1024 * 1024))<<"Mbytes";
182 
183  // CL_DEVICE_LOCAL_MEM_SIZE
184  clGetDeviceInfo(device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(mem_size), &mem_size, NULL);
185  MITK_INFO("ocl.log")<<" CL_DEVICE_LOCAL_MEM_SIZE:\t\t"<< (unsigned int)(mem_size / (1024)) <<"KByte\n";
186 
187  //check for image support properties
188  clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof(workgroup_size), &workgroup_size, NULL);
189  MITK_INFO("ocl.log")<<" CL_DEVICE_IMAGE2D_MAX_WIDTH:\t" << workgroup_size;
190 
191  clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof(workgroup_size), &workgroup_size, NULL);
192  MITK_INFO("ocl.log")<<" CL_DEVICE_IMAGE2D_MAX_HEIGHT:\t" << workgroup_size;
193 
194  clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof(workgroup_size), &workgroup_size, NULL);
195  MITK_INFO("ocl.log")<<" CL_DEVICE_IMAGE3D_MAX_WIDTH:\t" << workgroup_size;
196 
197  clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof(workgroup_size), &workgroup_size, NULL);
198  MITK_INFO("ocl.log")<<" CL_DEVICE_IMAGE3D_MAX_HEIGHT:\t" << workgroup_size;
199 
200  clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(workgroup_size), &workgroup_size, NULL);
201  MITK_INFO("ocl.log")<<" CL_DEVICE_IMAGE3D_MAX_DEPTH:\t" << workgroup_size;
202 
203 
204  // CL_DEVICE_QUEUE_PROPERTIES
205  cl_command_queue_properties queue_properties;
206  clGetDeviceInfo(device, CL_DEVICE_QUEUE_PROPERTIES, sizeof(queue_properties), &queue_properties, NULL);
207  if( queue_properties & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE )
208  MITK_INFO("ocl.log")<<" CL_DEVICE_QUEUE_PROPERTIES:\t\t"<< "CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE";
209  if( queue_properties & CL_QUEUE_PROFILING_ENABLE )
210  MITK_INFO("ocl.log")<<" CL_DEVICE_QUEUE_PROPERTIES:\t\t"<< "CL_QUEUE_PROFILING_ENABLE";
211 
212 }
213 
214 std::string GetOclErrorAsString( int _clErr )
215 {
216  std::string returnString("CL_SUCCESS\n");
217 
218  switch(_clErr)
219  {
220  case CL_DEVICE_NOT_FOUND:
221  returnString = "CL_DEVICE_NOT_FOUND\n";
222  break;
223  case CL_DEVICE_NOT_AVAILABLE:
224  returnString = "CL_DEVICE_NOT_AVAILABLE\n";
225  break;
226  /*case CL_DEVICE_COMPILER_NOT_AVAILABLE:
227  returnString = "CL_DEVICE_COMPILER_NOT_AVAILABLE\n";
228  break; */
229  case CL_MEM_OBJECT_ALLOCATION_FAILURE :
230  returnString = "CL_MEM_OBJECT_ALLOCATION_FAILURE\n";
231  break;
232  case CL_OUT_OF_RESOURCES:
233  returnString = "CL_OUT_OF_RESOURCES\n";
234  break;
235  case CL_OUT_OF_HOST_MEMORY:
236  returnString = "CL_OUT_OF_HOST_MEMORY\n";
237  break;
238  case CL_PROFILING_INFO_NOT_AVAILABLE:
239  returnString = "CL_PROFILING_INFO_NOT_AVAILABLE\n";
240  break;
241  case CL_MEM_COPY_OVERLAP:
242  returnString = "CL_MEM_COPY_OVERLAP\n";
243  break;
244  case CL_IMAGE_FORMAT_MISMATCH:
245  returnString = "CL_IMAGE_FORMAT_MISMATCH\n";
246  break;
247  case CL_IMAGE_FORMAT_NOT_SUPPORTED:
248  returnString = "CL_IMAGE_FORMAT_NOT_SUPPORTED\n";
249  break;
250  case CL_BUILD_PROGRAM_FAILURE:
251  returnString = "CL_BUILD_PROGRAM_FAILURE\n";
252  break;
253  case CL_MAP_FAILURE:
254  returnString = "CL_MAP_FAILURE\n";
255  break;
256  case CL_INVALID_VALUE:
257  returnString = "CL_INVALID_VALUE\n";
258  break;
259  case CL_INVALID_DEVICE_TYPE:
260  returnString = "CL_INVALID_DEVICE_TYPE\n";
261  break;
262  case CL_INVALID_PLATFORM:
263  returnString = "CL_INVALID_PLATFORM\n";
264  break;
265  case CL_INVALID_DEVICE:
266  returnString = "CL_INVALID_DEVICE\n";
267  break;
268  case CL_INVALID_CONTEXT :
269  returnString = "CL_INVALID_CONTEXT\n";
270  break;
271  case CL_INVALID_QUEUE_PROPERTIES:
272  returnString = "CL_INVALID_QUEUE_PROPERTIES\n";
273  break;
274  case CL_INVALID_COMMAND_QUEUE:
275  returnString = "CL_INVALID_COMMAND_QUEUE\n";
276  break;
277  case CL_INVALID_HOST_PTR:
278  returnString = "CL_INVALID_HOST_PTR\n";
279  break;
280  case CL_INVALID_MEM_OBJECT:
281  returnString = "CL_INVALID_MEM_OBJECT\n";
282  break;
283  case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
284  returnString = "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR\n";
285  break;
286  case CL_INVALID_IMAGE_SIZE:
287  returnString = "CL_INVALID_IMAGE_SIZE\n";
288  break;
289  case CL_INVALID_SAMPLER :
290  returnString = "CL_INVALID_SAMPLER\n";
291  break;
292  case CL_INVALID_BINARY:
293  returnString = "CL_INVALID_BINARY\n";
294  break;
295  case CL_INVALID_BUILD_OPTIONS:
296  returnString = "CL_INVALID_BUILD_OPTIONS\n";
297  break;
298  case CL_INVALID_PROGRAM:
299  returnString = "CL_INVALID_PROGRAM\n";
300  break;
301  case CL_INVALID_PROGRAM_EXECUTABLE:
302  returnString = "CL_INVALID_PROGRAM_EXECUTABLE\n";
303  break;
304  case CL_INVALID_KERNEL_NAME:
305  returnString = "CL_INVALID_KERNEL_NAME\n";
306  break;
307  case CL_INVALID_KERNEL_DEFINITION:
308  returnString = "CL_INVALID_KERNEL_DEFINITION\n";
309  break;
310  case CL_INVALID_KERNEL :
311  returnString = "CL_INVALID_KERNEL\n";
312  break;
313  case CL_INVALID_ARG_INDEX :
314  returnString = "CL_INVALID_ARG_INDEX\n";
315  break;
316  case CL_INVALID_ARG_VALUE :
317  returnString = "CL_INVALID_ARG_VALUE\n";
318  break;
319  case CL_INVALID_ARG_SIZE :
320  returnString = "CL_INVALID_ARG_SIZE\n";
321  break;
322  case CL_INVALID_KERNEL_ARGS :
323  returnString = "CL_INVALID_KERNEL_ARGS\n";
324  break;
325  case CL_INVALID_WORK_DIMENSION:
326  returnString = "CL_INVALID_WORK_DIMENSION\n";
327  break;
328  case CL_INVALID_WORK_GROUP_SIZE:
329  returnString = "CL_INVALID_WORK_GROUP_SIZE\n";
330  break;
331  case CL_INVALID_WORK_ITEM_SIZE:
332  returnString = "CL_INVALID_WORK_ITEM_SIZE\n";
333  break;
334  case CL_INVALID_GLOBAL_OFFSET:
335  returnString = "CL_INVALID_GLOBAL_OFFSET\n";
336  break;
337  case CL_INVALID_EVENT_WAIT_LIST:
338  returnString = "CL_INVALID_EVENT_WAIT_LIST\n";
339  break;
340  case CL_INVALID_EVENT:
341  returnString = "CL_INVALID_EVENT\n";
342  break;
343  case CL_INVALID_OPERATION:
344  returnString = "CL_INVALID_OPERATION\n";
345  break;
346  case CL_INVALID_GL_OBJECT:
347  returnString = "CL_INVALID_GL_OBJECT\n";
348  break;
349  case CL_INVALID_BUFFER_SIZE :
350  returnString = "CL_INVALID_BUFFER_SIZE\n";
351  break;
352  case CL_INVALID_MIP_LEVEL :
353  returnString = "CL_INVALID_MIP_LEVEL\n";
354  break;
355  default:
356  break;
357  }
358 
359  return returnString;
360 }
361 
362 void GetOclError(int _clErr)
363 {
364  if(_clErr == CL_SUCCESS )
365  MITK_WARN << "Called GetOclErr() with no error value: [CL_SUCCESS]";
366  else
367  MITK_ERROR << GetOclErrorAsString(_clErr);
368 }
369 
370 bool oclCheckError(int _err, const char* filepath, int lineno)
371 {
372  if (_err)
373  {
374  MITK_ERROR<< "OpenCL Error at " << filepath <<":"<< lineno;
375  GetOclError(_err);
376 
377  return 0;
378  }
379 
380  return 1;
381 }
382 
383 void GetSupportedImageFormats(cl_context _context, cl_mem_object_type _type)
384 {
385  const unsigned int entries = 500;
386  cl_image_format* formats = new cl_image_format[entries];
387 
388  cl_uint _written = 0;
389 
390  // OpenCL constant to catch error IDs
391  cl_int ciErr1;
392  // Get list of supported image formats for READ_ONLY access
393  ciErr1 = clGetSupportedImageFormats( _context, CL_MEM_READ_ONLY, _type, entries, formats, &_written);
394  CHECK_OCL_ERR(ciErr1);
395 
396  MITK_INFO << "Supported Image Formats, Image: CL_MEM_READ_ONLY \n";
397 
398  for (unsigned int i=0; i<_written; i++)
399  {
400  MITK_INFO<< "ChannelType: " << GetImageTypeAsString(formats[i].image_channel_data_type) << "| ChannelOrder: "<< GetImageTypeAsString(formats[i].image_channel_order) <<"\n";
401  }
402 
403  _written = 0;
404 
405  // Get list of supported image formats for READ_WRITE access
406  ciErr1 = clGetSupportedImageFormats( _context, CL_MEM_READ_WRITE, _type, entries, formats, &_written);
407  CHECK_OCL_ERR(ciErr1);
408 
409  MITK_INFO << "Supported Image Formats, Image: CL_MEM_READ_WRITE (found: " << _written <<") \n";
410 
411  for (unsigned int i=0; i<_written; i++)
412  {
413  MITK_INFO<< "ChannelType: " << GetImageTypeAsString(formats[i].image_channel_data_type) << "| ChannelOrder: "<< GetImageTypeAsString(formats[i].image_channel_order) <<"\n";
414  }
415 
416  _written = 0;
417 
418  // Get list of supported image formats for WRITE_ONLY access
419  ciErr1 = clGetSupportedImageFormats( _context, CL_MEM_WRITE_ONLY, _type, entries, formats, &_written);
420  CHECK_OCL_ERR(ciErr1);
421 
422  MITK_INFO << "Supported Image Formats, Image: CL_MEM_WRITE_ONLY (found: " << _written <<") \n";
423 
424  for (unsigned int i=0; i<_written; i++)
425  {
426  MITK_INFO<< "ChannelType: " << GetImageTypeAsString(formats[i].image_channel_data_type) << "| ChannelOrder: "<< GetImageTypeAsString(formats[i].image_channel_order) <<"\n";
427  }
428 }
429 
430 std::string GetImageTypeAsString( const unsigned int _in)
431 {
432  switch(_in)
433  {
434  case CL_R:
435  return "CL_R ";
436  break;
437  case CL_A:
438  return "CL_A ";
439  break;
440  case CL_RG:
441  return "CL_RG ";
442  break;
443  case CL_RA:
444  return "CL_RA ";
445  break;
446  case CL_RGB:
447  return "CL_RGB ";
448  break;
449  case CL_RGBA:
450  return "CL_RGBA ";
451  break;
452  case CL_BGRA:
453  return "CL_BGRA ";
454  break;
455  case CL_ARGB:
456  return "CL_ARGB ";
457  break;
458  case CL_INTENSITY:
459  return "CL_INTENSITY ";
460  break;
461  case CL_LUMINANCE:
462  return "CL_LUMINANCE ";
463  break;
464  case CL_SNORM_INT8:
465  return "CL_SNORM_INT8 ";
466  break;
467  case CL_SNORM_INT16:
468  return "CL_SNORM_INT16 ";
469  break;
470  case CL_UNORM_INT8:
471  return "CL_UNORM_INT8 ";
472  break;
473  case CL_UNORM_INT16:
474  return "CL_UNORM_INT16 ";
475  break;
476  case CL_UNORM_SHORT_565:
477  return "CL_UNORM_SHORT_565 ";
478  break;
479  case CL_UNORM_SHORT_555:
480  return "CL_UNORM_SHORT_555 ";
481  break;
482  case CL_UNORM_INT_101010:
483  return "CL_UNORM_INT_101010 ";
484  break;
485  case CL_SIGNED_INT8:
486  return "CL_SIGNED_INT8 ";
487  break;
488  case CL_SIGNED_INT16:
489  return "CL_SIGNED_INT16 ";
490  break;
491  case CL_SIGNED_INT32:
492  return "CL_SIGNED_INT32 ";
493  break;
494  case CL_UNSIGNED_INT8:
495  return "CL_UNSIGNED_INT8 ";
496  break;
497  case CL_UNSIGNED_INT16:
498  return "CL_UNSIGNED_INT16 ";
499  break;
500  case CL_UNSIGNED_INT32:
501  return "CL_UNSIGNED_INT32 ";
502  break;
503  case CL_HALF_FLOAT:
504  return "CL_HALF_FLOAT ";
505  break;
506  case CL_FLOAT:
507  return "CL_FLOAT ";
508  break;
509  default:
510  return "--";
511  break;
512  }
513 }
514 
515 
516 
517 void oclLogBinary(cl_program clProg, cl_device_id clDev)
518 {
519  // Grab the number of devices associated with the program
520  cl_uint num_devices;
521  clGetProgramInfo(clProg, CL_PROGRAM_NUM_DEVICES, sizeof(cl_uint), &num_devices, NULL);
522 
523  // Grab the device ids
524  cl_device_id* devices = (cl_device_id*) malloc(num_devices * sizeof(cl_device_id));
525  clGetProgramInfo(clProg, CL_PROGRAM_DEVICES, num_devices * sizeof(cl_device_id), devices, 0);
526 
527  // Grab the sizes of the binaries
528  size_t* binary_sizes = (size_t*)malloc(num_devices * sizeof(size_t));
529  clGetProgramInfo(clProg, CL_PROGRAM_BINARY_SIZES, num_devices * sizeof(size_t), binary_sizes, NULL);
530 
531  // Now get the binaries
532  char** ptx_code = (char**)malloc(num_devices * sizeof(char*));
533  for( unsigned int i=0; i<num_devices; ++i)
534  {
535  ptx_code[i] = (char*)malloc(binary_sizes[i]);
536  }
537  clGetProgramInfo(clProg, CL_PROGRAM_BINARIES, 0, ptx_code, NULL);
538 
539  // Find the index of the device of interest
540  unsigned int idx = 0;
541  while((idx < num_devices) && (devices[idx] != clDev))
542  {
543  ++idx;
544  }
545 
546  // If the index is associated, log the result
547  if( idx < num_devices )
548  {
549  MITK_INFO<< "\n ---------------- \n Program Binary: \n -----------------------\n";
550  MITK_INFO<< ptx_code[idx];
551  }
552 
553  free( devices );
554  free( binary_sizes );
555  for(unsigned int i=0; i<num_devices; ++i)
556  {
557  free(ptx_code[i]);
558  }
559  free( ptx_code );
560 }
561 
562 void oclLogBuildInfo(cl_program clProg, cl_device_id clDev)
563 {
564  char cBuildLog[10240];
565 
566  clGetProgramBuildInfo(clProg, clDev, CL_PROGRAM_BUILD_LOG, sizeof(cBuildLog), cBuildLog, NULL);
567  MITK_INFO<< "\n Program Build Log: \n -----------------------\n";
568  MITK_INFO<< cBuildLog;
569 }
CHECK_OCL_ERR
#define CHECK_OCL_ERR(_er)
Definition: mitkOclUtils.h:25
iDivUp
unsigned int iDivUp(unsigned int dividend, unsigned int divisor)
Method to estimate an integer quotient C from given dividend and divisor higher or equal to the corre...
Definition: mitkOclUtils.cpp:23
GetOclError
void GetOclError(int _clErr)
Checks whether the given value corresponds to an OpenCL Error value and prints this message out as MI...
Definition: mitkOclUtils.cpp:362
MITK_INFO
#define MITK_INFO
Definition: mitkLogMacros.h:22
MITK_ERROR
#define MITK_ERROR
Definition: mitkLogMacros.h:24
GetSupportedImageFormats
void GetSupportedImageFormats(cl_context _context, cl_mem_object_type _type)
Print out all supported image formats for given image type.
Definition: mitkOclUtils.cpp:383
GetOclErrorAsString
std::string GetOclErrorAsString(int _clErr)
Returns the name of an OpenCL Error as a string.
Definition: mitkOclUtils.cpp:214
oclLogBinary
void oclLogBinary(cl_program clProg, cl_device_id clDev)
Logs the GPU Program binary code.
Definition: mitkOclUtils.cpp:517
MITK_WARN
#define MITK_WARN
Definition: mitkLogMacros.h:23
GetImageTypeAsString
std::string GetImageTypeAsString(const unsigned int _in)
Translates the internal image type identifier to a human readable description string.
Definition: mitkOclUtils.cpp:430
oclLogBuildInfo
void oclLogBuildInfo(cl_program clProg, cl_device_id clDev)
Shows the OpenCL-Program build info, called if clBuildProgram != CL_SUCCES.
Definition: mitkOclUtils.cpp:562
oclPrintDeviceInfo
void oclPrintDeviceInfo(cl_device_id device)
Prints out the essential support information about current device.
Definition: mitkOclUtils.cpp:134
oclCheckError
bool oclCheckError(int _err, const char *filepath, int lineno)
Checks the given code for errors and produces a std::cout output if the _err does not equal CL_SUCCES...
Definition: mitkOclUtils.cpp:370
oclPrintMemObjectInfo
void oclPrintMemObjectInfo(cl_mem memobj)
Prints the available memory info about the given object to std::cout.
Definition: mitkOclUtils.cpp:54
oclGetPlatformID
cl_int oclGetPlatformID(cl_platform_id *selectedPlatform)
Returns a platform ID of an OpenCL-capable GPU, or throws an exception.
Definition: mitkOclUtils.cpp:27