 |
TAPs 0.7.7.3
|
|
TAPs 0.7.7.3
|
00001 /****************************************************************************** 00002 TAPsOpenCL.cpp 00003 ******************************************************************************/ 00007 /****************************************************************************** 00008 SUKITTI PUNAK (03/23/2011) 00009 UPDATE (07/07/2011) 00010 ******************************************************************************/ 00011 #include "TAPsOpenCL.hpp" 00012 // Using Inclusion Model (i.e. definitions are included in declarations) 00013 // (this name.cpp is included in name.hpp) 00014 // Each friend is defined directly inside its declaration. 00015 00016 BEGIN_NAMESPACE_TAPs__OpenCL 00017 00018 //============================================================================= 00019 // START CLASS: OpenCL_Util 00020 //----------------------------------------------------------------------------- 00021 std::string OpenCL_Util::StrOpenCLErrorCode ( cl_int errCode ) 00022 { 00023 switch ( errCode ) 00024 { 00025 case CL_SUCCESS: // 0 00026 return "CL_SUCCESS"; 00027 break; 00028 case CL_DEVICE_NOT_FOUND: // -1 00029 return "CL_DEVICE_NOT_FOUND"; 00030 break; 00031 case CL_DEVICE_NOT_AVAILABLE: // -2 00032 return "CL_DEVICE_NOT_AVAILABLE"; 00033 break; 00034 case CL_COMPILER_NOT_AVAILABLE: // -3 00035 return "CL_COMPILER_NOT_AVAILABLE"; 00036 break; 00037 case CL_MEM_OBJECT_ALLOCATION_FAILURE: // -4 00038 return "CL_MEM_OBJECT_ALLOCATION_FAILURE"; 00039 break; 00040 case CL_OUT_OF_RESOURCES: // -5 00041 return "CL_OUT_OF_RESOURCES"; 00042 break; 00043 case CL_OUT_OF_HOST_MEMORY: // -6 00044 return "CL_OUT_OF_HOST_MEMORY"; 00045 break; 00046 case CL_PROFILING_INFO_NOT_AVAILABLE: // -7 00047 return "CL_PROFILING_INFO_NOT_AVAILABLE"; 00048 break; 00049 case CL_MEM_COPY_OVERLAP: // -8 00050 return "CL_MEM_COPY_OVERLAP"; 00051 break; 00052 case CL_IMAGE_FORMAT_MISMATCH: // -9 00053 return "CL_IMAGE_FORMAT_MISMATCH"; 00054 break; 00055 case CL_IMAGE_FORMAT_NOT_SUPPORTED: // -10 00056 return "CL_IMAGE_FORMAT_NOT_SUPPORTED"; 00057 break; 00058 case CL_BUILD_PROGRAM_FAILURE: // -11 00059 return "CL_BUILD_PROGRAM_FAILURE"; 00060 break; 00061 case CL_MAP_FAILURE: // -12 00062 return "CL_MAP_FAILURE"; 00063 break; 00064 case CL_MISALIGNED_SUB_BUFFER_OFFSET: // -13 00065 return "CL_MISALIGNED_SUB_BUFFER_OFFSET"; 00066 break; 00067 case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST: // -14 00068 return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST"; 00069 break; 00070 case CL_INVALID_VALUE: // -30 00071 return "CL_INVALID_VALUE"; 00072 break; 00073 case CL_INVALID_DEVICE_TYPE: // -31 00074 return "CL_INVALID_DEVICE_TYPE"; 00075 break; 00076 case CL_INVALID_PLATFORM: // -32 00077 return "CL_INVALID_PLATFORM"; 00078 break; 00079 case CL_INVALID_DEVICE: // -33 00080 return "CL_INVALID_DEVICE"; 00081 break; 00082 case CL_INVALID_CONTEXT: // -34 00083 return "CL_INVALID_CONTEXT"; 00084 break; 00085 case CL_INVALID_QUEUE_PROPERTIES: // -35 00086 return "CL_INVALID_QUEUE_PROPERTIES"; 00087 break; 00088 case CL_INVALID_COMMAND_QUEUE: // -36 00089 return "CL_INVALID_COMMAND_QUEUE"; 00090 break; 00091 case CL_INVALID_HOST_PTR: // -37 00092 return "CL_INVALID_HOST_PTR"; 00093 break; 00094 case CL_INVALID_MEM_OBJECT: // -38 00095 return "CL_INVALID_MEM_OBJECT"; 00096 break; 00097 case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: // -39 00098 return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"; 00099 break; 00100 case CL_INVALID_IMAGE_SIZE: // -40 00101 return "CL_INVALID_IMAGE_SIZE"; 00102 break; 00103 case CL_INVALID_SAMPLER: // -41 00104 return "CL_INVALID_SAMPLER"; 00105 break; 00106 case CL_INVALID_BINARY: // -42 00107 return "CL_INVALID_BINARY"; 00108 break; 00109 case CL_INVALID_BUILD_OPTIONS: // -43 00110 return "CL_INVALID_BUILD_OPTIONS"; 00111 break; 00112 case CL_INVALID_PROGRAM: // -44 00113 return "CL_INVALID_PROGRAM"; 00114 break; 00115 case CL_INVALID_PROGRAM_EXECUTABLE: // -45 00116 return "CL_INVALID_PROGRAM_EXECUTABLE"; 00117 break; 00118 case CL_INVALID_KERNEL_NAME: // -46 00119 return "CL_INVALID_KERNEL_NAME"; 00120 break; 00121 case CL_INVALID_KERNEL_DEFINITION: // -47 00122 return "CL_INVALID_KERNEL_DEFINITION"; 00123 break; 00124 case CL_INVALID_KERNEL: // -48 00125 return "CL_INVALID_KERNEL"; 00126 break; 00127 case CL_INVALID_ARG_INDEX: // -49 00128 return "CL_INVALID_ARG_INDEX"; 00129 break; 00130 case CL_INVALID_ARG_VALUE: // -50 00131 return "CL_INVALID_ARG_VALUE"; 00132 break; 00133 case CL_INVALID_ARG_SIZE: // -51 00134 return "CL_INVALID_ARG_SIZE"; 00135 break; 00136 case CL_INVALID_KERNEL_ARGS: // -52 00137 return "CL_INVALID_KERNEL_ARGS"; 00138 break; 00139 case CL_INVALID_WORK_DIMENSION: // -53 00140 return "CL_INVALID_WORK_DIMENSION"; 00141 break; 00142 case CL_INVALID_WORK_GROUP_SIZE: // -54 00143 return "CL_INVALID_WORK_GROUP_SIZE"; 00144 break; 00145 case CL_INVALID_WORK_ITEM_SIZE: // -55 00146 return "CL_INVALID_WORK_ITEM_SIZE"; 00147 break; 00148 case CL_INVALID_GLOBAL_OFFSET: // -56 00149 return "CL_INVALID_GLOBAL_OFFSET"; 00150 break; 00151 case CL_INVALID_EVENT_WAIT_LIST: // -57 00152 return "CL_INVALID_EVENT_WAIT_LIST"; 00153 break; 00154 case CL_INVALID_EVENT: // -58 00155 return "CL_INVALID_EVENT"; 00156 break; 00157 case CL_INVALID_OPERATION: // -59 00158 return "CL_INVALID_OPERATION"; 00159 break; 00160 case CL_INVALID_GL_OBJECT: // -60 00161 return "CL_INVALID_GL_OBJECT"; 00162 break; 00163 case CL_INVALID_BUFFER_SIZE: // -61 00164 return "CL_INVALID_BUFFER_SIZE"; 00165 break; 00166 case CL_INVALID_MIP_LEVEL: // -62 00167 return "CL_INVALID_MIP_LEVEL"; 00168 break; 00169 case CL_INVALID_GLOBAL_WORK_SIZE: // -63 00170 return "CL_INVALID_GLOBAL_WORK_SIZE"; 00171 break; 00172 case CL_INVALID_PROPERTY: // -64 00173 return "CL_INVALID_PROPERTY"; 00174 break; 00175 default: 00176 return "AN UNKNOWN OpenCL ERROR CODE"; 00177 break; 00178 } 00179 } 00180 //----------------------------------------------------------------------------- 00181 std::string OpenCL_Util::StrOpenCLDeviceTypeCode ( cl_device_type deviceType ) 00182 { 00183 switch ( deviceType ) 00184 { 00185 case CL_DEVICE_TYPE_DEFAULT: // (1 << 0) 00186 return "CL_DEVICE_TYPE_DEFAULT"; 00187 break; 00188 case CL_DEVICE_TYPE_CPU: // (1 << 1) 00189 return "CL_DEVICE_TYPE_CPU"; 00190 break; 00191 case CL_DEVICE_TYPE_GPU: // (1 << 2) 00192 return "CL_DEVICE_TYPE_GPU"; 00193 break; 00194 case CL_DEVICE_TYPE_ACCELERATOR: // (1 << 3) 00195 return "CL_DEVICE_TYPE_ACCELERATOR"; 00196 break; 00197 case CL_DEVICE_TYPE_ALL: // 0xFFFFFFFF 00198 return "CL_DEVICE_TYPE_ALL"; 00199 break; 00200 default: 00201 return "AN UNKNOWN OpenCL DEVICE TYPE"; 00202 break; 00203 } 00204 } 00205 //----------------------------------------------------------------------------- 00206 // END CLASS: OpenCL_Util 00207 //============================================================================= 00208 00209 00210 00211 00212 //============================================================================= 00213 // START CLASS: OpenCL_Device 00214 //----------------------------------------------------------------------------- 00215 OpenCL_Device::OpenCL_Device ( cl_device_id id ) 00216 : m_DeviceID( id ) 00217 { 00218 GetOpenCLDeviceInfo(); 00219 } 00220 //----------------------------------------------------------------------------- 00221 OpenCL_Device::~OpenCL_Device () 00222 {} 00223 //----------------------------------------------------------------------------- 00224 std::string OpenCL_Device::StrInfo () const 00225 { 00226 std::stringstream ss; 00227 size_t val; 00228 cl_uint ui_val; 00229 00230 ss << "OpenCL Device ID: " << m_DeviceID << "\t(associated with OpenCL Platform ID: " << m_PlatformID << ")"; 00231 ss << "\n OpenCL Device Available: " << (DeviceAvailable() ? "true" : "false"); 00232 ss << "\n OpenCL Device Name: " << m_DeviceName; 00233 ss << "\n OpenCL Device Vendor: " << m_DeviceVendor; 00234 ss << "\n OpenCL Device Type: " << OpenCL_Util::StrOpenCLDeviceTypeCode( m_DeviceType ); 00235 ss << "\n OpenCL Device Profile: " << m_DeviceProfile; 00236 ss << "\n OpenCL Device Version: " << m_DeviceVersion; 00237 ss << "\n OpenCL Device OpenCL C Version: " << m_DeviceOpenCL_C_Version; 00238 ss << "\n OpenCL Device Max Compute Units: " << m_DeviceMaxComputeUnits; 00239 ss << "\n OpenCL Device Max Work-Item Dimensions: " << m_DeviceMaxWorkItemDimensions; 00240 ss << "\n OpenCL Device Max Work-Item Sizes: ("; 00241 for ( unsigned int i = 0; i < m_DeviceMaxWorkItemSizes.size()-1; ++i ) { 00242 ss << m_DeviceMaxWorkItemSizes[i] << ", "; 00243 } 00244 ss << m_DeviceMaxWorkItemSizes.back() << ")"; 00245 ss << "\n OpenCL Device Max Work-Group Size: " << m_DeviceMaxWorkGroupSize; 00246 val = DeviceMaxParameterSize(); 00247 ss << "\n OpenCL Device Max Parameter Size: " << val << " bytes <==> " << val/8 << " arguments"; 00248 ss << "\n OpenCL Device Single FP Config: " << StrOfDeviceSingleFPConfig(); 00249 ss << "\n OpenCL Device Max Const Buffer Size: " << DeviceMaxConstBufferSize()/1024 << " KB"; 00250 ss << "\n OpenCL Device Max Const Args: " << DeviceMaxConstArgs(); 00251 ss << "\n OpenCL Device Queue Properties: " << StrOfDeviceQueueProperties(); 00252 00253 ss << "\n Image Info:"; 00254 ss << "\n OpenCL Device Image Support: " << (DeviceImageSupport() ? "true" : "false"); 00255 if ( DeviceImageSupport() ) { 00256 ss << "\n OpenCL Device Max Samplers: " << DeviceMaxSamplers() << " samplers"; 00257 ss << "\n OpenCL Device Max Read Image Arguments: " << DeviceMaxReadImageArguments() << " image objects"; 00258 ss << "\n OpenCL Device Max Write Image Arguments: " << DeviceMaxWriteImageArguments() << " image objects"; 00259 ss << "\n OpenCL Device Image2D Max Width and Height: " << DeviceImage2DMaxWidth() << "x" << DeviceImage2DMaxHeight() << " pixels"; 00260 ss << "\n OpenCL Device Image3D Max Width, Height, and Depth: " << DeviceImage3DMaxWidth() << "x" << DeviceImage3DMaxHeight() << "x" << DeviceImage3DMaxDepth() << " pixels"; 00261 } 00262 00263 ss << "\n Mem Info:"; 00264 ss << "\n OpenCL Device Max Clock Frequency: " << DeviceMaxClockFrequency() << " MHz"; 00265 ss << "\n OpenCL Device Address Bits: " << DeviceAddressBits() << " bits"; 00266 ss << "\n OpenCL Device Global Mem Size: " << DeviceGlobalMemSize() / 1024 / 1024 << " MB"; 00267 ss << "\n OpenCL Device Local Mem Size: " << DeviceLocalMemSize() / 1024 << " KB"; 00268 ss << "\n OpenCL Device Max Mem Alloc Size: " << DeviceMaxMemAllocSize() / 1024 / 1024 << " MB"; 00269 ui_val = DeviceMemBaseAddrAlign(); 00270 ss << "\n OpenCL Device Mem Base Addr Align: " << ui_val << " bits <==> " << ui_val/8 << " bytes"; 00271 ss << "\n OpenCL Device Min Data Type Align Size: " << DeviceMinDataAlignSize() << " bytes"; 00272 ss << "\n OpenCL Device Min Data Type Align Size: " << DeviceMinDataAlignSize() << " bytes"; 00273 ss << "\n OpenCL Device Global Memory Cache Type: " << StrOfDeviceGlobalMemCacheType(); 00274 ss << "\n OpenCL Device Global Memory Cache Size: " << DeviceGlobalMemCacheSize() << " bytes"; 00275 ss << "\n OpenCL Device Global Memory Cacheline Size: " << DeviceGlobalMemCachelineSize() << " bytes"; 00276 ss << "\n OpenCL Device Global Memory Local Type: " << StrOfDeviceLocalMemType(); 00277 ss << "\n OpenCL Device Global Err Correction Support: " << (DeviceErrCorrectionSupport() ? "true" : "false"); 00278 //ss << "\n OpenCL Device Global Host Unified Mem: " << (DeviceHostUnifiedMem() ? "true" : "false"); 00279 00280 ss << "\n Misc Info:"; 00281 ss << "\n OpenCL Device Vendor ID: " << DeviceVendorID(); 00282 ss << "\n OpenCL Device Preferred Vector Width Sizes: " << StrOfOpenCLDevicePreferredVectorWidthSizes(); 00283 ss << "\n OpenCL Device Native Vector Width Sizes: " << StrOfOpenCLDeviceNativeVectorWidthSizes(); 00284 ss << "\n OpenCL Device Endian Little: " << (DeviceEndainLittle() ? "true" : "false"); 00285 ss << "\n OpenCL Device Profiling Timer Resolution: " << DeviceProfilingTimerResolution() << " ns"; 00286 ss << "\n OpenCL Device Compiler Available: " << (DeviceCompilerAvailable() ? "true" : "false"); 00287 ss << "\n OpenCL Device Exec Capabilities: " << StrOfDeviceExecCapabilities(); 00288 ss << "\n OpenCL Device Extensions:"; 00289 std::string extensions = DeviceExtensions(); 00290 std::string delimit( "\t\n " ); 00291 size_t start = 0, end = 0; 00292 while ( extensions.size() > 0 && end < 1024 ) 00293 { 00294 start = extensions.find_first_not_of( delimit, 0 ); 00295 end = extensions.find_first_of( delimit, start ); 00296 if ( end == std::string::npos ) { 00297 if ( start != std::string::npos ) { 00298 ss << "\n " << extensions.substr( start, extensions.size()-start ); 00299 } 00300 break; 00301 } 00302 else { 00303 ss << "\n " << extensions.substr( start, end-start ); 00304 } 00305 //start = end; 00306 //end = extensions.find_first_of( delimit, start ); 00307 extensions = extensions.substr( end ); 00308 } 00309 ss << "\n"; 00310 00311 return ss.str(); 00312 } 00313 //----------------------------------------------------------------------------- 00314 void OpenCL_Device::GetOpenCLDeviceInfo () 00315 { 00316 char cBuffer[1024]; 00317 size_t param_value_size_ret; 00318 00319 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PLATFORM, sizeof(m_PlatformID), &m_PlatformID, ¶m_value_size_ret ) ); 00320 00321 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_NAME, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00322 m_DeviceName = cBuffer; 00323 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_VENDOR, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00324 m_DeviceVendor = cBuffer; 00325 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PROFILE, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00326 m_DeviceProfile = cBuffer; 00327 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_VERSION, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00328 m_DeviceVersion = cBuffer; 00329 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_OPENCL_C_VERSION, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00330 //m_DeviceOpenCL_C_Version = cBuffer; 00331 00332 size_t dimensions[16]; 00333 00334 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_TYPE, sizeof(m_DeviceType), &m_DeviceType, ¶m_value_size_ret ) ); 00335 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(m_DeviceMaxComputeUnits), &m_DeviceMaxComputeUnits, ¶m_value_size_ret ) ); 00336 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(m_DeviceMaxWorkItemDimensions), &m_DeviceMaxWorkItemDimensions, ¶m_value_size_ret ) ); 00337 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(dimensions), dimensions, ¶m_value_size_ret ) ); 00338 for ( unsigned int i = 0; i < param_value_size_ret/sizeof(size_t); ++i ) { 00339 m_DeviceMaxWorkItemSizes.push_back( dimensions[i] ); 00340 } 00341 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(m_DeviceMaxWorkGroupSize), &m_DeviceMaxWorkGroupSize, ¶m_value_size_ret ) ); 00342 00343 00344 00345 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_TYPE, sizeof(m_DeviceType), &m_DeviceType, ¶m_value_size_ret ) ); 00346 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_TYPE, sizeof(m_DeviceType), &m_DeviceType, ¶m_value_size_ret ) ); 00347 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_VENDOR_ID, sizeof(m_DeviceVendorID), &m_DeviceVendorID, ¶m_value_size_ret ) ); 00348 } 00349 //----------------------------------------------------------------------------- 00350 cl_uint OpenCL_Device::DeviceVendorID () const 00351 { 00352 cl_uint id; 00353 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_VENDOR_ID, sizeof(id), &id, NULL ) ); 00354 return id; 00355 } 00356 //----------------------------------------------------------------------------- 00357 std::vector< cl_uint > OpenCL_Device::DevicePreferredVectorWidthSizes () const 00358 { 00359 std::vector< cl_uint > info; 00360 cl_uint data; 00361 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, sizeof(data), &data, NULL ) ); 00362 info.push_back( data ); 00363 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, sizeof(data), &data, NULL ) ); 00364 info.push_back( data ); 00365 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof(data), &data, NULL ) ); 00366 info.push_back( data ); 00367 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof(data), &data, NULL ) ); 00368 info.push_back( data ); 00369 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, sizeof(data), &data, NULL ) ); 00370 info.push_back( data ); 00371 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, sizeof(data), &data, NULL ) ); 00372 info.push_back( data ); 00373 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, sizeof(data), &data, NULL ) ); 00374 info.push_back( data ); 00375 00376 return info; 00377 } 00378 //----------------------------------------------------------------------------- 00379 std::vector< cl_uint > OpenCL_Device::DeviceNativeVectorWidthSizes () const 00380 { 00381 std::vector< cl_uint > info; 00382 //cl_uint data; 00383 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, sizeof(data), &data, NULL ) ); 00384 //info.push_back( data ); 00385 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, sizeof(data), &data, NULL ) ); 00386 //info.push_back( data ); 00387 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof(data), &data, NULL ) ); 00388 //info.push_back( data ); 00389 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof(data), &data, NULL ) ); 00390 //info.push_back( data ); 00391 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, sizeof(data), &data, NULL ) ); 00392 //info.push_back( data ); 00393 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, sizeof(data), &data, NULL ) ); 00394 //info.push_back( data ); 00395 //OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, sizeof(data), &data, NULL ) ); 00396 //info.push_back( data ); 00397 00398 return info; 00399 } 00400 //----------------------------------------------------------------------------- 00401 std::string OpenCL_Device::StrOfOpenCLDevicePreferredVectorWidthSizes () const 00402 { 00403 std::stringstream ss; 00404 std::vector< cl_uint > info = DevicePreferredVectorWidthSizes(); 00405 ss << info[0] << " char, "; 00406 ss << info[1] << " short, "; 00407 ss << info[2] << " int, "; 00408 ss << info[3] << " long, "; 00409 ss << info[4] << " float, "; 00410 ss << info[5] << " double, "; 00411 ss << info[6] << " half"; 00412 return ss.str(); 00413 } 00414 //----------------------------------------------------------------------------- 00415 std::string OpenCL_Device::StrOfOpenCLDeviceNativeVectorWidthSizes () const 00416 { 00417 std::stringstream ss; 00418 std::vector< cl_uint > info = DeviceNativeVectorWidthSizes(); 00419 //ss << info[0] << " char, "; 00420 //ss << info[1] << " short, "; 00421 //ss << info[2] << " int, "; 00422 //ss << info[3] << " long, "; 00423 //ss << info[4] << " float, "; 00424 //ss << info[5] << " double, "; 00425 //ss << info[6] << " half"; 00426 return ss.str(); 00427 } 00428 //----------------------------------------------------------------------------- 00429 cl_bool OpenCL_Device::DeviceImageSupport () const 00430 { 00431 cl_bool id; 00432 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_IMAGE_SUPPORT, sizeof(id), &id, NULL ) ); 00433 return id; 00434 } 00435 //----------------------------------------------------------------------------- 00436 cl_uint OpenCL_Device::DeviceMaxReadImageArguments () const 00437 { 00438 cl_uint id; 00439 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof(id), &id, NULL ) ); 00440 return id; 00441 } 00442 //----------------------------------------------------------------------------- 00443 cl_uint OpenCL_Device::DeviceMaxWriteImageArguments () const 00444 { 00445 cl_uint id; 00446 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof(id), &id, NULL ) ); 00447 return id; 00448 } 00449 //----------------------------------------------------------------------------- 00450 size_t OpenCL_Device::DeviceImage2DMaxWidth () const 00451 { 00452 size_t id; 00453 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof(id), &id, NULL ) ); 00454 return id; 00455 } 00456 //----------------------------------------------------------------------------- 00457 size_t OpenCL_Device::DeviceImage2DMaxHeight () const 00458 { 00459 size_t id; 00460 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof(id), &id, NULL ) ); 00461 return id; 00462 } 00463 //----------------------------------------------------------------------------- 00464 size_t OpenCL_Device::DeviceImage3DMaxWidth () const 00465 { 00466 size_t id; 00467 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof(id), &id, NULL ) ); 00468 return id; 00469 } 00470 //----------------------------------------------------------------------------- 00471 size_t OpenCL_Device::DeviceImage3DMaxHeight () const 00472 { 00473 size_t id; 00474 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof(id), &id, NULL ) ); 00475 return id; 00476 } 00477 //----------------------------------------------------------------------------- 00478 size_t OpenCL_Device::DeviceImage3DMaxDepth () const 00479 { 00480 size_t id; 00481 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(id), &id, NULL ) ); 00482 return id; 00483 } 00484 //----------------------------------------------------------------------------- 00485 size_t OpenCL_Device::DeviceMaxSamplers () const 00486 { 00487 size_t id; 00488 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_SAMPLERS, sizeof(id), &id, NULL ) ); 00489 return id; 00490 } 00491 //----------------------------------------------------------------------------- 00492 size_t OpenCL_Device::DeviceMaxParameterSize () const 00493 { 00494 size_t id; 00495 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_PARAMETER_SIZE, sizeof(id), &id, NULL ) ); 00496 return id; 00497 } 00498 //----------------------------------------------------------------------------- 00499 cl_uint OpenCL_Device::DeviceMaxClockFrequency () const 00500 { 00501 cl_uint id; 00502 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(id), &id, NULL ) ); 00503 return id; 00504 } 00505 //----------------------------------------------------------------------------- 00506 cl_uint OpenCL_Device::DeviceAddressBits () const 00507 { 00508 cl_uint id; 00509 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_ADDRESS_BITS, sizeof(id), &id, NULL ) ); 00510 return id; 00511 } 00512 //----------------------------------------------------------------------------- 00513 cl_ulong OpenCL_Device::DeviceGlobalMemSize () const 00514 { 00515 cl_ulong id; 00516 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(id), &id, NULL ) ); 00517 return id; 00518 } 00519 //----------------------------------------------------------------------------- 00520 cl_ulong OpenCL_Device::DeviceLocalMemSize () const 00521 { 00522 cl_ulong id; 00523 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(id), &id, NULL ) ); 00524 return id; 00525 } 00526 //----------------------------------------------------------------------------- 00527 cl_ulong OpenCL_Device::DeviceMaxMemAllocSize () const 00528 { 00529 cl_ulong id; 00530 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(id), &id, NULL ) ); 00531 return id; 00532 } 00533 //----------------------------------------------------------------------------- 00534 cl_uint OpenCL_Device::DeviceMemBaseAddrAlign () const 00535 { 00536 cl_uint id; 00537 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MEM_BASE_ADDR_ALIGN, sizeof(id), &id, NULL ) ); 00538 return id; 00539 } 00540 //----------------------------------------------------------------------------- 00541 cl_uint OpenCL_Device::DeviceMinDataAlignSize () const 00542 { 00543 cl_uint id; 00544 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, sizeof(id), &id, NULL ) ); 00545 return id; 00546 } 00547 //----------------------------------------------------------------------------- 00548 cl_device_fp_config OpenCL_Device::DeviceSingleFPConfig () const 00549 { 00550 cl_device_fp_config id; 00551 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_SINGLE_FP_CONFIG, sizeof(id), &id, NULL ) ); 00552 return id; 00553 } 00554 //----------------------------------------------------------------------------- 00555 std::string OpenCL_Device::StrOfDeviceSingleFPConfig () const 00556 { 00557 std::stringstream ss; 00558 cl_device_fp_config config = DeviceSingleFPConfig(); 00559 if ( config | CL_FP_DENORM ) ss << "CL_FP_DENORM "; 00560 if ( config | CL_FP_INF_NAN ) ss << "CL_FP_INF_NAN "; 00561 if ( config | CL_FP_ROUND_TO_NEAREST ) ss << "CL_FP_ROUND_TO_NEAREST "; 00562 if ( config | CL_FP_ROUND_TO_ZERO ) ss << "CL_FP_ROUND_TO_ZERO "; 00563 if ( config | CL_FP_ROUND_TO_INF ) ss << "CL_FP_ROUND_TO_INF "; 00564 if ( config | CL_FP_FMA ) ss << "CL_FP_FMA "; 00565 if ( config | CL_FP_SOFT_FLOAT ) ss << "CL_FP_SOFT_FLOAT "; 00566 return ss.str(); 00567 } 00568 //----------------------------------------------------------------------------- 00569 cl_device_mem_cache_type OpenCL_Device::DeviceGlobalMemCacheType () const 00570 { 00571 cl_device_mem_cache_type id; 00572 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, sizeof(id), &id, NULL ) ); 00573 return id; 00574 } 00575 //----------------------------------------------------------------------------- 00576 std::string OpenCL_Device::StrOfDeviceGlobalMemCacheType () const 00577 { 00578 std::stringstream ss; 00579 switch ( DeviceGlobalMemCacheType() ) 00580 { 00581 case CL_NONE: 00582 ss << "CL_NONE"; 00583 break; 00584 case CL_READ_ONLY_CACHE: 00585 ss << "CL_READ_ONLY_CACHE"; 00586 break; 00587 case CL_READ_WRITE_CACHE: 00588 ss << "CL_READ_WRITE_CACHE"; 00589 break; 00590 default: 00591 ss << "Unknown OpenCL Device Global Mem Cache Type"; 00592 break; 00593 } 00594 return ss.str(); 00595 } 00596 //----------------------------------------------------------------------------- 00597 cl_ulong OpenCL_Device::DeviceGlobalMemCacheSize () const 00598 { 00599 cl_ulong id; 00600 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, sizeof(id), &id, NULL ) ); 00601 return id; 00602 } 00603 //----------------------------------------------------------------------------- 00604 cl_uint OpenCL_Device::DeviceGlobalMemCachelineSize () const 00605 { 00606 cl_uint id; 00607 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, sizeof(id), &id, NULL ) ); 00608 return id; 00609 } 00610 //----------------------------------------------------------------------------- 00611 cl_ulong OpenCL_Device::DeviceMaxConstBufferSize () const 00612 { 00613 cl_ulong id; 00614 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(id), &id, NULL ) ); 00615 return id; 00616 } 00617 //----------------------------------------------------------------------------- 00618 cl_uint OpenCL_Device::DeviceMaxConstArgs () const 00619 { 00620 cl_uint id; 00621 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_MAX_CONSTANT_ARGS, sizeof(id), &id, NULL ) ); 00622 return id; 00623 } 00624 //----------------------------------------------------------------------------- 00625 cl_device_local_mem_type OpenCL_Device::DeviceLocalMemType () const 00626 { 00627 cl_device_local_mem_type id; 00628 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_LOCAL_MEM_TYPE, sizeof(id), &id, NULL ) ); 00629 return id; 00630 } 00631 //----------------------------------------------------------------------------- 00632 std::string OpenCL_Device::StrOfDeviceLocalMemType () const 00633 { 00634 std::stringstream ss; 00635 switch ( DeviceLocalMemType() ) 00636 { 00637 case CL_LOCAL: 00638 ss << "CL_LOCAL"; 00639 break; 00640 case CL_GLOBAL: 00641 ss << "CL_GLOBAL"; 00642 break; 00643 default: 00644 ss << "Unknown OpenCL Device Local Mem Type"; 00645 break; 00646 } 00647 return ss.str(); 00648 } 00649 //----------------------------------------------------------------------------- 00650 cl_bool OpenCL_Device::DeviceErrCorrectionSupport () const 00651 { 00652 cl_bool id; 00653 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_ERROR_CORRECTION_SUPPORT, sizeof(id), &id, NULL ) ); 00654 return id; 00655 } 00656 //----------------------------------------------------------------------------- 00657 cl_bool OpenCL_Device::DeviceHostUnifiedMem () const 00658 { 00659 cl_bool id; 00660 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_HOST_UNIFIED_MEMORY, sizeof(id), &id, NULL ) ); 00661 return id; 00662 } 00663 //----------------------------------------------------------------------------- 00664 cl_bool OpenCL_Device::DeviceAvailable () const 00665 { 00666 cl_bool id; 00667 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_AVAILABLE, sizeof(id), &id, NULL ) ); 00668 return id; 00669 } 00670 //----------------------------------------------------------------------------- 00671 cl_bool OpenCL_Device::DeviceEndainLittle () const 00672 { 00673 cl_bool id; 00674 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_ENDIAN_LITTLE, sizeof(id), &id, NULL ) ); 00675 return id; 00676 } 00677 //----------------------------------------------------------------------------- 00678 size_t OpenCL_Device::DeviceProfilingTimerResolution () const 00679 { 00680 size_t id; 00681 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof(id), &id, NULL ) ); 00682 return id; 00683 } 00684 //----------------------------------------------------------------------------- 00685 cl_bool OpenCL_Device::DeviceCompilerAvailable () const 00686 { 00687 cl_bool id; 00688 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_COMPILER_AVAILABLE, sizeof(id), &id, NULL ) ); 00689 return id; 00690 } 00691 //----------------------------------------------------------------------------- 00692 cl_device_exec_capabilities OpenCL_Device::DeviceExecCapabilities () const 00693 { 00694 cl_device_exec_capabilities id; 00695 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof(id), &id, NULL ) ); 00696 return id; 00697 } 00698 //----------------------------------------------------------------------------- 00699 std::string OpenCL_Device::StrOfDeviceExecCapabilities () const 00700 { 00701 std::stringstream ss; 00702 cl_device_exec_capabilities cap = DeviceExecCapabilities(); 00703 if ( cap | CL_EXEC_KERNEL ) ss << "CL_EXEC_KERNEL "; 00704 if ( cap | CL_EXEC_NATIVE_KERNEL ) ss << "CL_EXEC_NATIVE_KERNEL "; 00705 return ss.str(); 00706 } 00707 //----------------------------------------------------------------------------- 00708 cl_command_queue_properties OpenCL_Device::DeviceQueueProperties () const 00709 { 00710 cl_command_queue_properties id; 00711 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_QUEUE_PROPERTIES, sizeof(id), &id, NULL ) ); 00712 return id; 00713 } 00714 //----------------------------------------------------------------------------- 00715 std::string OpenCL_Device::StrOfDeviceQueueProperties () const 00716 { 00717 std::stringstream ss; 00718 cl_command_queue_properties prop = DeviceQueueProperties(); 00719 if ( prop | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE ) ss << "CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE "; 00720 if ( prop | CL_QUEUE_PROFILING_ENABLE ) ss << "CL_QUEUE_PROFILING_ENABLE "; 00721 return ss.str(); 00722 } 00723 //----------------------------------------------------------------------------- 00724 std::string OpenCL_Device::DeviceExtensions () const 00725 { 00726 char cBuffer[1024]; 00727 size_t param_value_size_ret; 00728 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceInfo( m_DeviceID, CL_DEVICE_EXTENSIONS, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00729 return std::string( cBuffer ); 00730 } 00731 //----------------------------------------------------------------------------- 00732 // OpenGL 00733 #if defined(__gl_h_) || defined(__GL_H__) 00734 //template <typename T> 00735 //void OpenCL_Device<T>::Draw () const 00736 //{ 00737 //} 00738 //----------------------------------------------------------------------------- 00739 #endif // OpenGL 00740 //----------------------------------------------------------------------------- 00741 // END CLASS: OpenCL_Device 00742 //============================================================================= 00743 00744 00745 00746 00747 //============================================================================= 00748 // START CLASS: OpenCL_Platform 00749 //----------------------------------------------------------------------------- 00750 OpenCL_Platform::OpenCL_Platform ( cl_platform_id id ) 00751 : m_PlatformID( id ) 00752 { 00753 GetOpenCLPlatformInfo(); 00754 GetListOfOpenCLDevices(); 00755 } 00756 //----------------------------------------------------------------------------- 00757 OpenCL_Platform::~OpenCL_Platform () 00758 {} 00759 //----------------------------------------------------------------------------- 00760 std::string OpenCL_Platform::StrInfo () const 00761 { 00762 std::stringstream ss; 00763 ss << "OpenCL Platform ID: " << m_PlatformID; 00764 ss << "\n OpenCL Platform Name: " << m_PlatformName; 00765 ss << "\n OpenCL Platform Version: " << m_PlatformVersion; 00766 ss << "\n OpenCL Platform Profile: " << m_PlatformProfile; 00767 ss << "\n OpenCL Platform Vendor: " << m_PlatformVendor; 00768 ss << "\n OpenCL Platform Extensions:"; 00769 std::string extensions = PlatformExtensions(); 00770 std::string delimit( "\t\n " ); 00771 size_t start = 0, end = 0; 00772 while ( extensions.size() > 0 && end < 1024 ) 00773 { 00774 start = extensions.find_first_not_of( delimit, 0 ); 00775 end = extensions.find_first_of( delimit, start ); 00776 if ( end == std::string::npos ) { 00777 if ( start != std::string::npos ) { 00778 ss << "\n " << extensions.substr( start, extensions.size()-start ); 00779 } 00780 break; 00781 } 00782 else { 00783 ss << "\n " << extensions.substr( start, end-start ); 00784 } 00785 extensions = extensions.substr( end ); 00786 } 00787 ss << "\n Number of OpenCL devices: " << NumOfOpenCLDevices(); 00788 ss << "\n"; 00789 for ( unsigned int i = 0; i < NumOfOpenCLDevices(); ++i ) { 00790 ss << "\nOpenCL Device #" << i << "\n"; 00791 ss << m_OpenCLDevices[i] << "\n"; 00792 } 00793 ss << "\n"; 00794 return ss.str(); 00795 } 00796 //----------------------------------------------------------------------------- 00797 void OpenCL_Platform::GetOpenCLPlatformInfo () 00798 { 00799 char cBuffer[1024]; 00800 size_t param_value_size_ret; 00801 00802 OpenCL_Util::CheckOpenCLErrorCode( clGetPlatformInfo( m_PlatformID, CL_PLATFORM_NAME, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00803 m_PlatformName = cBuffer; 00804 OpenCL_Util::CheckOpenCLErrorCode( clGetPlatformInfo( m_PlatformID, CL_PLATFORM_VERSION, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00805 m_PlatformVersion = cBuffer; 00806 OpenCL_Util::CheckOpenCLErrorCode( clGetPlatformInfo( m_PlatformID, CL_PLATFORM_PROFILE, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00807 m_PlatformProfile = cBuffer; 00808 OpenCL_Util::CheckOpenCLErrorCode( clGetPlatformInfo( m_PlatformID, CL_PLATFORM_VENDOR, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00809 m_PlatformVendor = cBuffer; 00810 } 00811 //----------------------------------------------------------------------------- 00812 std::string OpenCL_Platform::PlatformExtensions () const 00813 { 00814 char cBuffer[1024]; 00815 size_t param_value_size_ret; 00816 OpenCL_Util::CheckOpenCLErrorCode( clGetPlatformInfo( m_PlatformID, CL_PLATFORM_EXTENSIONS, sizeof(cBuffer), cBuffer, ¶m_value_size_ret ) ); 00817 return std::string( cBuffer ); 00818 } 00819 //----------------------------------------------------------------------------- 00820 void OpenCL_Platform::GetListOfOpenCLDevices () 00821 { 00822 const cl_uint num_entries = 1024; 00823 cl_device_id devices[num_entries]; 00824 cl_uint num_devices; 00825 OpenCL_Util::CheckOpenCLErrorCode( clGetDeviceIDs( m_PlatformID, CL_DEVICE_TYPE_ALL, num_entries, devices, &num_devices ) ); 00826 for ( unsigned int i = 0; i < num_devices; ++i ) { 00827 m_OpenCLDeviceIDs.push_back( devices[i] ); 00828 m_OpenCLDevices.push_back( OpenCL_Device( devices[i] ) ); 00829 } 00830 } 00831 //----------------------------------------------------------------------------- 00832 // OpenGL 00833 #if defined(__gl_h_) || defined(__GL_H__) 00834 //template <typename T> 00835 //void OpenCL_Platform<T>::Draw () const 00836 //{ 00837 //} 00838 //----------------------------------------------------------------------------- 00839 #endif // OpenGL 00840 //----------------------------------------------------------------------------- 00841 // END CLASS: OpenCL_Platform 00842 //============================================================================= 00843 00844 00845 //============================================================================= 00846 END_NAMESPACE_TAPs__OpenCL 00847 //34567890123456789012345678901234567890123456789012345678901234567890123456789 00848 //--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
1.7.4 
