cristy | dbba821 | 2013-07-19 14:53:50 +0000 | [diff] [blame] | 1 | /* |
cristy | b56bb24 | 2014-11-25 17:12:48 +0000 | [diff] [blame] | 2 | Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 3 | dedicated to making software imaging solutions freely available. |
cristy | dbba821 | 2013-07-19 14:53:50 +0000 | [diff] [blame] | 4 | |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 5 | You may not use this file except in compliance with the License. |
| 6 | obtain a copy of the License at |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 7 | |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 8 | http://www.imagemagick.org/script/license.php |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 9 | |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 10 | Unless required by applicable law or agreed to in writing, software |
| 11 | distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | See the License for the specific language governing permissions and |
| 14 | limitations under the License. |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 15 | |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 16 | MagickCore OpenCL private methods. |
cristy | dbba821 | 2013-07-19 14:53:50 +0000 | [diff] [blame] | 17 | */ |
| 18 | #ifndef _MAGICKCORE_OPENCL_PRIVATE_H |
| 19 | #define _MAGICKCORE_OPENCL_PRIVATE_H |
| 20 | |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 21 | /* |
| 22 | Include declarations. |
| 23 | */ |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 24 | #include "MagickCore/studio.h" |
cristy | e85d0f7 | 2013-11-27 02:25:43 +0000 | [diff] [blame] | 25 | #include "MagickCore/opencl.h" |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 26 | |
cristy | dbba821 | 2013-07-19 14:53:50 +0000 | [diff] [blame] | 27 | #if defined(__cplusplus) || defined(c_plusplus) |
| 28 | extern "C" { |
| 29 | #endif |
| 30 | |
cristy | 5845024 | 2013-12-15 17:16:03 +0000 | [diff] [blame] | 31 | #if !defined(MAGICKCORE_OPENCL_SUPPORT) |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 32 | typedef void* cl_platform_id; |
| 33 | typedef void* cl_device_id; |
| 34 | typedef void* cl_context; |
| 35 | typedef void* cl_command_queue; |
| 36 | typedef void* cl_kernel; |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 37 | typedef void* cl_mem; |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 38 | typedef struct { unsigned char t[8]; } cl_device_type; /* 64-bit */ |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 39 | #else |
| 40 | /* |
| 41 | * |
| 42 | * function pointer typedefs |
| 43 | * |
| 44 | */ |
| 45 | |
| 46 | /* Platform APIs */ |
| 47 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clGetPlatformIDs)( |
| 48 | cl_uint num_entries, |
| 49 | cl_platform_id * platforms, |
| 50 | cl_uint * num_platforms) CL_API_SUFFIX__VERSION_1_0; |
| 51 | |
| 52 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clGetPlatformInfo)( |
| 53 | cl_platform_id platform, |
| 54 | cl_platform_info param_name, |
| 55 | size_t param_value_size, |
| 56 | void * param_value, |
| 57 | size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; |
| 58 | |
| 59 | /* Device APIs */ |
| 60 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clGetDeviceIDs)( |
| 61 | cl_platform_id platform, |
| 62 | cl_device_type device_type, |
| 63 | cl_uint num_entries, |
| 64 | cl_device_id * devices, |
| 65 | cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_0; |
| 66 | |
| 67 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clGetDeviceInfo)( |
| 68 | cl_device_id device, |
| 69 | cl_device_info param_name, |
| 70 | size_t param_value_size, |
| 71 | void * param_value, |
| 72 | size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; |
| 73 | |
| 74 | /* Context APIs */ |
| 75 | typedef CL_API_ENTRY cl_context (CL_API_CALL *MAGICKpfn_clCreateContext)( |
| 76 | const cl_context_properties * properties, |
| 77 | cl_uint num_devices, |
| 78 | const cl_device_id * devices, |
| 79 | void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *), |
| 80 | void * user_data, |
| 81 | cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; |
| 82 | |
| 83 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clReleaseContext)( |
| 84 | cl_context context) CL_API_SUFFIX__VERSION_1_0; |
| 85 | |
| 86 | /* Command Queue APIs */ |
| 87 | typedef CL_API_ENTRY cl_command_queue (CL_API_CALL *MAGICKpfn_clCreateCommandQueue)( |
| 88 | cl_context context, |
| 89 | cl_device_id device, |
| 90 | cl_command_queue_properties properties, |
| 91 | cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; |
| 92 | |
| 93 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clReleaseCommandQueue)( |
| 94 | cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; |
| 95 | |
| 96 | /* Memory Object APIs */ |
| 97 | typedef CL_API_ENTRY cl_mem (CL_API_CALL *MAGICKpfn_clCreateBuffer)( |
| 98 | cl_context context, |
| 99 | cl_mem_flags flags, |
| 100 | size_t size, |
| 101 | void * host_ptr, |
| 102 | cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; |
| 103 | |
| 104 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clReleaseMemObject)(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0; |
| 105 | |
| 106 | /* Program Object APIs */ |
| 107 | typedef CL_API_ENTRY cl_program (CL_API_CALL *MAGICKpfn_clCreateProgramWithSource)( |
| 108 | cl_context context, |
| 109 | cl_uint count, |
| 110 | const char ** strings, |
| 111 | const size_t * lengths, |
| 112 | cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; |
| 113 | |
| 114 | typedef CL_API_ENTRY cl_program (CL_API_CALL *MAGICKpfn_clCreateProgramWithBinary)( |
| 115 | cl_context context, |
| 116 | cl_uint num_devices, |
| 117 | const cl_device_id * device_list, |
| 118 | const size_t * lengths, |
| 119 | const unsigned char ** binaries, |
| 120 | cl_int * binary_status, |
| 121 | cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; |
| 122 | |
| 123 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clReleaseProgram)(cl_program program) CL_API_SUFFIX__VERSION_1_0; |
| 124 | |
| 125 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clBuildProgram)( |
| 126 | cl_program program, |
| 127 | cl_uint num_devices, |
| 128 | const cl_device_id * device_list, |
| 129 | const char * options, |
| 130 | void (CL_CALLBACK *pfn_notify)(cl_program program, void * user_data), |
| 131 | void * user_data) CL_API_SUFFIX__VERSION_1_0; |
| 132 | |
| 133 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clGetProgramInfo)( |
| 134 | cl_program program, |
| 135 | cl_program_info param_name, |
| 136 | size_t param_value_size, |
| 137 | void * param_value, |
| 138 | size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; |
| 139 | |
| 140 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clGetProgramBuildInfo)( |
| 141 | cl_program program, |
| 142 | cl_device_id device, |
| 143 | cl_program_build_info param_name, |
| 144 | size_t param_value_size, |
| 145 | void * param_value, |
| 146 | size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; |
| 147 | |
| 148 | /* Kernel Object APIs */ |
| 149 | typedef CL_API_ENTRY cl_kernel (CL_API_CALL *MAGICKpfn_clCreateKernel)( |
| 150 | cl_program program, |
| 151 | const char * kernel_name, |
| 152 | cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; |
| 153 | |
| 154 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clReleaseKernel)(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0; |
| 155 | |
| 156 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clSetKernelArg)( |
| 157 | cl_kernel kernel, |
| 158 | cl_uint arg_index, |
| 159 | size_t arg_size, |
| 160 | const void * arg_value) CL_API_SUFFIX__VERSION_1_0; |
| 161 | |
| 162 | /* Flush and Finish APIs */ |
| 163 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clFlush)(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; |
| 164 | |
| 165 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clFinish)(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; |
| 166 | |
| 167 | /* Enqueued Commands APIs */ |
| 168 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clEnqueueReadBuffer)( |
| 169 | cl_command_queue command_queue, |
| 170 | cl_mem buffer, |
| 171 | cl_bool blocking_read, |
| 172 | size_t offset, |
| 173 | size_t cb, |
| 174 | void * ptr, |
| 175 | cl_uint num_events_in_wait_list, |
| 176 | const cl_event * event_wait_list, |
| 177 | cl_event * event) CL_API_SUFFIX__VERSION_1_0; |
| 178 | |
| 179 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clEnqueueWriteBuffer)( |
| 180 | cl_command_queue command_queue, |
| 181 | cl_mem buffer, |
| 182 | cl_bool blocking_write, |
| 183 | size_t offset, |
| 184 | size_t cb, |
| 185 | const void * ptr, |
| 186 | cl_uint num_events_in_wait_list, |
| 187 | const cl_event * event_wait_list, |
| 188 | cl_event * event) CL_API_SUFFIX__VERSION_1_0; |
| 189 | |
| 190 | typedef CL_API_ENTRY void * (CL_API_CALL *MAGICKpfn_clEnqueueMapBuffer)( |
| 191 | cl_command_queue command_queue, |
| 192 | cl_mem buffer, |
| 193 | cl_bool blocking_map, |
| 194 | cl_map_flags map_flags, |
| 195 | size_t offset, |
| 196 | size_t cb, |
| 197 | cl_uint num_events_in_wait_list, |
| 198 | const cl_event * event_wait_list, |
| 199 | cl_event * event, |
| 200 | cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; |
| 201 | |
| 202 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clEnqueueUnmapMemObject)( |
| 203 | cl_command_queue command_queue, |
| 204 | cl_mem memobj, |
| 205 | void * mapped_ptr, |
| 206 | cl_uint num_events_in_wait_list, |
| 207 | const cl_event * event_wait_list, |
| 208 | cl_event * event) CL_API_SUFFIX__VERSION_1_0; |
| 209 | |
| 210 | typedef CL_API_ENTRY cl_int (CL_API_CALL *MAGICKpfn_clEnqueueNDRangeKernel)( |
| 211 | cl_command_queue command_queue, |
| 212 | cl_kernel kernel, |
| 213 | cl_uint work_dim, |
| 214 | const size_t * global_work_offset, |
| 215 | const size_t * global_work_size, |
| 216 | const size_t * local_work_size, |
| 217 | cl_uint num_events_in_wait_list, |
| 218 | const cl_event * event_wait_list, |
| 219 | cl_event * event) CL_API_SUFFIX__VERSION_1_0; |
| 220 | |
| 221 | /* |
| 222 | * |
| 223 | * vendor dispatch table structure |
| 224 | * |
| 225 | * note that the types in the structure KHRicdVendorDispatch mirror the function |
| 226 | * names listed in the string table khrIcdVendorDispatchFunctionNames |
| 227 | * |
| 228 | */ |
| 229 | |
| 230 | typedef struct MagickLibraryRec MagickLibrary; |
| 231 | |
| 232 | struct MagickLibraryRec |
| 233 | { |
| 234 | void * base; |
| 235 | |
| 236 | MAGICKpfn_clGetPlatformIDs clGetPlatformIDs; |
| 237 | MAGICKpfn_clGetPlatformInfo clGetPlatformInfo; |
| 238 | MAGICKpfn_clGetDeviceIDs clGetDeviceIDs; |
| 239 | MAGICKpfn_clGetDeviceInfo clGetDeviceInfo; |
| 240 | MAGICKpfn_clCreateContext clCreateContext; |
| 241 | MAGICKpfn_clCreateCommandQueue clCreateCommandQueue; |
| 242 | MAGICKpfn_clReleaseCommandQueue clReleaseCommandQueue; |
| 243 | MAGICKpfn_clCreateBuffer clCreateBuffer; |
| 244 | MAGICKpfn_clReleaseMemObject clReleaseMemObject; |
| 245 | MAGICKpfn_clCreateProgramWithSource clCreateProgramWithSource; |
| 246 | MAGICKpfn_clCreateProgramWithBinary clCreateProgramWithBinary; |
| 247 | MAGICKpfn_clReleaseProgram clReleaseProgram; |
| 248 | MAGICKpfn_clBuildProgram clBuildProgram; |
| 249 | MAGICKpfn_clGetProgramInfo clGetProgramInfo; |
| 250 | MAGICKpfn_clGetProgramBuildInfo clGetProgramBuildInfo; |
| 251 | MAGICKpfn_clCreateKernel clCreateKernel; |
| 252 | MAGICKpfn_clReleaseKernel clReleaseKernel; |
| 253 | MAGICKpfn_clSetKernelArg clSetKernelArg; |
| 254 | MAGICKpfn_clFlush clFlush; |
| 255 | MAGICKpfn_clFinish clFinish; |
| 256 | MAGICKpfn_clEnqueueReadBuffer clEnqueueReadBuffer; |
| 257 | MAGICKpfn_clEnqueueWriteBuffer clEnqueueWriteBuffer; |
| 258 | MAGICKpfn_clEnqueueMapBuffer clEnqueueMapBuffer; |
| 259 | MAGICKpfn_clEnqueueUnmapMemObject clEnqueueUnmapMemObject; |
| 260 | MAGICKpfn_clEnqueueNDRangeKernel clEnqueueNDRangeKernel; |
| 261 | }; |
| 262 | |
| 263 | struct _MagickCLEnv { |
| 264 | MagickBooleanType OpenCLInitialized; /* whether OpenCL environment is initialized. */ |
| 265 | MagickBooleanType OpenCLDisabled; /* whether if OpenCL has been explicitely disabled. */ |
| 266 | |
| 267 | MagickLibrary * library; |
| 268 | |
| 269 | /*OpenCL objects */ |
| 270 | cl_platform_id platform; |
| 271 | cl_device_type deviceType; |
| 272 | cl_device_id device; |
| 273 | cl_context context; |
| 274 | |
| 275 | MagickBooleanType disableProgramCache; /* disable the OpenCL program cache */ |
| 276 | cl_program programs[MAGICK_OPENCL_NUM_PROGRAMS]; /* one program object maps one kernel source file */ |
| 277 | |
| 278 | MagickBooleanType regenerateProfile; /* re-run the microbenchmark in auto device selection mode */ |
| 279 | |
| 280 | /* Random number generator seeds */ |
| 281 | unsigned int numGenerators; |
| 282 | float randNormalize; |
| 283 | cl_mem seeds; |
| 284 | SemaphoreInfo* seedsLock; |
| 285 | |
| 286 | SemaphoreInfo* lock; |
| 287 | }; |
| 288 | |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 289 | #endif |
| 290 | |
| 291 | #if defined(MAGICKCORE_HDRI_SUPPORT) |
| 292 | #define CLOptions "-cl-single-precision-constant -cl-mad-enable -DMAGICKCORE_HDRI_SUPPORT=1 "\ |
| 293 | "-DCLQuantum=float -DCLSignedQuantum=float -DCLPixelType=float4 -DQuantumRange=%f " \ |
| 294 | "-DQuantumScale=%f -DCharQuantumScale=%f -DMagickEpsilon=%f -DMagickPI=%f "\ |
| 295 | " -DMaxMap=%u -DMAGICKCORE_QUANTUM_DEPTH=%u" |
| 296 | #define CLPixelPacket cl_float4 |
| 297 | #define CLCharQuantumScale 1.0f |
| 298 | #elif (MAGICKCORE_QUANTUM_DEPTH == 8) |
| 299 | #define CLOptions "-cl-single-precision-constant -cl-mad-enable " \ |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 300 | "-DCLQuantum=uchar -DCLSignedQuantum=char -DCLPixelType=uchar4 -DQuantumRange=%ff " \ |
| 301 | "-DQuantumScale=%ff -DCharQuantumScale=%ff -DMagickEpsilon=%ff -DMagickPI=%ff "\ |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 302 | "-DMaxMap=%u -DMAGICKCORE_QUANTUM_DEPTH=%u" |
| 303 | #define CLPixelPacket cl_uchar4 |
| 304 | #define CLCharQuantumScale 1.0f |
| 305 | #elif (MAGICKCORE_QUANTUM_DEPTH == 16) |
| 306 | #define CLOptions "-cl-single-precision-constant -cl-mad-enable " \ |
| 307 | "-DCLQuantum=ushort -DCLSignedQuantum=short -DCLPixelType=ushort4 -DQuantumRange=%f "\ |
| 308 | "-DQuantumScale=%f -DCharQuantumScale=%f -DMagickEpsilon=%f -DMagickPI=%f "\ |
| 309 | "-DMaxMap=%u -DMAGICKCORE_QUANTUM_DEPTH=%u" |
| 310 | #define CLPixelPacket cl_ushort4 |
| 311 | #define CLCharQuantumScale 257.0f |
| 312 | #elif (MAGICKCORE_QUANTUM_DEPTH == 32) |
| 313 | #define CLOptions "-cl-single-precision-constant -cl-mad-enable " \ |
| 314 | "-DCLQuantum=uint -DCLSignedQuantum=int -DCLPixelType=uint4 -DQuantumRange=%f "\ |
| 315 | "-DQuantumScale=%f -DCharQuantumScale=%f -DMagickEpsilon=%f -DMagickPI=%f "\ |
| 316 | "-DMaxMap=%u -DMAGICKCORE_QUANTUM_DEPTH=%u" |
| 317 | #define CLPixelPacket cl_uint4 |
| 318 | #define CLCharQuantumScale 16843009.0f |
| 319 | #elif (MAGICKCORE_QUANTUM_DEPTH == 64) |
| 320 | #define CLOptions "-cl-single-precision-constant -cl-mad-enable " \ |
| 321 | "-DCLQuantum=ulong -DCLSignedQuantum=long -DCLPixelType=ulong4 -DQuantumRange=%f "\ |
| 322 | "-DQuantumScale=%f -DCharQuantumScale=%f -DMagickEpsilon=%f -DMagickPI=%f "\ |
| 323 | "-DMaxMap=%u -DMAGICKCORE_QUANTUM_DEPTH=%u" |
| 324 | #define CLPixelPacket cl_ulong4 |
| 325 | #define CLCharQuantumScale 72340172838076673.0f |
| 326 | #endif |
| 327 | |
cristy | 7b6514c | 2013-12-10 23:13:13 +0000 | [diff] [blame] | 328 | extern MagickPrivate cl_context |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 329 | GetOpenCLContext(MagickCLEnv); |
| 330 | |
cristy | 7b6514c | 2013-12-10 23:13:13 +0000 | [diff] [blame] | 331 | extern MagickPrivate cl_kernel |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 332 | AcquireOpenCLKernel(MagickCLEnv, MagickOpenCLProgram, const char*); |
| 333 | |
cristy | 7b6514c | 2013-12-10 23:13:13 +0000 | [diff] [blame] | 334 | extern MagickPrivate cl_command_queue |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 335 | AcquireOpenCLCommandQueue(MagickCLEnv); |
| 336 | |
cristy | 7b6514c | 2013-12-10 23:13:13 +0000 | [diff] [blame] | 337 | extern MagickPrivate MagickBooleanType |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 338 | OpenCLThrowMagickException(ExceptionInfo *, |
| 339 | const char *,const char *,const size_t, |
| 340 | const ExceptionType,const char *,const char *,...), |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 341 | RelinquishOpenCLCommandQueue(MagickCLEnv, cl_command_queue), |
| 342 | RelinquishOpenCLKernel(MagickCLEnv, cl_kernel); |
| 343 | |
cristy | 7b6514c | 2013-12-10 23:13:13 +0000 | [diff] [blame] | 344 | extern MagickPrivate unsigned long |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 345 | GetOpenCLDeviceLocalMemorySize(MagickCLEnv), |
| 346 | GetOpenCLDeviceMaxMemAllocSize(MagickCLEnv); |
| 347 | |
cristy | 7b6514c | 2013-12-10 23:13:13 +0000 | [diff] [blame] | 348 | extern MagickPrivate const char* |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 349 | GetOpenCLCachedFilesDirectory(); |
| 350 | |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 351 | extern MagickPrivate void |
| 352 | UnlockRandSeedBuffer(MagickCLEnv), |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 353 | OpenCLLog(const char*); |
| 354 | |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 355 | extern MagickPrivate cl_mem |
| 356 | GetAndLockRandSeedBuffer(MagickCLEnv); |
| 357 | |
| 358 | extern MagickPrivate unsigned int |
| 359 | GetNumRandGenerators(MagickCLEnv); |
| 360 | |
| 361 | extern MagickPrivate float |
| 362 | GetRandNormalize(MagickCLEnv clEnv); |
| 363 | |
| 364 | typedef struct _AccelerateTimer { |
| 365 | long long _freq; |
| 366 | long long _clocks; |
| 367 | long long _start; |
| 368 | } AccelerateTimer; |
| 369 | |
| 370 | |
| 371 | void startAccelerateTimer(AccelerateTimer* timer); |
| 372 | void stopAccelerateTimer(AccelerateTimer* timer); |
| 373 | void resetAccelerateTimer(AccelerateTimer* timer); |
| 374 | void initAccelerateTimer(AccelerateTimer* timer); |
| 375 | double readAccelerateTimer(AccelerateTimer* timer); |
| 376 | |
cristy | e85d0f7 | 2013-11-27 02:25:43 +0000 | [diff] [blame] | 377 | /* #define OPENCLLOG_ENABLED 1 */ |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 378 | static inline void OpenCLLogException(const char* function, |
| 379 | const unsigned int line, |
| 380 | ExceptionInfo* exception) { |
cristy | e85d0f7 | 2013-11-27 02:25:43 +0000 | [diff] [blame] | 381 | #ifdef OPENCLLOG_ENABLED |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 382 | if (exception->severity!=0) { |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 383 | char message[MagickPathExtent]; |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 384 | /* dump the source into a file */ |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 385 | (void) FormatLocaleString(message,MagickPathExtent,"%s:%d Exception(%d):%s " |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 386 | ,function,line,exception->severity,exception->reason); |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 387 | OpenCLLog(message); |
cristy | 711ed18 | 2013-11-24 15:15:16 +0000 | [diff] [blame] | 388 | } |
cristy | e85d0f7 | 2013-11-27 02:25:43 +0000 | [diff] [blame] | 389 | #else |
| 390 | magick_unreferenced(function); |
| 391 | magick_unreferenced(line); |
| 392 | magick_unreferenced(exception); |
| 393 | #endif |
cristy | f034abb | 2013-11-24 14:16:14 +0000 | [diff] [blame] | 394 | } |
| 395 | |
cristy | 0c832c6 | 2014-03-07 22:21:04 +0000 | [diff] [blame] | 396 | |
cristy | dbba821 | 2013-07-19 14:53:50 +0000 | [diff] [blame] | 397 | #if defined(__cplusplus) || defined(c_plusplus) |
| 398 | } |
| 399 | #endif |
| 400 | |
| 401 | #endif |