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 SIP_NO_FILE
 
#define CL_HPP_ENABLE_EXCEPTIONS
 
#include <QtGlobal>
#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 CORE_EXPORT QgsOpenClUtils
{
    Q_GADGET
 
  public:
 
    enum ExceptionBehavior
    {
      Catch,  
      Throw   
    };
    enum ExceptionBehavior {…};
 
    enum HardwareType
    {
      CPU,
      GPU,
      Other
    };
    enum HardwareType {…};
 
    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.
    };
    enum Info {…};
 
    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 ) );
        }
        ~CPLAllocator() {…}
 
        void reset( T *newData )
        {
          if ( mMem )
            CPLFree( static_cast<void *>( mMem ) );
          mMem = newData;
        }
        void reset( T *newData ) {…}
 
        void reset( unsigned long size )
        {
          reset( static_cast<T *>( CPLMalloc( sizeof( T ) *size ) ) );
        }
        void reset( unsigned long size ) {…}
 
        T &operator* ()
        {
          // cppcheck-suppress returnTempReference
          return &mMem[0];
        }
        T &operator* () {…}
 
        T *release()
        {
          T *tmpMem = mMem;
          mMem = nullptr;
          return tmpMem;
        }
        T *release() {…}
 
        T &operator[]( const int index )
        {
          return mMem[index];
        }
        T &operator[]( const int index ) {…}
 
        T *get()
        {
          return mMem;
        }
        T *get() {…}
 
      private:
 
        T *mMem = nullptr;
    };
    struct CPLAllocator {…};
 
 
  private:
 
    QgsOpenClUtils();
 
    static bool activate( const QString &preferredDeviceId = QString() );
 
    static bool activateInternal( const QString &preferredDeviceId );
 
    static void init();
 
    static bool sAvailable;
    static QLatin1String SETTINGS_GLOBAL_ENABLED_KEY;
    static QLatin1String SETTINGS_DEFAULT_DEVICE_KEY;
};
class CORE_EXPORT QgsOpenClUtils {…};
 
 
 
#endif // QGSOPENCLUTILS_H