opencl/inc/opencl_device_selection.h

   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 #ifndef INCLUDED_OPENCL_INC_OPENCL_DEVICE_SELECTION_H
  11 #define INCLUDED_OPENCL_INC_OPENCL_DEVICE_SELECTION_H
  12
  13 #ifdef _MSC_VER
  14 #define _CRT_SECURE_NO_WARNINGS
  15 #endif
  16
  17 #include <stdlib.h>
  18 #include <stdio.h>
  19 #include <string.h>
  20
  21 #include <clew/clew.h>
  22 #include <libxml/xmlwriter.h>
  23 #include <libxml/xmlstring.h>
  24 #include <tools/stream.hxx>
  25 #include <rtl/math.hxx>
  26
  27 #include <opencl/OpenCLZone.hxx>
  28
  29 #include <vector>
  30
  31 enum ds_status
  32 {
  33     DS_SUCCESS = 0
  34     ,DS_INVALID_PROFILE = 1000
  35     ,DS_MEMORY_ERROR
  36     , DS_INVALID_PERF_EVALUATOR_TYPE
  37     , DS_INVALID_PERF_EVALUATOR
  38     , DS_PERF_EVALUATOR_ERROR
  39     , DS_FILE_ERROR
  40     , DS_UNKNOWN_DEVICE_TYPE
  41     , DS_PROFILE_FILE_ERROR
  42     , DS_SCORE_SERIALIZER_ERROR
  43     , DS_SCORE_DESERIALIZER_ERROR
  44 };
  45
  46 // device type
  47 enum class DeviceType
  48 {
  49     None,
  50     NativeCPU,
  51     OpenCLDevice
  52 };
  53
  54 struct ds_device
  55 {
  56     DeviceType eType;
  57     cl_device_id aDeviceID;
  58
  59     OString sPlatformName;
  60     OString sPlatformVendor;
  61     OString sPlatformVersion;
  62     OString sPlatformProfile;
  63     OString sPlatformExtensions;
  64
  65     OString sDeviceName;
  66     OString sDeviceVendor;
  67     OString sDeviceVersion;
  68     OString sDriverVersion;
  69     OString sDeviceType;
  70     OString sDeviceExtensions;
  71     OString sDeviceOpenCLVersion;
  72
  73     bool bDeviceAvailable;
  74     bool bDeviceCompilerAvailable;
  75     bool bDeviceLinkerAvailable;
  76
  77     double fTime;   // small time means faster device
  78     bool   bErrors; // were there any opencl errors
  79 };
  80
  81 struct ds_profile
  82 {
  83     std::vector<ds_device> devices;
  84     OString version;
  85
  86     ds_profile(OString& inVersion)
  87         : version(inVersion)
  88     {}
  89 };
  90
  91 inline OString getPlatformInfoString(cl_platform_id aPlatformId, cl_platform_info aPlatformInfo)
  92 {
  93     std::vector<char> temporary(2048, 0);
  94     clGetPlatformInfo(aPlatformId, aPlatformInfo, temporary.size(), temporary.data(), nullptr);
  95     return OString(temporary.data());
  96 }
  97
  98 inline OString getDeviceInfoString(cl_device_id aDeviceId, cl_device_info aDeviceInfo)
  99 {
 100     std::vector<char> temporary(2048, 0);
 101     clGetDeviceInfo(aDeviceId, aDeviceInfo, temporary.size(), temporary.data(), nullptr);
 102     return OString(temporary.data());
 103 }
 104
 105 inline OString getDeviceType(cl_device_id aDeviceId)
 106 {
 107     OString sType = "";
 108     cl_device_type aDeviceType;
 109     clGetDeviceInfo(aDeviceId, CL_DEVICE_TYPE, sizeof(aDeviceType), &aDeviceType, nullptr);
 110     if (aDeviceType & CL_DEVICE_TYPE_CPU)
 111         sType += "cpu ";
 112     if (aDeviceType & CL_DEVICE_TYPE_GPU)
 113         sType += "gpu ";
 114     if (aDeviceType & CL_DEVICE_TYPE_ACCELERATOR)
 115         sType += "accelerator ";
 116     if (aDeviceType & CL_DEVICE_TYPE_CUSTOM)
 117         sType += "custom ";
 118     if (aDeviceType & CL_DEVICE_TYPE_DEFAULT)
 119         sType += "default ";
 120     return sType;
 121 }
 122
 123 inline bool getDeviceInfoBool(cl_device_id aDeviceId, cl_device_info aDeviceInfo)
 124 {
 125     cl_bool bCLBool;
 126     clGetDeviceInfo(aDeviceId, aDeviceInfo, sizeof(bCLBool), &bCLBool, nullptr);
 127     return bCLBool == CL_TRUE;
 128 }
 129
 130 inline ds_status initDSProfile(std::unique_ptr<ds_profile>& rProfile, OString rVersion)
 131 {
 132     OpenCLZone zone;
 133
 134     int numDevices;
 135     cl_uint numPlatforms;
 136     std::vector<cl_platform_id> platforms;
 137     std::vector<cl_device_id> devices;
 138
 139     unsigned int next;
 140     unsigned int i;
 141
 142     rProfile = std::unique_ptr<ds_profile>(new ds_profile(rVersion));
 143
 144     clGetPlatformIDs(0, NULL, &numPlatforms);
 145     if (numPlatforms != 0)
 146     {
 147         platforms.resize(numPlatforms);
 148         clGetPlatformIDs(numPlatforms, platforms.data(), NULL);
 149     }
 150
 151     numDevices = 0;
 152     for (i = 0; i < (unsigned int)numPlatforms; i++)
 153     {
 154         cl_uint num = 0;
 155         cl_int err = clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_ALL, 0, NULL, &num);
 156         if (err != CL_SUCCESS)
 157         {
 158             /* we want to catch at least the case when the call returns
 159              * CL_DEVICE_NOT_FOUND (i.e. no devices), because some platforms
 160              * don't set num to 0 in this case; but in fact this is a good
 161              * thing to do for _any_ error returned by the call
 162              */
 163             num = 0;
 164         }
 165         numDevices += num;
 166     }
 167
 168     if (numDevices != 0)
 169     {
 170         devices.resize(numDevices);
 171     }
 172
 173     rProfile->devices.resize(numDevices + 1); // +1 to numDevices to include the native CPU
 174
 175     next = 0;
 176     for (i = 0; i < (unsigned int)numPlatforms; i++)
 177     {
 178         cl_uint num = 0;
 179         unsigned j;
 180
 181         OString sPlatformProfile = getPlatformInfoString(platforms[i], CL_PLATFORM_PROFILE);
 182         OString sPlatformVersion = getPlatformInfoString(platforms[i], CL_PLATFORM_VERSION);
 183         OString sPlatformName    = getPlatformInfoString(platforms[i], CL_PLATFORM_NAME);
 184         OString sPlatformVendor  = getPlatformInfoString(platforms[i], CL_PLATFORM_VENDOR);
 185         OString sPlatformExts    = getPlatformInfoString(platforms[i], CL_PLATFORM_EXTENSIONS);
 186
 187         cl_int err = clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_ALL, numDevices, devices.data(), &num);
 188         if (err != CL_SUCCESS)
 189         {
 190             /* we want to catch at least the case when the call returns
 191              * CL_DEVICE_NOT_FOUND (i.e. no devices), because some platforms
 192              * don't set num to 0 in this case; but in fact this is a good
 193              * thing to do for _any_ error returned by the call
 194              */
 195             num = 0;
 196         }
 197         for (j = 0; j < num; j++, next++)
 198         {
 199             cl_device_id aDeviceID = devices[j];
 200
 201             ds_device& rDevice = rProfile->devices[next];
 202             rDevice.eType = DeviceType::OpenCLDevice;
 203             rDevice.aDeviceID = aDeviceID;
 204
 205             rDevice.sPlatformName         = sPlatformName;
 206             rDevice.sPlatformVendor       = sPlatformVendor;
 207             rDevice.sPlatformVersion      = sPlatformVersion;
 208             rDevice.sPlatformProfile      = sPlatformProfile;
 209             rDevice.sPlatformExtensions   = sPlatformExts;
 210
 211             rDevice.sDeviceName       = getDeviceInfoString(aDeviceID, CL_DEVICE_NAME);
 212             rDevice.sDeviceVendor     = getDeviceInfoString(aDeviceID, CL_DEVICE_VENDOR);
 213             rDevice.sDeviceVersion    = getDeviceInfoString(aDeviceID, CL_DEVICE_VERSION);
 214             rDevice.sDriverVersion    = getDeviceInfoString(aDeviceID, CL_DRIVER_VERSION);
 215             rDevice.sDeviceType       = getDeviceType(aDeviceID);
 216             rDevice.sDeviceExtensions = getDeviceInfoString(aDeviceID, CL_DEVICE_EXTENSIONS);
 217             rDevice.sDeviceOpenCLVersion = getDeviceInfoString(aDeviceID, CL_DEVICE_OPENCL_C_VERSION);
 218
 219             rDevice.bDeviceAvailable         = getDeviceInfoBool(aDeviceID, CL_DEVICE_AVAILABLE);
 220             rDevice.bDeviceCompilerAvailable = getDeviceInfoBool(aDeviceID, CL_DEVICE_COMPILER_AVAILABLE);
 221             rDevice.bDeviceLinkerAvailable   = getDeviceInfoBool(aDeviceID, CL_DEVICE_LINKER_AVAILABLE);
 222         }
 223     }
 224     rProfile->devices[next].eType = DeviceType::NativeCPU;
 225
 226     return DS_SUCCESS;
 227 }
 228
 229 namespace
 230 {
 231
 232 /**
 233  * XmlWriter writes a XML to a SvStream. It uses libxml2 for writing but hides
 234  * all the internal libxml2 workings and uses types that are native for LO
 235  * development.
 236  *
 237  * The codepage used for XML is always "utf-8" and the output is indented so it
 238  * is easier to read.
 239  *
 240  * TODO: move to common code
 241  */
 242 class XmlWriter
 243 {
 244 private:
 245     SvStream* mpStream;
 246     xmlTextWriterPtr mpWriter;
 247
 248     static int funcWriteCallback(void* pContext, const char* sBuffer, int nLen)
 249     {
 250         SvStream* pStream = static_cast<SvStream*>(pContext);
 251         return static_cast<int>(pStream->Write(sBuffer, nLen));
 252     }
 253
 254     static int funcCloseCallback(void* pContext)
 255     {
 256         SvStream* pStream = static_cast<SvStream*>(pContext);
 257         pStream->Flush();
 258         return 0; // 0 or -1 in case of error
 259     }
 260
 261 public:
 262
 263     XmlWriter(SvStream* pStream)
 264         : mpStream(pStream)
 265         , mpWriter(nullptr)
 266     {
 267     }
 268
 269     ~XmlWriter()
 270     {
 271         if (mpWriter != nullptr)
 272             endDocument();
 273     }
 274
 275     bool startDocument()
 276     {
 277         xmlOutputBufferPtr xmlOutBuffer = xmlOutputBufferCreateIO(funcWriteCallback, funcCloseCallback, mpStream, nullptr);
 278         mpWriter = xmlNewTextWriter(xmlOutBuffer);
 279         if (mpWriter == nullptr)
 280             return false;
 281         xmlTextWriterSetIndent(mpWriter, 1);
 282         xmlTextWriterStartDocument(mpWriter, nullptr, "UTF-8", nullptr);
 283         return true;
 284     }
 285
 286     void endDocument()
 287     {
 288         xmlTextWriterEndDocument(mpWriter);
 289         xmlFreeTextWriter(mpWriter);
 290         mpWriter = nullptr;
 291     }
 292
 293     void startElement(const OString& sName)
 294     {
 295         xmlChar* xmlName = xmlCharStrdup(sName.getStr());
 296         xmlTextWriterStartElement(mpWriter, xmlName);
 297         xmlFree(xmlName);
 298     }
 299
 300     void endElement()
 301     {
 302         xmlTextWriterEndElement(mpWriter);
 303     }
 304
 305     void content(const OString& sValue)
 306     {
 307         xmlChar* xmlValue = xmlCharStrdup(sValue.getStr());
 308         xmlTextWriterWriteString(mpWriter, xmlValue);
 309         xmlFree(xmlValue);
 310     }
 311 };
 312
 313 /**
 314  * XmlWalker main purpose is to make it easier for walking the
 315  * parsed XML DOM tree.
 316  *
 317  * It hides all the libxml2 and C -isms and makes the useage more
 318  * comfortable from LO developer point of view.
 319  *
 320  * TODO: move to common code
 321  */
 322 class XmlWalker
 323 {
 324 private:
 325     xmlDocPtr mpDocPtr;
 326     xmlNodePtr mpRoot;
 327     xmlNodePtr mpCurrent;
 328
 329     std::vector<xmlNodePtr> mpStack;
 330
 331 public:
 332     XmlWalker()
 333         : mpDocPtr(nullptr)
 334         , mpRoot(nullptr)
 335         , mpCurrent(nullptr)
 336     {}
 337
 338     ~XmlWalker()
 339     {
 340         xmlFreeDoc(mpDocPtr);
 341     }
 342
 343     bool open(SvStream* pStream)
 344     {
 345         sal_Size nSize = pStream->remainingSize();
 346         std::vector<sal_uInt8> aBuffer(nSize + 1);
 347         pStream->Read(aBuffer.data(), nSize);
 348         aBuffer[nSize] = 0;
 349         mpDocPtr = xmlParseDoc(reinterpret_cast<xmlChar*>(aBuffer.data()));
 350         if (mpDocPtr == nullptr)
 351             return false;
 352         mpRoot = xmlDocGetRootElement(mpDocPtr);
 353         mpCurrent = mpRoot;
 354         mpStack.push_back(mpCurrent);
 355         return true;
 356     }
 357
 358     OString name()
 359     {
 360         return OString(reinterpret_cast<const char*>(mpCurrent->name));
 361     }
 362
 363     OString content()
 364     {
 365         OString aContent;
 366         if (mpCurrent->xmlChildrenNode != nullptr)
 367         {
 368             xmlChar* pContent = xmlNodeListGetString(mpDocPtr, mpCurrent->xmlChildrenNode, 1);
 369             aContent = OString(reinterpret_cast<const char*>(pContent));
 370             xmlFree(pContent);
 371         }
 372         return aContent;
 373     }
 374
 375     void children()
 376     {
 377         mpStack.push_back(mpCurrent);
 378         mpCurrent = mpCurrent->xmlChildrenNode;
 379     }
 380
 381     void parent()
 382     {
 383         mpCurrent = mpStack.back();
 384         mpStack.pop_back();
 385     }
 386
 387     void next()
 388     {
 389         mpCurrent = mpCurrent->next;
 390     }
 391
 392     bool isValid()
 393     {
 394         return mpCurrent != nullptr;
 395     }
 396 };
 397
 398 } // end anonymous namespace
 399
 400 inline ds_status writeProfile(const OUString& rStreamName, std::unique_ptr<ds_profile>& pProfile)
 401 {
 402     if (pProfile == nullptr)
 403         return DS_INVALID_PROFILE;
 404     if (rStreamName.isEmpty())
 405         return DS_INVALID_PROFILE;
 406
 407     std::unique_ptr<SvStream> pStream;
 408     pStream.reset(new SvFileStream(rStreamName, STREAM_STD_READWRITE | StreamMode::TRUNC));
 409
 410     XmlWriter aXmlWriter(pStream.get());
 411
 412     if (!aXmlWriter.startDocument())
 413         return DS_FILE_ERROR;
 414
 415     aXmlWriter.startElement("profile");
 416
 417     aXmlWriter.startElement("version");
 418     aXmlWriter.content(OString(pProfile->version));
 419     aXmlWriter.endElement();
 420
 421     for (ds_device& rDevice : pProfile->devices)
 422     {
 423         aXmlWriter.startElement("device");
 424
 425         switch(rDevice.eType)
 426         {
 427             case DeviceType::NativeCPU:
 428                 aXmlWriter.startElement("type");
 429                 aXmlWriter.content("native");
 430                 aXmlWriter.endElement();
 431                 break;
 432             case DeviceType::OpenCLDevice:
 433                 aXmlWriter.startElement("type");
 434                 aXmlWriter.content("opencl");
 435                 aXmlWriter.endElement();
 436
 437                 aXmlWriter.startElement("name");
 438                 aXmlWriter.content(OString(rDevice.sDeviceName));
 439                 aXmlWriter.endElement();
 440
 441                 aXmlWriter.startElement("driver");
 442                 aXmlWriter.content(OString(rDevice.sDriverVersion));
 443                 aXmlWriter.endElement();
 444                 break;
 445             default:
 446                 break;
 447         }
 448
 449         aXmlWriter.startElement("time");
 450         if (rtl::math::approxEqual(rDevice.fTime, DBL_MAX))
 451             aXmlWriter.content("max");
 452         else
 453             aXmlWriter.content(OString::number(rDevice.fTime));
 454         aXmlWriter.endElement();
 455
 456         aXmlWriter.startElement("errors");
 457         aXmlWriter.content(rDevice.bErrors ? "true" : "false");
 458         aXmlWriter.endElement();
 459
 460         aXmlWriter.endElement();
 461     }
 462
 463     aXmlWriter.endElement();
 464     aXmlWriter.endDocument();
 465
 466     return DS_SUCCESS;
 467 }
 468
 469 inline ds_status readProfile(const OUString& rStreamName, std::unique_ptr<ds_profile>& pProfile)
 470 {
 471     ds_status eStatus = DS_SUCCESS;
 472
 473     if (rStreamName.isEmpty())
 474         return DS_INVALID_PROFILE;
 475
 476     std::unique_ptr<SvStream> pStream;
 477     pStream.reset(new SvFileStream(rStreamName, StreamMode::READ));
 478     XmlWalker aWalker;
 479
 480     if (!aWalker.open(pStream.get()))
 481         return DS_FILE_ERROR;
 482
 483     if (aWalker.name() == "profile")
 484     {
 485         aWalker.children();
 486         while (aWalker.isValid())
 487         {
 488             if (aWalker.name() == "version")
 489             {
 490                 if (aWalker.content() != pProfile->version)
 491                     return DS_PROFILE_FILE_ERROR;
 492             }
 493             else if (aWalker.name() == "device")
 494             {
 495                 aWalker.children();
 496
 497                 DeviceType eDeviceType = DeviceType::None;
 498                 OString sName;
 499                 OString sVersion;
 500                 double fTime = -1.0;
 501                 bool bErrors = true;
 502
 503                 while (aWalker.isValid())
 504                 {
 505                     if (aWalker.name() == "type")
 506                     {
 507                         OString sContent = aWalker.content();
 508                         if (sContent == "native")
 509                             eDeviceType = DeviceType::NativeCPU;
 510                         else if (sContent == "opencl")
 511                             eDeviceType = DeviceType::OpenCLDevice;
 512                         else
 513                             return DS_PROFILE_FILE_ERROR;
 514                     }
 515                     else if (aWalker.name() == "name")
 516                     {
 517                         sName = aWalker.content();
 518                     }
 519                     else if (aWalker.name() == "driver")
 520                     {
 521                         sVersion = aWalker.content();
 522                     }
 523                     else if (aWalker.name() == "time")
 524                     {
 525                         if (aWalker.content() == "max")
 526                             fTime = DBL_MAX;
 527                         else
 528                             fTime = aWalker.content().toDouble();
 529                     }
 530                     else if (aWalker.name() == "errors")
 531                     {
 532                         bErrors = (aWalker.content() == "true");
 533                     }
 534
 535                     aWalker.next();
 536                 }
 537
 538                 if (fTime < 0.0)
 539                     return DS_PROFILE_FILE_ERROR;
 540
 541                 for (ds_device& rDevice : pProfile->devices)
 542                 {
 543                     // type matches? either both are DS_DEVICE_OPENCL_DEVICE or DS_DEVICE_NATIVE_CPU
 544                     if (rDevice.eType == eDeviceType)
 545                     {
 546                         // is DS_DEVICE_NATIVE_CPU or name + version matches?
 547                         if (eDeviceType == DeviceType::NativeCPU ||
 548                                 (sName == OString(rDevice.sDeviceName) &&
 549                                  sVersion == OString(rDevice.sDriverVersion)))
 550                         {
 551                             rDevice.fTime = fTime;
 552                             rDevice.bErrors = bErrors;
 553                         }
 554                     }
 555                 }
 556
 557                 aWalker.parent();
 558             }
 559             aWalker.next();
 560         }
 561         aWalker.parent();
 562     }
 563
 564     return eStatus;
 565 }
 566
 567 #endif
 568
 569 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */