itkOpenCLKernel.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkOpenCLKernel_h
#define __itkOpenCLKernel_h
 
#include "itkOpenCL.h"
#include "itkOpenCLGlobal.h"
#include "itkOpenCLEvent.h"
#include "itkOpenCLSize.h"
#include "itkOpenCLMemoryObject.h"
#include "itkOpenCLSampler.h"
#include "itkOpenCLVector.h"
 
#include "itkIndex.h"
#include "itkPoint.h"
#include "itkVector.h"
#include "itkCovariantVector.h"
#include "itkMatrix.h"
 
namespace itk
{
// Defines for macro injections to reduce spoil code
#define OpenCLKernelSetArgMacroH( type ) \
  cl_int SetArg( const cl_uint index, const type value ); \
 
#define OpenCLKernelSetArgMacroCXX( type ) \
  cl_int OpenCLKernel::SetArg( const cl_uint index, const type value ) \
  { \
    return clSetKernelArg( this->m_KernelId, index, sizeof( value ), (const void *)&value ); \
  } \
 
#define  OpenCLKernelSetArgsMacroH( type0, type1, type2, type3, type4 ) \
  OpenCLKernelSetArgMacroH( type0 ) OpenCLKernelSetArgMacroH( type1 ) \
  OpenCLKernelSetArgMacroH( type2 ) OpenCLKernelSetArgMacroH( type3 ) \
  OpenCLKernelSetArgMacroH( type4 ) \
 
#define OpenCLKernelSetArgsMacroCXX( type0, type1, type2, type3, type4 ) \
  OpenCLKernelSetArgMacroCXX( type0 ) OpenCLKernelSetArgMacroCXX( type1 ) \
  OpenCLKernelSetArgMacroCXX( type2 ) OpenCLKernelSetArgMacroCXX( type3 ) \
  OpenCLKernelSetArgMacroCXX( type4 ) \
 
// Forward declaration
class OpenCLContext;
class OpenCLProgram;
class OpenCLVectorBase;
class OpenCLDevice;
 
class OpenCLKernelPimpl; // OpenCLKernel private implementation idiom.
 
class ITKOpenCL_EXPORT OpenCLKernel
{
public:
 
  typedef OpenCLMemoryObject Self;
 
  OpenCLKernel();
 
  OpenCLKernel( OpenCLContext * context, const cl_kernel id );
 
  OpenCLKernel( const OpenCLKernel & other );
 
  ~OpenCLKernel();
 
  OpenCLKernel & operator=( const OpenCLKernel & other );
 
  bool IsNull() const;
 
  cl_kernel GetKernelId() const;
 
  OpenCLContext * GetContext() const;
 
  OpenCLProgram GetProgram() const;
 
  std::string GetName() const;
 
  std::size_t GetNumberOfArguments() const;
 
  OpenCLSize GetCompileWorkGroupSize() const;
 
  OpenCLSize GetCompileWorkGroupSize( const OpenCLDevice & device ) const;
 
  void SetGlobalWorkSize( const OpenCLSize & size );
 
  OpenCLSize GetGlobalWorkSize() const;
 
  void SetRoundedGlobalWorkSize( const OpenCLSize & size );
 
  void SetLocalWorkSize( const OpenCLSize & size );
 
  void SetGlobalWorkOffset( const OpenCLSize & offset );
 
  OpenCLSize GetGlobalWorkOffset() const;
 
  OpenCLSize GetLocalWorkSize() const;
 
  OpenCLSize GetBestLocalWorkSizeImage1D() const;
 
  OpenCLSize GetBestLocalWorkSizeImage2D() const;
 
  OpenCLSize GetBestLocalWorkSizeImage3D() const;
 
  OpenCLSize GetBestLocalWorkSizeImage( const std::size_t dimension ) const;
 
  size_t GetPreferredWorkSizeMultiple() const;
 
  void SetDoubleAsFloat( const bool value ) { this->m_DoubleAsFloat = value; }
  void SetDoubleAsFloatEnable() { this->m_DoubleAsFloat = true; }
  void SetDoubleAsFloatDisable() { this->m_DoubleAsFloat = false; }
  bool GetDoubleAsFloatEnabled() { return this->m_DoubleAsFloat; }
 
  /*
  template< typename T,
  typename = typename std::enable_if<
    std::is_scalar< T >::value || std::is_union< T >::value >::type >
  cl_int SetArg( const cl_uint index, const T value )
  {
    return clSetKernelArg( this->m_KernelId, index,
      sizeof( value ), (const void *)&value );
  }
  */
 
  OpenCLKernelSetArgsMacroH( cl_uchar, cl_uchar2, cl_uchar4, cl_uchar8, cl_uchar16 )
  OpenCLKernelSetArgsMacroH( cl_char, cl_char2, cl_char4, cl_char8, cl_char16 )
  OpenCLKernelSetArgsMacroH( cl_ushort, cl_ushort2, cl_ushort4, cl_ushort8, cl_ushort16 )
  OpenCLKernelSetArgsMacroH( cl_short, cl_short2, cl_short4, cl_short8, cl_short16 )
  OpenCLKernelSetArgsMacroH( cl_uint, cl_uint2, cl_uint4, cl_uint8, cl_uint16 )
  OpenCLKernelSetArgsMacroH( cl_int, cl_int2, cl_int4, cl_int8, cl_int16 )
  OpenCLKernelSetArgsMacroH( cl_ulong, cl_ulong2, cl_ulong4, cl_ulong8, cl_ulong16 )
  OpenCLKernelSetArgsMacroH( cl_long, cl_long2, cl_long4, cl_long8, cl_long16 )
  OpenCLKernelSetArgsMacroH( cl_float, cl_float2, cl_float4, cl_float8, cl_float16 )
  OpenCLKernelSetArgsMacroH( cl_double, cl_double2, cl_double4, cl_double8, cl_double16 )
 
  cl_int SetArg( const cl_uint index, const void * data, const size_t size );
 
  typedef Size< 1 > Size1DType;
  cl_int SetArg( const cl_uint index, const Size1DType & value );
 
  typedef Size< 2 > Size2DType;
  cl_int SetArg( const cl_uint index, const Size2DType & value );
 
  typedef Size< 3 > Size3DType;
  cl_int SetArg( const cl_uint index, const Size3DType & value );
 
  typedef Size< 4 > Size4DType;
  cl_int SetArg( const cl_uint index, const Size4DType & value );
 
  typedef Index< 1 > Index1DType;
  cl_int SetArg( const cl_uint index, const Index1DType & value );
 
  typedef Index< 2 > Index2DType;
  cl_int SetArg( const cl_uint index, const Index2DType & value );
 
  typedef Index< 3 > Index3DType;
  cl_int SetArg( const cl_uint index, const Index3DType & value );
 
  typedef Index< 4 > Index4DType;
  cl_int SetArg( const cl_uint index, const Index4DType & value );
 
  typedef Offset< 1 > Offset1DType;
  cl_int SetArg( const cl_uint index, const Offset1DType & value );
 
  typedef Offset< 2 > Offset2DType;
  cl_int SetArg( const cl_uint index, const Offset2DType & value );
 
  typedef Offset< 3 > Offset3DType;
  cl_int SetArg( const cl_uint index, const Offset3DType & value );
 
  typedef Offset< 4 > Offset4DType;
  cl_int SetArg( const cl_uint index, const Offset4DType & value );
 
  typedef Point< int, 1 > PointInt1DType;
  cl_int SetArg( const cl_uint index, const PointInt1DType & value );
 
  typedef Point< float, 1 > PointFloat1DType;
  cl_int SetArg( const cl_uint index, const PointFloat1DType & value );
 
  typedef Point< double, 1 > PointDouble1DType;
  cl_int SetArg( const cl_uint index, const PointDouble1DType & value );
 
  typedef Point< int, 2 > PointInt2DType;
  cl_int SetArg( const cl_uint index, const PointInt2DType & value );
 
  typedef Point< float, 2 > PointFloat2DType;
  cl_int SetArg( const cl_uint index, const PointFloat2DType & value );
 
  typedef Point< double, 2 > PointDouble2DType;
  cl_int SetArg( const cl_uint index, const PointDouble2DType & value );
 
  typedef Point< int, 3 > PointInt3DType;
  cl_int SetArg( const cl_uint index, const PointInt3DType & value );
 
  typedef Point< float, 3 > PointFloat3DType;
  cl_int SetArg( const cl_uint index, const PointFloat3DType & value );
 
  typedef Point< double, 3 > PointDouble3DType;
  cl_int SetArg( const cl_uint index, const PointDouble3DType & value );
 
  typedef Point< int, 4 > PointInt4DType;
  cl_int SetArg( const cl_uint index, const PointInt4DType & value );
 
  typedef Point< float, 4 > PointFloat4DType;
  cl_int SetArg( const cl_uint index, const PointFloat4DType & value );
 
  typedef Point< double, 4 > PointDouble4DType;
  cl_int SetArg( const cl_uint index, const PointDouble4DType & value );
 
  typedef Vector< int, 1 > VectorInt1DType;
  cl_int SetArg( const cl_uint index, const VectorInt1DType & value );
 
  typedef Vector< float, 1 > VectorFloat1DType;
  cl_int SetArg( const cl_uint index, const VectorFloat1DType & value );
 
  typedef Vector< double, 1 > VectorDouble1DType;
  cl_int SetArg( const cl_uint index, const VectorDouble1DType & value );
 
  typedef Vector< int, 2 > VectorInt2DType;
  cl_int SetArg( const cl_uint index, const VectorInt2DType & value );
 
  typedef Vector< float, 2 > VectorFloat2DType;
  cl_int SetArg( const cl_uint index, const VectorFloat2DType & value );
 
  typedef Vector< double, 2 > VectorDouble2DType;
  cl_int SetArg( const cl_uint index, const VectorDouble2DType & value );
 
  typedef Vector< int, 3 > VectorInt3DType;
  cl_int SetArg( const cl_uint index, const VectorInt3DType & value );
 
  typedef Vector< float, 3 > VectorFloat3DType;
  cl_int SetArg( const cl_uint index, const VectorFloat3DType & value );
 
  typedef Vector< double, 3 > VectorDouble3DType;
  cl_int SetArg( const cl_uint index, const VectorDouble3DType & value );
 
  typedef Vector< int, 4 > VectorInt4DType;
  cl_int SetArg( const cl_uint index, const VectorInt4DType & value );
 
  typedef Vector< float, 4 > VectorFloat4DType;
  cl_int SetArg( const cl_uint index, const VectorFloat4DType & value );
 
  typedef Vector< double, 4 > VectorDouble4DType;
  cl_int SetArg( const cl_uint index, const VectorDouble4DType & value );
 
  typedef CovariantVector< int, 1 > CovariantVectorInt1DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorInt1DType & value );
 
  typedef CovariantVector< float, 1 > CovariantVectorFloat1DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorFloat1DType & value );
 
  typedef CovariantVector< double, 1 > CovariantVectorDouble1DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorDouble1DType & value );
 
  typedef CovariantVector< int, 2 > CovariantVectorInt2DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorInt2DType & value );
 
  typedef CovariantVector< float, 2 > CovariantVectorFloat2DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorFloat2DType & value );
 
  typedef CovariantVector< double, 2 > CovariantVectorDouble2DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorDouble2DType & value );
 
  typedef CovariantVector< int, 3 > CovariantVectorInt3DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorInt3DType & value );
 
  typedef CovariantVector< float, 3 > CovariantVectorFloat3DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorFloat3DType & value );
 
  typedef CovariantVector< double, 3 > CovariantVectorDouble3DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorDouble3DType & value );
 
  typedef CovariantVector< int, 4 > CovariantVectorInt4DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorInt4DType & value );
 
  typedef CovariantVector< float, 4 > CovariantVectorFloat4DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorFloat4DType & value );
 
  typedef CovariantVector< double, 4 > CovariantVectorDouble4DType;
  cl_int SetArg( const cl_uint index, const CovariantVectorDouble4DType & value );
 
  typedef Matrix< float, 1, 1 > MatrixFloat1x1Type;
  cl_int SetArg( const cl_uint index, const MatrixFloat1x1Type & value );
 
  typedef Matrix< double, 1, 1 > MatrixDouble1x1Type;
  cl_int SetArg( const cl_uint index, const MatrixDouble1x1Type & value );
 
  typedef Matrix< float, 2, 2 > MatrixFloat2x2Type;
  cl_int SetArg( const cl_uint index, const MatrixFloat2x2Type & value );
 
  typedef Matrix< double, 2, 2 > MatrixDouble2x2Type;
  cl_int SetArg( const cl_uint index, const MatrixDouble2x2Type & value );
 
  typedef Matrix< float, 3, 3 > MatrixFloat3x3Type;
  cl_int SetArg( const cl_uint index, const MatrixFloat3x3Type & value );
 
  typedef Matrix< double, 3, 3 > MatrixDouble3x3Type;
  cl_int SetArg( const cl_uint index, const MatrixDouble3x3Type & value );
 
  typedef Matrix< float, 4, 4 > MatrixFloat4x4Type;
  cl_int SetArg( const cl_uint index, const MatrixFloat4x4Type & value );
 
  typedef Matrix< double, 4, 4 > MatrixDouble4x4Type;
  cl_int SetArg( const cl_uint index, const MatrixDouble4x4Type & value );
 
  cl_int SetArg( const cl_uint index, const OpenCLMemoryObject & value );
 
  cl_int SetArg( const cl_uint index, const OpenCLVectorBase & value );
 
  cl_int SetArg( const cl_uint index, const OpenCLSampler & value );
 
  OpenCLEvent LaunchKernel();
 
  OpenCLEvent LaunchKernel( const OpenCLSize & global_work_size,
    const OpenCLSize & local_work_size = OpenCLSize::null,
    const OpenCLSize & global_work_offset = OpenCLSize::null );
 
  OpenCLEvent LaunchKernel( const OpenCLEventList & event_list );
 
  OpenCLEvent LaunchKernel( const OpenCLEventList & event_list,
    const OpenCLSize & global_work_size,
    const OpenCLSize & local_work_size = OpenCLSize::null,
    const OpenCLSize & global_work_offset = OpenCLSize::null );
 
  bool LaunchTask( const OpenCLEventList & event_list );
 
  OpenCLEvent LaunchTaskAsync( const OpenCLEventList & event_list );
 
  inline OpenCLEvent operator()() { return this->LaunchKernel(); }
 
  template< typename T1 >
  inline OpenCLEvent operator()( const T1 & arg1 )
  {
    this->SetArg( 0, arg1 );
    return this->LaunchKernel();
  }
 
 
  template< typename T1, typename T2 >
  inline OpenCLEvent operator()( const T1 & arg1, const T2 & arg2 )
  {
    this->SetArg( 0, arg1 );
    this->SetArg( 1, arg2 );
    return this->LaunchKernel();
  }
 
 
  template< typename T1, typename T2, typename T3 >
  inline OpenCLEvent operator()
    ( const T1 & arg1, const T2 & arg2, const T3 & arg3 )
  {
    this->SetArg( 0, arg1 );
    this->SetArg( 1, arg2 );
    this->SetArg( 2, arg3 );
    return this->LaunchKernel();
  }
 
 
  template< typename T1, typename T2, typename T3, typename T4 >
  inline OpenCLEvent operator()
    ( const T1 & arg1, const T2 & arg2, const T3 & arg3, const T4 & arg4 )
  {
    this->SetArg( 0, arg1 );
    this->SetArg( 1, arg2 );
    this->SetArg( 2, arg3 );
    this->SetArg( 3, arg4 );
    return this->LaunchKernel();
  }
 
 
  template< typename T1, typename T2, typename T3, typename T4,
  typename T5 >
  inline OpenCLEvent operator()
    ( const T1 & arg1, const T2 & arg2, const T3 & arg3, const T4 & arg4,
    const T5 & arg5 )
  {
    this->SetArg( 0, arg1 );
    this->SetArg( 1, arg2 );
    this->SetArg( 2, arg3 );
    this->SetArg( 3, arg4 );
    this->SetArg( 4, arg5 );
    return this->LaunchKernel();
  }
 
 
  template< typename T1, typename T2, typename T3, typename T4,
  typename T5, typename T6 >
  inline OpenCLEvent operator()
    ( const T1 & arg1, const T2 & arg2, const T3 & arg3, const T4 & arg4,
    const T5 & arg5, const T6 & arg6 )
  {
    this->SetArg( 0, arg1 );
    this->SetArg( 1, arg2 );
    this->SetArg( 2, arg3 );
    this->SetArg( 3, arg4 );
    this->SetArg( 4, arg5 );
    this->SetArg( 5, arg6 );
    return this->LaunchKernel();
  }
 
 
  template< typename T1, typename T2, typename T3, typename T4,
  typename T5, typename T6, typename T7 >
  inline OpenCLEvent operator()
    ( const T1 & arg1, const T2 & arg2, const T3 & arg3, const T4 & arg4,
    const T5 & arg5, const T6 & arg6, const T7 & arg7 )
  {
    this->SetArg( 0, arg1 );
    this->SetArg( 1, arg2 );
    this->SetArg( 2, arg3 );
    this->SetArg( 3, arg4 );
    this->SetArg( 4, arg5 );
    this->SetArg( 5, arg6 );
    this->SetArg( 6, arg7 );
    return this->LaunchKernel();
  }
 
 
  template< typename T1, typename T2, typename T3, typename T4,
  typename T5, typename T6, typename T7, typename T8 >
  inline OpenCLEvent operator()
    ( const T1 & arg1, const T2 & arg2, const T3 & arg3, const T4 & arg4,
    const T5 & arg5, const T6 & arg6, const T7 & arg7, const T8 & arg8 )
  {
    this->SetArg( 0, arg1 );
    this->SetArg( 1, arg2 );
    this->SetArg( 2, arg3 );
    this->SetArg( 3, arg4 );
    this->SetArg( 4, arg5 );
    this->SetArg( 5, arg6 );
    this->SetArg( 6, arg7 );
    this->SetArg( 7, arg8 );
    return this->LaunchKernel();
  }
 
 
  template< typename T1, typename T2, typename T3, typename T4,
  typename T5, typename T6, typename T7, typename T8,
  typename T9 >
  inline OpenCLEvent operator()
    ( const T1 & arg1, const T2 & arg2, const T3 & arg3, const T4 & arg4,
    const T5 & arg5, const T6 & arg6, const T7 & arg7, const T8 & arg8,
    const T9 & arg9 )
  {
    this->SetArg( 0, arg1 );
    this->SetArg( 1, arg2 );
    this->SetArg( 2, arg3 );
    this->SetArg( 3, arg4 );
    this->SetArg( 4, arg5 );
    this->SetArg( 5, arg6 );
    this->SetArg( 6, arg7 );
    this->SetArg( 7, arg8 );
    this->SetArg( 8, arg9 );
    return this->LaunchKernel();
  }
 
 
  template< typename T1, typename T2, typename T3, typename T4,
  typename T5, typename T6, typename T7, typename T8,
  typename T9, typename T10 >
  inline OpenCLEvent operator()
    ( const T1 & arg1, const T2 & arg2, const T3 & arg3, const T4 & arg4,
    const T5 & arg5, const T6 & arg6, const T7 & arg7, const T8 & arg8,
    const T9 & arg9, const T10 & arg10 )
  {
    this->SetArg( 0, arg1 );
    this->SetArg( 1, arg2 );
    this->SetArg( 2, arg3 );
    this->SetArg( 3, arg4 );
    this->SetArg( 4, arg5 );
    this->SetArg( 5, arg6 );
    this->SetArg( 6, arg7 );
    this->SetArg( 7, arg8 );
    this->SetArg( 8, arg9 );
    this->SetArg( 9, arg10 );
    return this->LaunchKernel();
  }
 
 
private:
 
  std::unique_ptr< OpenCLKernelPimpl > d_ptr;
  cl_kernel                            m_KernelId;
  bool                                 m_DoubleAsFloat;
 
  ITK_OPENCL_DECLARE_PRIVATE( OpenCLKernel )
};
 
bool ITKOpenCL_EXPORT operator==( const OpenCLKernel & lhs, const OpenCLKernel & rhs );
 
bool ITKOpenCL_EXPORT operator!=( const OpenCLKernel & lhs, const OpenCLKernel & rhs );
 
template< typename charT, typename traits >
inline
std::basic_ostream< charT, traits > &
operator<<( std::basic_ostream< charT, traits > & strm,
  const OpenCLKernel & kernel )
{
  if( kernel.IsNull() )
  {
    strm << "OpenCLKernel(null)";
    return strm;
  }
 
  const char indent = ' ';
 
  strm << "OpenCLKernel" << std::endl
       << indent << "Id: " << kernel.GetKernelId() << std::endl
       << indent << "Name: " << kernel.GetName() << std::endl
       << indent << "Number of arguments: " << kernel.GetNumberOfArguments() << std::endl
       << indent << "Global work size: " << kernel.GetGlobalWorkSize() << std::endl
       << indent << "Local work size: " << kernel.GetLocalWorkSize() << std::endl
       << indent << "Global work offset: " << kernel.GetGlobalWorkOffset() << std::endl
       << indent << "Compile work group size: " << kernel.GetCompileWorkGroupSize() << std::endl
       << indent << "Best local work size image 2D: " << kernel.GetBestLocalWorkSizeImage2D() << std::endl
       << indent << "Best local work size image 3D: " << kernel.GetBestLocalWorkSizeImage3D() << std::endl
       << indent << "Preferred work size multiple: " << kernel.GetPreferredWorkSizeMultiple() << std::endl;
 
  return strm;
}
 
 
} // end namespace itk
 
#endif /* __itkOpenCLKernel_h */