sc/source/core/opencl/openclwrapper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <config_folders.h>
  11
  12 #include "openclwrapper.hxx"
  13
  14 #include <rtl/ustring.hxx>
  15 #include <rtl/strbuf.hxx>
  16 #include <rtl/digest.h>
  17 #include <rtl/bootstrap.hxx>
  18 #include <boost/scoped_array.hpp>
  19
  20 #include "sal/config.h"
  21 #include <osl/file.hxx>
  22 #include "opencl_device.hxx"
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <cmath>
  28
  29 #ifdef WIN32
  30 #include <windows.h>
  31 #define OPENCL_DLL_NAME "OpenCL.dll"
  32 #elif defined(MACOSX)
  33 #define OPENCL_DLL_NAME NULL
  34 #else
  35 #define OPENCL_DLL_NAME "libOpenCL.so"
  36 #endif
  37
  38 #define DEVICE_NAME_LENGTH 1024
  39 #define DRIVER_VERSION_LENGTH 1024
  40 #define PLATFORM_VERSION_LENGTH 1024
  41
  42 using namespace std;
  43
  44 namespace sc { namespace opencl {
  45
  46 GPUEnv OpenclDevice::gpuEnv;
  47 int OpenclDevice::isInited =0;
  48
  49 namespace {
  50
  51 OString generateMD5(const void* pData, size_t length)
  52 {
  53     sal_uInt8 pBuffer[RTL_DIGEST_LENGTH_MD5];
  54     rtlDigestError aError = rtl_digest_MD5(pData, length,
  55             pBuffer, RTL_DIGEST_LENGTH_MD5);
  56     SAL_WARN_IF(aError != rtl_Digest_E_None, "sc", "md5 generation failed");
  57
  58     OStringBuffer aBuffer;
  59     const char* pString = "0123456789ABCDEF";
  60     for(size_t i = 0; i < RTL_DIGEST_LENGTH_MD5; ++i)
  61     {
  62         sal_uInt8 val = pBuffer[i];
  63         aBuffer.append(pString[val/16]);
  64         aBuffer.append(pString[val%16]);
  65     }
  66     return aBuffer.makeStringAndClear();
  67 }
  68
  69 OString getCacheFolder()
  70 {
  71     OUString url("${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}/cache/");
  72     rtl::Bootstrap::expandMacros(url);
  73
  74     osl::Directory::create(url);
  75
  76     return rtl::OUStringToOString(url, RTL_TEXTENCODING_UTF8);
  77 }
  78
  79 void clearCache()
  80 {
  81 #if 0
  82     // We used to delete all files that did not end with the hash of
  83     // the static kernel source string from oclkernels.hxx. But as
  84     // those static kernels were not used for anything, it was
  85     // pointless, that hash never changed. The static kernels are now
  86     // removed, their hash is not part of the .bin file names any
  87     // more.  So there is little this function can do until we come up
  88     // with some other way to figure out which cached .bin files are
  89     // "current".
  90     OUString aCacheDirURL(rtl::OStringToOUString(OpenclDevice::maCacheFolder, RTL_TEXTENCODING_UTF8));
  91     osl::Directory aCacheDir(aCacheDirURL);
  92     osl::FileBase::RC status = aCacheDir.open();
  93     if(status != osl::FileBase::E_None)
  94         return;
  95
  96     osl::DirectoryItem aItem;
  97     while(osl::FileBase::E_None == aCacheDir.getNextItem(aItem))
  98     {
  99         osl::FileStatus aFileStatus(osl_FileStatus_Mask_FileName|osl_FileStatus_Mask_FileURL);
 100         status = aItem.getFileStatus(aFileStatus);
 101         if(status != osl::FileBase::E_None)
 102             continue;
 103
 104         OUString aFileName = aFileStatus.getFileName();
 105         if(aFileName.endsWith(".bin"))
 106         {
 107             if ( file is in some way obsolete )
 108             {
 109                 // delete the file
 110                 OUString aFileUrl = aFileStatus.getFileURL();
 111                 osl::File::remove(aFileUrl);
 112             }
 113         }
 114     }
 115 #endif
 116 }
 117
 118 }
 119
 120 OString OpenclDevice::maCacheFolder = getCacheFolder();
 121
 122 int OpenclDevice::releaseOpenclRunEnv()
 123 {
 124     releaseOpenclEnv( &gpuEnv );
 125
 126     return 1;
 127 }
 128
 129 int OpenclDevice::registOpenclKernel()
 130 {
 131     if ( !gpuEnv.mnIsUserCreated )
 132         memset( &gpuEnv, 0, sizeof(gpuEnv) );
 133
 134     return 0;
 135 }
 136
 137 int OpenclDevice::setKernelEnv( KernelEnv *envInfo )
 138 {
 139     envInfo->mpkContext = gpuEnv.mpContext;
 140     envInfo->mpkCmdQueue = gpuEnv.mpCmdQueue;
 141     envInfo->mpkProgram = gpuEnv.mpArryPrograms[0];
 142
 143     return 1;
 144 }
 145
 146 namespace {
 147
 148 OString createFileName(cl_device_id deviceId, const char* clFileName)
 149 {
 150     OString fileName(clFileName);
 151     sal_Int32 nIndex = fileName.lastIndexOf(".cl");
 152     if(nIndex > 0)
 153         fileName = fileName.copy(0, nIndex);
 154
 155     char deviceName[DEVICE_NAME_LENGTH] = {0};
 156     clGetDeviceInfo(deviceId, CL_DEVICE_NAME,
 157             sizeof(deviceName), deviceName, NULL);
 158
 159     char driverVersion[DRIVER_VERSION_LENGTH] = {0};
 160     clGetDeviceInfo(deviceId, CL_DRIVER_VERSION,
 161             sizeof(driverVersion), driverVersion, NULL);
 162
 163     cl_platform_id platformId;
 164     clGetDeviceInfo(deviceId, CL_DEVICE_PLATFORM,
 165             sizeof(platformId), &platformId, NULL);
 166
 167     char platformVersion[PLATFORM_VERSION_LENGTH] = {0};
 168     clGetPlatformInfo(platformId, CL_PLATFORM_VERSION, sizeof(platformVersion),
 169             platformVersion, NULL);
 170
 171     // create hash for deviceName + driver version + platform version
 172     OString aString = OString(deviceName) + driverVersion + platformVersion;
 173     OString aHash = generateMD5(aString.getStr(), aString.getLength());
 174
 175     return OpenclDevice::maCacheFolder + fileName + "-" +
 176         aHash + ".bin";
 177 }
 178
 179 }
 180
 181 std::vector<boost::shared_ptr<osl::File> > OpenclDevice::binaryGenerated( const char * clFileName, cl_context context )
 182 {
 183     size_t numDevices=0;
 184
 185     std::vector<boost::shared_ptr<osl::File> > aGeneratedFiles;
 186     cl_int clStatus = clGetContextInfo( context, CL_CONTEXT_DEVICES,
 187             0, NULL, &numDevices );
 188     numDevices /= sizeof(numDevices);
 189
 190     if(clStatus != CL_SUCCESS)
 191         return aGeneratedFiles;
 192
 193
 194     // grab the handles to all of the devices in the context.
 195     boost::scoped_array<cl_device_id> mpArryDevsID(new cl_device_id[numDevices]);
 196     clStatus = clGetContextInfo( context, CL_CONTEXT_DEVICES,
 197             sizeof( cl_device_id ) * numDevices, mpArryDevsID.get(), NULL );
 198
 199     if(clStatus != CL_SUCCESS)
 200         return aGeneratedFiles;
 201
 202     for ( size_t i = 0; i < numDevices; i++ )
 203     {
 204         if ( mpArryDevsID[i] != 0 )
 205         {
 206             OString fileName = createFileName(gpuEnv.mpArryDevsID[i], clFileName);
 207             osl::File* pNewFile = new osl::File(rtl::OStringToOUString(fileName, RTL_TEXTENCODING_UTF8));
 208             if(pNewFile->open(osl_File_OpenFlag_Read) == osl::FileBase::E_None)
 209             {
 210                 aGeneratedFiles.push_back(boost::shared_ptr<osl::File>(pNewFile));
 211                 SAL_INFO("sc.opencl", "Opening binary file '" << fileName << "' for reading: success");
 212             }
 213             else
 214             {
 215                 SAL_INFO("sc.opencl", "Opening binary file '" << fileName << "' for reading: FAIL");
 216                 delete pNewFile;
 217                 break;
 218             }
 219         }
 220     }
 221
 222     return aGeneratedFiles;
 223 }
 224
 225 int OpenclDevice::writeBinaryToFile( const OString& rFileName, const char* binary, size_t numBytes )
 226 {
 227     clearCache();
 228     osl::File file(rtl::OStringToOUString(rFileName, RTL_TEXTENCODING_UTF8));
 229     osl::FileBase::RC status = file.open(
 230             osl_File_OpenFlag_Write | osl_File_OpenFlag_Create );
 231
 232     if(status != osl::FileBase::E_None)
 233         return 0;
 234
 235     sal_uInt64 nBytesWritten = 0;
 236     file.write( binary, numBytes, nBytesWritten );
 237
 238     assert(numBytes == nBytesWritten);
 239
 240     return 1;
 241 }
 242
 243 int OpenclDevice::generatBinFromKernelSource( cl_program program, const char * clFileName )
 244 {
 245     cl_uint numDevices;
 246
 247     cl_int clStatus = clGetProgramInfo( program, CL_PROGRAM_NUM_DEVICES,
 248                    sizeof(numDevices), &numDevices, NULL );
 249     CHECK_OPENCL( clStatus, "clGetProgramInfo" );
 250
 251     std::vector<cl_device_id> mpArryDevsID(numDevices);
 252     /* grab the handles to all of the devices in the program. */
 253     clStatus = clGetProgramInfo( program, CL_PROGRAM_DEVICES,
 254                    sizeof(cl_device_id) * numDevices, &mpArryDevsID[0], NULL );
 255     CHECK_OPENCL( clStatus, "clGetProgramInfo" );
 256
 257     /* figure out the sizes of each of the binaries. */
 258     std::vector<size_t> binarySizes(numDevices);
 259
 260     clStatus = clGetProgramInfo( program, CL_PROGRAM_BINARY_SIZES,
 261                    sizeof(size_t) * numDevices, &binarySizes[0], NULL );
 262     CHECK_OPENCL( clStatus, "clGetProgramInfo" );
 263
 264     /* copy over all of the generated binaries. */
 265     boost::scoped_array<char*> binaries(new char*[numDevices]);
 266
 267     for ( size_t i = 0; i < numDevices; i++ )
 268     {
 269         if ( binarySizes[i] != 0 )
 270         {
 271             binaries[i] = new char[binarySizes[i]];
 272         }
 273         else
 274         {
 275             binaries[i] = NULL;
 276         }
 277     }
 278
 279     clStatus = clGetProgramInfo( program, CL_PROGRAM_BINARIES,
 280                    sizeof(char *) * numDevices, binaries.get(), NULL );
 281     CHECK_OPENCL(clStatus,"clGetProgramInfo");
 282
 283     /* dump out each binary into its own separate file. */
 284     for ( size_t i = 0; i < numDevices; i++ )
 285     {
 286
 287         if ( binarySizes[i] != 0 )
 288         {
 289             OString fileName = createFileName(mpArryDevsID[i], clFileName);
 290             if ( !writeBinaryToFile( fileName,
 291                         binaries[i], binarySizes[i] ) )
 292                 SAL_INFO("sc.opencl", "Writing binary file '" << fileName << "': FAIL");
 293             else
 294                 SAL_INFO("sc.opencl", "Writing binary file '" << fileName << "': success");
 295         }
 296     }
 297
 298     // Release all resouces and memory
 299     for ( size_t i = 0; i < numDevices; i++ )
 300     {
 301         delete[] binaries[i];
 302     }
 303
 304     return 1;
 305 }
 306
 307 int OpenclDevice::initOpenclAttr( OpenCLEnv * env )
 308 {
 309     if ( gpuEnv.mnIsUserCreated )
 310         return 1;
 311
 312     gpuEnv.mpContext = env->mpOclContext;
 313     gpuEnv.mpPlatformID = env->mpOclPlatformID;
 314     gpuEnv.mpDevID = env->mpOclDevsID;
 315     gpuEnv.mpCmdQueue = env->mpOclCmdQueue;
 316
 317     gpuEnv.mnIsUserCreated = 1;
 318
 319     return 0;
 320 }
 321
 322 int OpenclDevice::releaseOpenclEnv( GPUEnv *gpuInfo )
 323 {
 324     if ( !isInited )
 325     {
 326         return 1;
 327     }
 328
 329     if ( gpuEnv.mpCmdQueue )
 330     {
 331         clReleaseCommandQueue( gpuEnv.mpCmdQueue );
 332         gpuEnv.mpCmdQueue = NULL;
 333     }
 334     if ( gpuEnv.mpContext )
 335     {
 336         clReleaseContext( gpuEnv.mpContext );
 337         gpuEnv.mpContext = NULL;
 338     }
 339     isInited = 0;
 340     gpuInfo->mnIsUserCreated = 0;
 341     free( gpuInfo->mpArryDevsID );
 342
 343     return 1;
 344 }
 345
 346 namespace {
 347
 348 bool buildProgram(const char* buildOption, GPUEnv* gpuInfo, int idx)
 349 {
 350     cl_int clStatus;
 351     //char options[512];
 352     // create a cl program executable for all the devices specified
 353     if (!gpuInfo->mnIsUserCreated)
 354     {
 355         clStatus = clBuildProgram(gpuInfo->mpArryPrograms[idx], 1, gpuInfo->mpArryDevsID,
 356                        buildOption, NULL, NULL);
 357     }
 358     else
 359     {
 360         clStatus = clBuildProgram(gpuInfo->mpArryPrograms[idx], 1, &(gpuInfo->mpDevID),
 361                        buildOption, NULL, NULL);
 362     }
 363
 364     if ( clStatus != CL_SUCCESS )
 365     {
 366         size_t length;
 367         if ( !gpuInfo->mnIsUserCreated )
 368         {
 369             clStatus = clGetProgramBuildInfo( gpuInfo->mpArryPrograms[idx], gpuInfo->mpArryDevsID[0],
 370                            CL_PROGRAM_BUILD_LOG, 0, NULL, &length );
 371         }
 372         else
 373         {
 374             clStatus = clGetProgramBuildInfo( gpuInfo->mpArryPrograms[idx], gpuInfo->mpDevID,
 375                            CL_PROGRAM_BUILD_LOG, 0, NULL, &length);
 376         }
 377         if ( clStatus != CL_SUCCESS )
 378         {
 379             return 0;
 380         }
 381
 382         boost::scoped_array<char> buildLog(new char[length]);
 383         if ( !gpuInfo->mnIsUserCreated )
 384         {
 385             clStatus = clGetProgramBuildInfo( gpuInfo->mpArryPrograms[idx], gpuInfo->mpArryDevsID[0],
 386                            CL_PROGRAM_BUILD_LOG, length, buildLog.get(), &length );
 387         }
 388         else
 389         {
 390             clStatus = clGetProgramBuildInfo( gpuInfo->mpArryPrograms[idx], gpuInfo->mpDevID,
 391                            CL_PROGRAM_BUILD_LOG, length, buildLog.get(), &length );
 392         }
 393         if ( clStatus != CL_SUCCESS )
 394         {
 395             return false;
 396         }
 397
 398         OString aBuildLogFileURL = OpenclDevice::maCacheFolder + "kernel-build.log";
 399         osl::File aBuildLogFile(rtl::OStringToOUString(aBuildLogFileURL, RTL_TEXTENCODING_UTF8));
 400         osl::FileBase::RC status = aBuildLogFile.open(
 401                 osl_File_OpenFlag_Write | osl_File_OpenFlag_Create );
 402
 403         if(status != osl::FileBase::E_None)
 404             return false;
 405
 406         sal_uInt64 nBytesWritten = 0;
 407         aBuildLogFile.write( buildLog.get(), length, nBytesWritten );
 408
 409         return false;
 410     }
 411
 412     return true;
 413 }
 414
 415 }
 416
 417 bool OpenclDevice::buildProgramFromBinary(const char* buildOption, GPUEnv* gpuInfo, const char* filename, int idx)
 418 {
 419     size_t numDevices;
 420     cl_int clStatus = clGetContextInfo( gpuInfo->mpContext, CL_CONTEXT_DEVICES,
 421             0, NULL, &numDevices );
 422     numDevices /= sizeof(numDevices);
 423     CHECK_OPENCL( clStatus, "clGetContextInfo" );
 424
 425     std::vector<boost::shared_ptr<osl::File> > aGeneratedFiles = binaryGenerated(
 426             filename, gpuInfo->mpContext );
 427
 428     if (aGeneratedFiles.size() == numDevices)
 429     {
 430         boost::scoped_array<size_t> length(new size_t[numDevices]);
 431         boost::scoped_array<unsigned char*> pBinary(new unsigned char*[numDevices]);
 432         for(size_t i = 0; i < numDevices; ++i)
 433         {
 434             sal_uInt64 nSize;
 435             aGeneratedFiles[i]->getSize(nSize);
 436             unsigned char* binary = new unsigned char[nSize];
 437             sal_uInt64 nBytesRead;
 438             aGeneratedFiles[i]->read(binary, nSize, nBytesRead);
 439             if(nSize != nBytesRead)
 440                 assert(false);
 441
 442             length[i] = nBytesRead;
 443
 444             pBinary[i] = binary;
 445         }
 446
 447         // grab the handles to all of the devices in the context.
 448         boost::scoped_array<cl_device_id> mpArryDevsID(new cl_device_id[numDevices]);
 449         clStatus = clGetContextInfo( gpuInfo->mpContext, CL_CONTEXT_DEVICES,
 450                        sizeof( cl_device_id ) * numDevices, mpArryDevsID.get(), NULL );
 451
 452         if(clStatus != CL_SUCCESS)
 453         {
 454             for(size_t i = 0; i < numDevices; ++i)
 455             {
 456                 delete[] pBinary[i];
 457             }
 458             return false;
 459         }
 460
 461         cl_int binary_status;
 462
 463         gpuInfo->mpArryPrograms[idx] = clCreateProgramWithBinary( gpuInfo->mpContext,numDevices,
 464                                            mpArryDevsID.get(), length.get(), (const unsigned char**) pBinary.get(),
 465                                            &binary_status, &clStatus );
 466         if(clStatus != CL_SUCCESS)
 467         {
 468             // something went wrong, fall back to compiling from source
 469             return false;
 470         }
 471         for(size_t i = 0; i < numDevices; ++i)
 472         {
 473             delete[] pBinary[i];
 474         }
 475     }
 476
 477     if ( !gpuInfo->mpArryPrograms[idx] )
 478     {
 479         return false;
 480     }
 481     return buildProgram(buildOption, gpuInfo, idx);
 482 }
 483
 484 int OpenclDevice::initOpenclRunEnv( int argc )
 485 {
 486     if ( MAX_CLKERNEL_NUM <= 0 )
 487     {
 488         return 1;
 489     }
 490     if ( ( argc > MAX_CLFILE_NUM ) || ( argc < 0 ) )
 491         return 1;
 492
 493     if ( !isInited )
 494     {
 495         registOpenclKernel();
 496         //initialize devices, context, comand_queue
 497         int status = initOpenclRunEnv( &gpuEnv );
 498         if ( status )
 499         {
 500             return 1;
 501         }
 502         //initialize program, kernelName, kernelCount
 503         if( getenv( "SC_FLOAT" ) )
 504         {
 505             gpuEnv.mnKhrFp64Flag = 0;
 506             gpuEnv.mnAmdFp64Flag = 0;
 507         }
 508         if( gpuEnv.mnKhrFp64Flag )
 509         {
 510             SAL_INFO("sc.opencl", "Use Khr double");
 511         }
 512         else if( gpuEnv.mnAmdFp64Flag )
 513         {
 514             SAL_INFO("sc.opencl", "Use AMD double type");
 515         }
 516         else
 517         {
 518             SAL_INFO("sc.opencl", "USE float type");
 519         }
 520         isInited = 1;
 521     }
 522     return 0;
 523 }
 524
 525 namespace {
 526
 527 void checkDeviceForDoubleSupport(cl_device_id deviceId, bool& bKhrFp64, bool& bAmdFp64)
 528 {
 529     bKhrFp64 = false;
 530     bAmdFp64 = false;
 531
 532     // Check device extensions for double type
 533     size_t aDevExtInfoSize = 0;
 534
 535     cl_uint clStatus = clGetDeviceInfo( deviceId, CL_DEVICE_EXTENSIONS, 0, NULL, &aDevExtInfoSize );
 536     if( clStatus != CL_SUCCESS )
 537         return;
 538
 539     boost::scoped_array<char> pExtInfo(new char[aDevExtInfoSize]);
 540
 541     clStatus = clGetDeviceInfo( deviceId, CL_DEVICE_EXTENSIONS,
 542                    sizeof(char) * aDevExtInfoSize, pExtInfo.get(), NULL);
 543
 544     if( clStatus != CL_SUCCESS )
 545         return;
 546
 547     if ( strstr( pExtInfo.get(), "cl_khr_fp64" ) )
 548     {
 549         bKhrFp64 = true;
 550     }
 551     else
 552     {
 553         // Check if cl_amd_fp64 extension is supported
 554         if ( strstr( pExtInfo.get(), "cl_amd_fp64" ) )
 555             bAmdFp64 = true;
 556     }
 557 }
 558
 559 }
 560
 561 int OpenclDevice::initOpenclRunEnv( GPUEnv *gpuInfo )
 562 {
 563     size_t length;
 564     cl_int clStatus;
 565     cl_uint numPlatforms, numDevices;
 566     cl_platform_id *platforms;
 567
 568     // Have a look at the available platforms.
 569
 570     if ( !gpuInfo->mnIsUserCreated )
 571     {
 572         clStatus = clGetPlatformIDs( 0, NULL, &numPlatforms );
 573         CHECK_OPENCL(clStatus, "clGetPlatformIDs");
 574         gpuInfo->mpPlatformID = NULL;
 575
 576         if ( 0 < numPlatforms )
 577         {
 578             char platformName[256];
 579             platforms = (cl_platform_id*) malloc( numPlatforms * sizeof( cl_platform_id ) );
 580             if (!platforms)
 581             {
 582                 return 1;
 583             }
 584             clStatus = clGetPlatformIDs( numPlatforms, platforms, NULL );
 585             CHECK_OPENCL(clStatus, "clGetPlatformIDs");
 586
 587             for ( unsigned int i = 0; i < numPlatforms; i++ )
 588             {
 589                 clStatus = clGetPlatformInfo( platforms[i], CL_PLATFORM_VENDOR,
 590                     sizeof( platformName ), platformName, NULL );
 591
 592                 if ( clStatus != CL_SUCCESS )
 593                 {
 594                     break;
 595                 }
 596                 gpuInfo->mpPlatformID = platforms[i];
 597
 598                 //if (!strcmp(platformName, "Intel(R) Coporation"))
 599                 //if( !strcmp( platformName, "Advanced Micro Devices, Inc." ))
 600                 {
 601                     gpuInfo->mpPlatformID = platforms[i];
 602                     if ( getenv("SC_OPENCLCPU") )
 603                     {
 604                         clStatus = clGetDeviceIDs(gpuInfo->mpPlatformID, // platform
 605                                                   CL_DEVICE_TYPE_CPU,    // device_type for CPU device
 606                                                   0,                     // num_entries
 607                                                   NULL,                  // devices
 608                                                   &numDevices);
 609                     }
 610                     else
 611                     {
 612                           clStatus = clGetDeviceIDs(gpuInfo->mpPlatformID, // platform
 613                                                   CL_DEVICE_TYPE_GPU,      // device_type for GPU device
 614                                                   0,                       // num_entries
 615                                                   NULL,                    // devices
 616                                                   &numDevices);
 617                     }
 618                     if ( clStatus != CL_SUCCESS )
 619                         continue;
 620
 621                     if ( numDevices )
 622                         break;
 623                 }
 624             }
 625             free( platforms );
 626             if ( clStatus != CL_SUCCESS )
 627                 return 1;
 628         }
 629         if ( NULL == gpuInfo->mpPlatformID )
 630             return 1;
 631
 632         // Use available platform.
 633         cl_context_properties cps[3];
 634         cps[0] = CL_CONTEXT_PLATFORM;
 635         cps[1] = (cl_context_properties) gpuInfo->mpPlatformID;
 636         cps[2] = 0;
 637         // Set device type for OpenCL
 638         if ( getenv("SC_OPENCLCPU") )
 639         {
 640             gpuInfo->mDevType = CL_DEVICE_TYPE_CPU;
 641         }
 642         else
 643         {
 644             gpuInfo->mDevType = CL_DEVICE_TYPE_GPU;
 645         }
 646         gpuInfo->mpContext = clCreateContextFromType( cps, gpuInfo->mDevType, NULL, NULL, &clStatus );
 647
 648         if ( ( gpuInfo->mpContext == (cl_context) NULL) || ( clStatus != CL_SUCCESS ) )
 649         {
 650             gpuInfo->mDevType = CL_DEVICE_TYPE_CPU;
 651             gpuInfo->mpContext = clCreateContextFromType( cps, gpuInfo->mDevType, NULL, NULL, &clStatus );
 652         }
 653         if ( ( gpuInfo->mpContext == (cl_context) NULL) || ( clStatus != CL_SUCCESS ) )
 654         {
 655             gpuInfo->mDevType = CL_DEVICE_TYPE_DEFAULT;
 656             gpuInfo->mpContext = clCreateContextFromType( cps, gpuInfo->mDevType, NULL, NULL, &clStatus );
 657         }
 658         if ( ( gpuInfo->mpContext == (cl_context) NULL) || ( clStatus != CL_SUCCESS ) )
 659             return 1;
 660         // Detect OpenCL devices.
 661         // First, get the size of device list data
 662         clStatus = clGetContextInfo( gpuInfo->mpContext, CL_CONTEXT_DEVICES, 0, NULL, &length );
 663         if ( ( clStatus != CL_SUCCESS ) || ( length == 0 ) )
 664             return 1;
 665         // Now allocate memory for device list based on the size we got earlier
 666         gpuInfo->mpArryDevsID = (cl_device_id*) malloc( length );
 667         if ( gpuInfo->mpArryDevsID == (cl_device_id*) NULL )
 668             return 1;
 669         // Now, get the device list data
 670         clStatus = clGetContextInfo( gpuInfo->mpContext, CL_CONTEXT_DEVICES, length,
 671                        gpuInfo->mpArryDevsID, NULL );
 672         CHECK_OPENCL(clStatus, "clGetContextInfo");
 673
 674         // Create OpenCL command queue.
 675         gpuInfo->mpCmdQueue = clCreateCommandQueue( gpuInfo->mpContext, gpuInfo->mpArryDevsID[0], 0, &clStatus );
 676
 677         CHECK_OPENCL(clStatus, "clCreateCommandQueue");
 678     }
 679     bool bKhrFp64 = false;
 680     bool bAmdFp64 = false;
 681
 682     checkDeviceForDoubleSupport(gpuInfo->mpArryDevsID[0], bKhrFp64, bAmdFp64);
 683
 684     gpuInfo->mnKhrFp64Flag = bKhrFp64;
 685     gpuInfo->mnAmdFp64Flag = bAmdFp64;
 686
 687     return 0;
 688 }
 689
 690 void OpenclDevice::setOpenclState( int state )
 691 {
 692     isInited = state;
 693 }
 694
 695 int OpenclDevice::getOpenclState()
 696 {
 697     return isInited;
 698 }
 699
 700 namespace {
 701
 702 // based on crashes and hanging during kernel compilation
 703 bool checkForKnownBadCompilers(const OpenclDeviceInfo& rInfo)
 704 {
 705
 706     struct {
 707         const char* pVendorName; const char* pDriverVersion;
 708     } aBadOpenCLCompilers[] = {
 709         { "Intel(R) Corporation", "9.17.10.2884" }
 710     };
 711
 712     for(size_t i = 0; i < SAL_N_ELEMENTS(aBadOpenCLCompilers); ++i)
 713     {
 714         if(rInfo.maVendor == OUString::createFromAscii(aBadOpenCLCompilers[i].pVendorName) &&
 715                 rInfo.maDriver == OUString::createFromAscii(aBadOpenCLCompilers[i].pDriverVersion))
 716             return true;
 717     }
 718
 719     return false;
 720 }
 721
 722 void createDeviceInfo(cl_device_id aDeviceId, OpenclPlatformInfo& rPlatformInfo)
 723 {
 724     OpenclDeviceInfo aDeviceInfo;
 725     aDeviceInfo.device = aDeviceId;
 726
 727     char pName[DEVICE_NAME_LENGTH];
 728     cl_int nState = clGetDeviceInfo(aDeviceId, CL_DEVICE_NAME, DEVICE_NAME_LENGTH, pName, NULL);
 729     if(nState != CL_SUCCESS)
 730         return;
 731
 732     aDeviceInfo.maName = OUString::createFromAscii(pName);
 733
 734     char pVendor[DEVICE_NAME_LENGTH];
 735     nState = clGetDeviceInfo(aDeviceId, CL_DEVICE_VENDOR, DEVICE_NAME_LENGTH, pVendor, NULL);
 736     if(nState != CL_SUCCESS)
 737         return;
 738
 739     aDeviceInfo.maVendor = OUString::createFromAscii(pVendor);
 740
 741     cl_ulong nMemSize;
 742     nState = clGetDeviceInfo(aDeviceId, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(nMemSize), &nMemSize, NULL);
 743     if(nState != CL_SUCCESS)
 744         return;
 745
 746     aDeviceInfo.mnMemory = nMemSize;
 747
 748     cl_uint nClockFrequency;
 749     nState = clGetDeviceInfo(aDeviceId, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(nClockFrequency), &nClockFrequency, NULL);
 750     if(nState != CL_SUCCESS)
 751         return;
 752
 753     aDeviceInfo.mnFrequency = nClockFrequency;
 754
 755     cl_uint nComputeUnits;
 756     nState = clGetDeviceInfo(aDeviceId, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(nComputeUnits), &nComputeUnits, NULL);
 757     if(nState != CL_SUCCESS)
 758         return;
 759
 760     char pDriver[DEVICE_NAME_LENGTH];
 761     nState = clGetDeviceInfo(aDeviceId, CL_DRIVER_VERSION, DEVICE_NAME_LENGTH, pDriver, NULL);
 762
 763     if(nState != CL_SUCCESS)
 764         return;
 765
 766     aDeviceInfo.maDriver = OUString::createFromAscii(pDriver);
 767
 768     bool bKhrFp64 = false;
 769     bool bAmdFp64 = false;
 770     checkDeviceForDoubleSupport(aDeviceId, bKhrFp64, bAmdFp64);
 771
 772     // only list devices that support double
 773     if(!bKhrFp64 && !bAmdFp64)
 774         return;
 775
 776     aDeviceInfo.mnComputeUnits = nComputeUnits;
 777
 778     if(!checkForKnownBadCompilers(aDeviceInfo))
 779         rPlatformInfo.maDevices.push_back(aDeviceInfo);
 780 }
 781
 782 bool createPlatformInfo(cl_platform_id nPlatformId, OpenclPlatformInfo& rPlatformInfo)
 783 {
 784     rPlatformInfo.platform = nPlatformId;
 785     char pName[64];
 786     cl_int nState = clGetPlatformInfo(nPlatformId, CL_PLATFORM_NAME, 64,
 787              pName, NULL);
 788     if(nState != CL_SUCCESS)
 789         return false;
 790     rPlatformInfo.maName = OUString::createFromAscii(pName);
 791
 792     char pVendor[64];
 793     nState = clGetPlatformInfo(nPlatformId, CL_PLATFORM_VENDOR, 64,
 794              pVendor, NULL);
 795     if(nState != CL_SUCCESS)
 796         return false;
 797
 798     rPlatformInfo.maVendor = OUString::createFromAscii(pName);
 799
 800     cl_uint nDevices;
 801     nState = clGetDeviceIDs(nPlatformId, CL_DEVICE_TYPE_ALL, 0, NULL, &nDevices);
 802     if(nState != CL_SUCCESS)
 803         return false;
 804
 805     // memory leak that does not matter
 806     // memory is stored in static variable that lives through the whole program
 807     cl_device_id* pDevices = new cl_device_id[nDevices];
 808     nState = clGetDeviceIDs(nPlatformId, CL_DEVICE_TYPE_ALL, nDevices, pDevices, NULL);
 809     if(nState != CL_SUCCESS)
 810         return false;
 811
 812     for(size_t i = 0; i < nDevices; ++i)
 813     {
 814         createDeviceInfo(pDevices[i], rPlatformInfo);
 815     }
 816
 817     return true;
 818 }
 819
 820 }
 821
 822 size_t getOpenCLPlatformCount()
 823 {
 824     int status = clewInit(OPENCL_DLL_NAME);
 825     if (status < 0)
 826         return 0;
 827
 828     cl_uint nPlatforms;
 829     cl_int nState = clGetPlatformIDs(0, NULL, &nPlatforms);
 830
 831     if (nState != CL_SUCCESS)
 832         return 0;
 833
 834     return nPlatforms;
 835 }
 836
 837 const std::vector<OpenclPlatformInfo>& fillOpenCLInfo()
 838 {
 839     static std::vector<OpenclPlatformInfo> aPlatforms;
 840     if(!aPlatforms.empty())
 841         return aPlatforms;
 842
 843     int status = clewInit(OPENCL_DLL_NAME);
 844     if (status < 0)
 845         return aPlatforms;
 846
 847     cl_uint nPlatforms;
 848     cl_int nState = clGetPlatformIDs(0, NULL, &nPlatforms);
 849
 850     if(nState != CL_SUCCESS)
 851         return aPlatforms;
 852
 853     // memory leak that does not matter,
 854     // memory is stored in static instance aPlatforms
 855     cl_platform_id* pPlatforms = new cl_platform_id[nPlatforms];
 856     nState = clGetPlatformIDs(nPlatforms, pPlatforms, NULL);
 857
 858     if(nState != CL_SUCCESS)
 859         return aPlatforms;
 860
 861     for(size_t i = 0; i < nPlatforms; ++i)
 862     {
 863         OpenclPlatformInfo aPlatformInfo;
 864         if(createPlatformInfo(pPlatforms[i], aPlatformInfo))
 865             aPlatforms.push_back(aPlatformInfo);
 866     }
 867
 868     return aPlatforms;
 869 }
 870
 871 namespace {
 872
 873 cl_device_id findDeviceIdByDeviceString(const OUString& rString, const std::vector<OpenclPlatformInfo>& rPlatforms)
 874 {
 875     std::vector<OpenclPlatformInfo>::const_iterator it = rPlatforms.begin(), itEnd = rPlatforms.end();
 876     for(; it != itEnd; ++it)
 877     {
 878         std::vector<OpenclDeviceInfo>::const_iterator itr = it->maDevices.begin(), itrEnd = it->maDevices.end();
 879         for(; itr != itrEnd; ++itr)
 880         {
 881             OUString aDeviceId = it->maVendor + " " + itr->maName;
 882             if(rString == aDeviceId)
 883             {
 884                 return static_cast<cl_device_id>(itr->device);
 885             }
 886         }
 887     }
 888
 889     return NULL;
 890 }
 891
 892 void findDeviceInfoFromDeviceId(cl_device_id aDeviceId, size_t& rDeviceId, size_t& rPlatformId)
 893 {
 894     cl_platform_id platformId;
 895     cl_int nState = clGetDeviceInfo(aDeviceId, CL_DEVICE_PLATFORM,
 896             sizeof(platformId), &platformId, NULL);
 897
 898     if(nState != CL_SUCCESS)
 899         return;
 900
 901     const std::vector<OpenclPlatformInfo>& rPlatforms = fillOpenCLInfo();
 902     for(size_t i = 0; i < rPlatforms.size(); ++i)
 903     {
 904         cl_platform_id platId = static_cast<cl_platform_id>(rPlatforms[i].platform);
 905         if(platId != platformId)
 906             continue;
 907
 908         for(size_t j = 0; j < rPlatforms[i].maDevices.size(); ++j)
 909         {
 910             cl_device_id id = static_cast<cl_device_id>(rPlatforms[i].maDevices[j].device);
 911             if(id == aDeviceId)
 912             {
 913                 rDeviceId = j;
 914                 rPlatformId = i;
 915                 return;
 916             }
 917         }
 918     }
 919 }
 920
 921 }
 922
 923 bool switchOpenclDevice(const OUString* pDevice, bool bAutoSelect, bool bForceEvaluation)
 924 {
 925     cl_device_id pDeviceId = NULL;
 926     if(pDevice)
 927         pDeviceId = findDeviceIdByDeviceString(*pDevice, fillOpenCLInfo());
 928
 929     if(!pDeviceId || bAutoSelect)
 930     {
 931         int status = clewInit(OPENCL_DLL_NAME);
 932         if (status < 0)
 933             return false;
 934
 935         OUString url("${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}/cache/");
 936         rtl::Bootstrap::expandMacros(url);
 937         OUString path;
 938         osl::FileBase::getSystemPathFromFileURL(url,path);
 939         OString dsFileName = rtl::OUStringToOString(path, RTL_TEXTENCODING_UTF8);
 940         ds_device pSelectedDevice = sc::OpenCLDevice::getDeviceSelection(dsFileName.getStr(), bForceEvaluation);
 941         pDeviceId = pSelectedDevice.oclDeviceID;
 942
 943     }
 944
 945     if(OpenclDevice::gpuEnv.mpDevID == pDeviceId)
 946     {
 947         // we don't need to change anything
 948         // still the same device
 949         return pDeviceId != NULL;
 950     }
 951
 952     cl_platform_id platformId;
 953     cl_int nState = clGetDeviceInfo(pDeviceId, CL_DEVICE_PLATFORM,
 954             sizeof(platformId), &platformId, NULL);
 955
 956     cl_context_properties cps[3];
 957     cps[0] = CL_CONTEXT_PLATFORM;
 958     cps[1] = (cl_context_properties) platformId;
 959     cps[2] = 0;
 960     cl_context context = clCreateContext( cps, 1, &pDeviceId, NULL, NULL, &nState );
 961
 962     if(nState != CL_SUCCESS || context == NULL)
 963     {
 964         if(context != NULL)
 965             clReleaseContext(context);
 966
 967         SAL_WARN("sc", "failed to set/switch opencl device");
 968         return false;
 969     }
 970
 971     cl_command_queue command_queue = clCreateCommandQueue(
 972             context, pDeviceId, 0, &nState);
 973
 974     if(command_queue == NULL || nState != CL_SUCCESS)
 975     {
 976         if(command_queue != NULL)
 977             clReleaseCommandQueue(command_queue);
 978
 979         clReleaseContext(context);
 980         SAL_WARN("sc", "failed to set/switch opencl device");
 981         return false;
 982     }
 983
 984     OpenclDevice::releaseOpenclEnv(&OpenclDevice::gpuEnv);
 985     OpenCLEnv env;
 986     env.mpOclPlatformID = platformId;
 987     env.mpOclContext = context;
 988     env.mpOclDevsID = pDeviceId;
 989     env.mpOclCmdQueue = command_queue;
 990     OpenclDevice::initOpenclAttr(&env);
 991
 992     // why do we need this at all?
 993     OpenclDevice::gpuEnv.mpArryDevsID = (cl_device_id*) malloc( sizeof(cl_device_id) );
 994     OpenclDevice::gpuEnv.mpArryDevsID[0] = pDeviceId;
 995     return !OpenclDevice::initOpenclRunEnv(0);
 996 }
 997
 998 void getOpenCLDeviceInfo(size_t& rDeviceId, size_t& rPlatformId)
 999 {
1000     int status = clewInit(OPENCL_DLL_NAME);
1001     if (status < 0)
1002         return;
1003
1004     cl_device_id id = OpenclDevice::gpuEnv.mpDevID;
1005     findDeviceInfoFromDeviceId(id, rDeviceId, rPlatformId);
1006 }
1007
1008 }}
1009
1010 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */