git.oblomov.eu Git - ocl-icd/blob - libdummy_icd.c

   1 /**
   2 Copyright (c) 2012, Brice Videau <brice.videau@imag.fr>
   3 Copyright (c) 2012, Vincent Danjean <Vincent.Danjean@ens-lyon.org>
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions are met:
   8
   9 1. Redistributions of source code must retain the above copyright notice, this
  10    list of conditions and the following disclaimer.
  11 2. Redistributions in binary form must reproduce the above copyright notice,
  12    this list of conditions and the following disclaimer in the documentation
  13    and/or other materials provided with the distribution.
  14
  15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  16 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  17 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  19 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  20 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  22 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  24 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25 */
  26
  27 #include "ocl_icd_debug.h"
  28 #include "libdummy_icd.h"
  29 #include "libdummy_icd_gen.h"
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #define NUM_PLATFORMS 1
  34
  35 #define SYMB(f) \
  36 typeof(INT##f) f __attribute__ ((alias ("INT" #f), visibility("default")))
  37
  38 #pragma GCC visibility push(hidden)
  39
  40 int debug_ocl_icd_mask;
  41
  42 cl_uint const num_master_platforms = NUM_PLATFORMS;
  43 struct _cl_platform_id master_platforms[NUM_PLATFORMS] = { {&master_dispatch} };
  44
  45 static cl_int _GetPlatformIDs(
  46              cl_uint num_entries,
  47              cl_platform_id *platforms,
  48              cl_uint *num_platforms) {
  49   debug_trace();
  50   if( platforms == NULL && num_platforms == NULL )
  51     return CL_INVALID_VALUE;
  52   if( num_entries == 0 && platforms != NULL )
  53     return CL_INVALID_VALUE;
  54   if( num_master_platforms == 0)
  55     return CL_PLATFORM_NOT_FOUND_KHR;
  56   if( num_platforms != NULL ){
  57     debug(D_LOG, "  asked num_platforms");
  58     *num_platforms = num_master_platforms; }
  59   if( platforms != NULL ) {
  60     debug(D_LOG, "  asked %i platforms", num_entries);
  61     cl_uint i;
  62     for( i=0; i<(num_master_platforms<num_entries?num_master_platforms:num_entries); i++)
  63       platforms[i] = &master_platforms[i];
  64   }
  65   return CL_SUCCESS;
  66 }
  67
  68 CL_API_ENTRY cl_int CL_API_CALL INTclGetPlatformIDs(
  69              cl_uint num_entries,
  70              cl_platform_id *platforms,
  71              cl_uint *num_platforms) {
  72   debug_init();
  73   debug_trace();
  74   return _GetPlatformIDs(num_entries, platforms, num_platforms);
  75 }
  76 SYMB(clGetPlatformIDs);
  77
  78 CL_API_ENTRY cl_int CL_API_CALL INTclIcdGetPlatformIDsKHR(
  79              cl_uint num_entries,
  80              cl_platform_id *platforms,
  81              cl_uint *num_platforms) {
  82   debug_init();
  83   debug_trace();
  84   return _GetPlatformIDs(num_entries, platforms, num_platforms);
  85 }
  86 SYMB(clIcdGetPlatformIDsKHR);
  87
  88 /*CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddressForPlatform(
  89              cl_platform_id platform,
  90              const char *   func_name) CL_API_SUFFIX__VERSION_1_2 {
  91 }*/
  92
  93 CL_API_ENTRY void * CL_API_CALL INTclGetExtensionFunctionAddress(
  94              const char *   func_name) CL_API_SUFFIX__VERSION_1_0 {
  95   debug_init();
  96   debug_trace();
  97   debug(D_LOG, "request address for %s", func_name);
  98   if( func_name != NULL &&  strcmp("clIcdGetPlatformIDsKHR", func_name) == 0 )
  99     return (void *)_GetPlatformIDs;
 100   return NULL;
 101 }
 102 SYMB(clGetExtensionFunctionAddress);
 103
 104 CL_API_ENTRY cl_int CL_API_CALL INTclGetPlatformInfo(
 105              cl_platform_id   platform,
 106              cl_platform_info param_name,
 107              size_t           param_value_size,
 108              void *           param_value,
 109              size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
 110   debug_init();
 111   debug_trace();
 112   debug(D_LOG, "request info for 0x%x", param_name);
 113
 114   char cl_platform_profile[] = "FULL_PROFILE";
 115   char cl_platform_version[] = "OpenCL 1.2";
 116   char cl_platform_name[] = "DummyCL";
 117   char cl_platform_vendor[] = "ocl-icd ICD test"
 118 #ifdef ICD_WITHOUT_EXTENSION
 119           " (no ext)"
 120 #endif
 121           ;
 122   char cl_platform_extensions[] =
 123 #ifdef ICD_WITHOUT_EXTENSION
 124           "private_ext"
 125 #else
 126           "cl_khr_icd"
 127 #endif
 128           ;
 129   char cl_platform_icd_suffix_khr[] = "LIG";
 130   size_t size_string;
 131   char * string_p;
 132   if( platform != NULL ) {
 133     int found = 0;
 134     int i;
 135     for(i=0; i<num_master_platforms; i++) {
 136       if( platform == &master_platforms[i] )
 137         found = 1;
 138     }
 139     if(!found)
 140       return CL_INVALID_PLATFORM;
 141   }
 142   switch ( param_name ) {
 143     case CL_PLATFORM_PROFILE:
 144       string_p = cl_platform_profile;
 145       size_string = sizeof(cl_platform_profile);
 146       break;
 147     case CL_PLATFORM_VERSION:
 148       string_p = cl_platform_version;
 149       size_string = sizeof(cl_platform_version);
 150       break;
 151     case CL_PLATFORM_NAME:
 152       string_p = cl_platform_name;
 153       size_string = sizeof(cl_platform_name);
 154       break;
 155     case CL_PLATFORM_VENDOR:
 156       string_p = cl_platform_vendor;
 157       size_string = sizeof(cl_platform_vendor);
 158       break;
 159     case CL_PLATFORM_EXTENSIONS:
 160 #ifdef ICD_WITHOUT_EXTENSION
 161       if (getenv("EMULATE_INTEL_ICD")) {
 162         exit(3);
 163       }
 164 #endif
 165       string_p = cl_platform_extensions;
 166       size_string = sizeof(cl_platform_extensions);
 167       break;
 168     case CL_PLATFORM_ICD_SUFFIX_KHR:
 169       string_p = cl_platform_icd_suffix_khr;
 170       size_string = sizeof(cl_platform_icd_suffix_khr);
 171       break;
 172     default:
 173       return CL_INVALID_VALUE;
 174       break;
 175   }
 176   if( param_value != NULL ) {
 177     if( size_string > param_value_size )
 178       return CL_INVALID_VALUE;
 179     memcpy(param_value, string_p, size_string);
 180   }
 181   if( param_value_size_ret != NULL )
 182     *param_value_size_ret = size_string;
 183   return CL_SUCCESS;
 184 }
 185 SYMB(clGetPlatformInfo);
 186
 187 #pragma GCC visibility pop
 188