qgsopenclutils.h

Go to the documentation of this file.

/***************************************************************************
  qgsopenclutils.h - QgsOpenClUtils
 
 ---------------------
 begin                : 11.4.2018
 copyright            : (C) 2018 by Alessandro Pasotti
 email                : elpaso at itopen dot it
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef QGSOPENCLUTILS_H
#define QGSOPENCLUTILS_H
 
 
#define CL_HPP_ENABLE_EXCEPTIONS
 
#include <QString>
#include <QtGlobal>
 
#define SIP_NO_FILE
 
using namespace Qt::StringLiterals;
 
#ifdef Q_OS_MAC
#define CL_HPP_MINIMUM_OPENCL_VERSION 120
#define CL_HPP_TARGET_OPENCL_VERSION 120
#define CL_TARGET_OPENCL_VERSION 120
#else
#define CL_USE_DEPRECATED_OPENCL_1_1_APIS
#define CL_HPP_TARGET_OPENCL_VERSION 200
#define CL_TARGET_OPENCL_VERSION 200
#endif
 
#include "qgsconfig.h"
 
#ifdef OPENCL_USE_NEW_HEADER
#include <CL/opencl.hpp>
#else
#include <CL/cl2.hpp>
#endif
 
#include "qgis_core.h"
#include "qgis.h"
 
#include "cpl_conv.h"
 
class QgsSettingsEntryBool;
class QgsSettingsEntryString;

class CORE_EXPORT QgsOpenClUtils
{
    Q_GADGET
 
  public:
    static const QgsSettingsEntryBool *settingsOpenClEnabled;
    static const QgsSettingsEntryString *settingsOpenClDefaultDevice;
    enum ExceptionBehavior
    {
      Catch, 
      Throw  
    };

    enum HardwareType
    {
      CPU,
      GPU,
      Other
    };
 
    Q_ENUM( HardwareType )
 
    
    enum Info
    {
      Name = CL_DEVICE_NAME,
      Vendor = CL_DEVICE_VENDOR,
      Version = CL_DEVICE_VERSION,
      Profile = CL_DEVICE_PROFILE,
      ImageSupport = CL_DEVICE_IMAGE_SUPPORT,
      Image2dMaxWidth = CL_DEVICE_IMAGE2D_MAX_WIDTH,
      Image2dMaxHeight = CL_DEVICE_IMAGE2D_MAX_HEIGHT,
      MaxMemAllocSize = CL_DEVICE_MAX_MEM_ALLOC_SIZE,
      Type = CL_DEVICE_TYPE // CPU/GPU etc.
    };

    static bool available();

    static bool enabled();

    static const std::vector<cl::Device> devices();

    static cl::Device activeDevice();

    static QString activePlatformVersion();

    static void storePreferredDevice( const QString deviceId );

    static QString preferredDevice();

    static QString deviceId( const cl::Device device );

    static QString deviceDescription( const cl::Device device );

    static QString deviceDescription( const QString deviceId );

    static void setEnabled( bool enabled );

    static QString buildLog( cl::BuildError &error );

    static QString sourceFromPath( const QString &path );

    static QString sourceFromBaseName( const QString &baseName );

    static QLatin1String LOGMESSAGE_TAG;

    static QString errorText( const int errorCode );

    static cl::CommandQueue commandQueue();

    Q_DECL_DEPRECATED static cl::Program buildProgram( const cl::Context &context, const QString &source, ExceptionBehavior exceptionBehavior = Catch );

    static cl::Program buildProgram( const QString &source, ExceptionBehavior exceptionBehavior = Catch );
 

    static cl::Context context();

    static QString sourcePath();

    static void setSourcePath( const QString &value );

    static QString activeDeviceInfo( const Info infoType = Info::Name );

    static QString deviceInfo( const Info infoType, cl::Device device );

    template<typename T> struct CPLAllocator
    {
      public:
        explicit CPLAllocator( unsigned long size )
          : mMem( static_cast<T *>( CPLMalloc( sizeof( T ) * size ) ) )
        {}
 
        ~CPLAllocator() { CPLFree( static_cast<void *>( mMem ) ); }
 
        void reset( T *newData )
        {
          if ( mMem )
            CPLFree( static_cast<void *>( mMem ) );
          mMem = newData;
        }
 
        void reset( unsigned long size ) { reset( static_cast<T *>( CPLMalloc( sizeof( T ) * size ) ) ); }
 
        T &operator*()
        {
          // cppcheck-suppress returnTempReference
          return &mMem[0];
        }
 
        T *release()
        {
          T *tmpMem = mMem;
          mMem = nullptr;
          return tmpMem;
        }
 
        T &operator[]( const int index ) { return mMem[index]; }
 
        T *get() { return mMem; }
 
      private:
        T *mMem = nullptr;
    };
 
 
  private:
    QgsOpenClUtils();

    static bool activate( const QString &preferredDeviceId = QString() );
 
    static bool activateInternal( const QString &preferredDeviceId );

    static void init();
 
    static bool sAvailable;
};
 
 
#endif // QGSOPENCLUTILS_H