opencl_kernel.h

#ifndef OPENCL_KERNEL_H
#define OPENCL_KERNEL_H
#include <CL/cl.h>
#include <QObject>
#include "opencl_buffer.h"
#include "opencl.h"
#include "edebug.h"
//



namespace OpenCL
{
   class Kernel : public QObject
   {
      Q_OBJECT
   public:
      virtual ~Kernel() override;
      Event execute(CommandQueue* queue);
   protected:
      class Locker;
      explicit Kernel(Program* program, const QString& name, QObject* parent = nullptr);
      Kernel::Locker lock();
      void unlock();
      int maxWorkGroupSize(Device* device) const;
      int workGroupMultiple(Device* device) const;
      void setDimensions(cl_uint size);
      void setSizes(cl_uint dimension, qint64 globalSize, qint64 localSize);
      template<class T> void setArgument(cl_uint index, T value);
      template<class T> void setBuffer(cl_uint index, Buffer<T>* buffer);
      template<class T> void setLocalMemory(cl_uint index, qint64 size);
   private:
      void allocate();
      void clear();
      cl_kernel _id;
      cl_uint _size {1};
      size_t* _offsets {nullptr};
      size_t* _globalSizes {nullptr};
      size_t* _localSizes {nullptr};
      QMutex _lock;
      bool _isLocked {false};
   };






   template<class T> void Kernel::setArgument(cl_uint index, T value)
   {
      EDEBUG_FUNC(this,index,value)
   
      // If this kernel is not locked then throw an exception, else go to the next step. 
      if ( !_isLocked )
      {
         E_MAKE_EXCEPTION(e);
         e.setTitle(tr("Logic Error"));
         e.setDetails(tr("Cannot set OpenCL kernel parameters without locking the object first."));
         throw e;
      }
   
      // Set the kernel argument with the given index to the given value. If setting the 
      // argument fails then throw an exception. 
      cl_int code {clSetKernelArg(_id,index,sizeof(T),&value)};
      if ( code != CL_SUCCESS )
      {
         E_MAKE_EXCEPTION(e);
         fillException(&e,code);
         throw e;
      }
   }






   template<class T> void Kernel::setBuffer(cl_uint index, Buffer<T>* buffer)
   {
      EDEBUG_FUNC(this,index,buffer)
   
      // If this kernel is not locked then throw an exception, else go to the next step. 
      if ( !_isLocked )
      {
         E_MAKE_EXCEPTION(e);
         e.setTitle(tr("Logic Error"));
         e.setDetails(tr("Cannot set OpenCL kernel parameters without locking the object first."));
         throw e;
      }
   
      // Set the kernel argument with the given index to the given OpenCL buffer. If 
      // setting the argument fails then throw an exception. 
      cl_mem id {buffer->id()};
      cl_int code {clSetKernelArg(_id,index,sizeof(cl_mem),&id)};
      if ( code != CL_SUCCESS )
      {
         E_MAKE_EXCEPTION(e);
         fillException(&e,code);
         throw e;
      }
   }






   template<class T> void Kernel::setLocalMemory(cl_uint index, qint64 size)
   {
      EDEBUG_FUNC(this,index,size)
   
      // If this kernel is not locked or the given size is less than one then throw an 
      // exception, else go to the next step. 
      if ( !_isLocked )
      {
         E_MAKE_EXCEPTION(e);
         e.setTitle(tr("Logic Error"));
         e.setDetails(tr("Cannot set OpenCL kernel parameters without locking the object first."));
         throw e;
      }
      if ( size < 1 )
      {
         E_MAKE_EXCEPTION(e);
         e.setTitle(tr("Invalid Argument"));
         e.setDetails(tr("Cannot set local memory argument of OpenCL kernel with a size of less than 1."));
         throw e;
      }
   
      // Set the kernel argument with the given index to allocate the given amount of 
      // local memory. If setting the argument fails then throw an exception. 
      cl_int code {clSetKernelArg(_id,index,sizeof(T)*size,nullptr)};
      if ( code != CL_SUCCESS )
      {
         E_MAKE_EXCEPTION(e);
         fillException(&e,code);
         throw e;
      }
   }
}



#endif