itkOpenCLContext.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 __itkOpenCLContext_h
#define __itkOpenCLContext_h
 
#include "itkLightObject.h"
#include "itkObjectFactory.h"
 
#include "itkOpenCLDevice.h"
#include "itkOpenCLCommandQueue.h"
#include "itkOpenCLBuffer.h"
#include "itkOpenCLVector.h"
#include "itkOpenCLImage.h"
#include "itkOpenCLSampler.h"
#include "itkOpenCLProgram.h"
#include "itkOpenCLUserEvent.h"
 
namespace itk
{
// Forward declaration
class OpenCLKernel;
class OpenCLVectorBase;
class OpenCLContextPimpl; // OpenCLContext private implementation idiom.
 
class ITKOpenCL_EXPORT OpenCLContext : public LightObject
{
public:
 
  typedef OpenCLContext              Self;
  typedef LightObject                Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;
 
  itkTypeMacro( OpenCLContext, LightObject );
 
  static Pointer New();
 
  static Pointer GetInstance();
 
  static void SetInstance( OpenCLContext * instance );
 
  bool IsCreated() const;
 
  enum CreateMethod {
    Default                                = 0x0000,
    DevelopmentSingleMaximumFlopsDevice    = 0x0001,
    DevelopmentMultipleMaximumFlopsDevices = 0x0002,
    SingleMaximumFlopsDevice               = 0x0004,
    MultipleMaximumFlopsDevices            = 0x0008
  };
 
  bool Create( const OpenCLDevice::DeviceType type );
 
  bool Create( const std::list< OpenCLDevice > & devices );
 
  bool Create( const OpenCLContext::CreateMethod method );
 
  bool Create( const OpenCLPlatform & platfrom,
    const OpenCLDevice::DeviceType type = OpenCLDevice::Default );
 
  bool Create();
 
  virtual void Release();
 
  cl_context GetContextId() const;
 
  void SetContextId( cl_context id );
 
  std::list< OpenCLDevice > GetDevices() const;
 
  OpenCLDevice GetDefaultDevice() const;
 
  cl_int GetLastError() const;
 
  void SetLastError( const cl_int error );
 
  static std::string GetErrorName( const cl_int code );
 
  void ReportError( const cl_int code, const char * fileName = "",
    const int lineNumber = 0, const char * location = "" );
 
  OpenCLCommandQueue GetCommandQueue();
 
  void SetCommandQueue( const OpenCLCommandQueue & queue );
 
  OpenCLCommandQueue GetDefaultCommandQueue();
 
  OpenCLCommandQueue CreateCommandQueue( const cl_command_queue_properties properties,
    const OpenCLDevice & device = OpenCLDevice() );
 
  OpenCLBuffer CreateBufferDevice( const OpenCLMemoryObject::Access access,
    const std::size_t size );
 
  OpenCLBuffer CreateBufferHost( void * data,
    const OpenCLMemoryObject::Access access, const std::size_t size );
 
  OpenCLBuffer CreateBufferCopy( const void * data,
    const OpenCLMemoryObject::Access access, const std::size_t size );
 
  template< typename T >
  OpenCLVector< T > CreateVector( const OpenCLMemoryObject::Access access,
    const std::size_t size )
  {
    return OpenCLVector< T >( this, access, size );
  }
 
 
  OpenCLImage CreateImageDevice( const OpenCLImageFormat & format,
    const OpenCLMemoryObject::Access access, const OpenCLSize & size );
 
  OpenCLImage CreateImageHost( const OpenCLImageFormat & format,
    void * data, const OpenCLSize & size,
    const OpenCLMemoryObject::Access access );
 
  OpenCLImage CreateImageCopy( const OpenCLImageFormat & format,
    const void * data, const OpenCLSize & size,
    const OpenCLMemoryObject::Access access );
 
  OpenCLProgram CreateProgramFromSourceCode( const std::string & sourceCode,
    const std::string & prefixSourceCode = std::string(),
    const std::string & postfixSourceCode = std::string() );
 
  OpenCLProgram CreateProgramFromSourceFile( const std::string & filename,
    const std::string & prefixSourceCode = std::string(),
    const std::string & postfixSourceCode = std::string() );
 
  OpenCLProgram CreateProgramFromBinaryCode( const unsigned char * binary,
    const std::size_t size );
 
  OpenCLProgram BuildProgramFromSourceCode( const std::string & sourceCode,
    const std::string & prefixSourceCode = std::string(),
    const std::string & postfixSourceCode = std::string() );
 
  OpenCLProgram BuildProgramFromSourceCode( const std::list< OpenCLDevice > & devices,
    const std::string & sourceCode,
    const std::string & prefixSourceCode = std::string(),
    const std::string & postfixSourceCode = std::string(),
    const std::string & extraBuildOptions = std::string() );
 
  OpenCLProgram BuildProgramFromSourceFile( const std::string & fileName,
    const std::string & prefixSourceCode = std::string(),
    const std::string & postfixSourceCode = std::string() );
 
  OpenCLProgram BuildProgramFromSourceFile( const std::list< OpenCLDevice > & devices,
    const std::string & fileName,
    const std::string & prefixSourceCode = std::string(),
    const std::string & postfixSourceCode = std::string(),
    const std::string & extraBuildOptions = std::string() );
 
  std::list< OpenCLImageFormat > GetSupportedImageFormats(
    const OpenCLImageFormat::ImageType image_type, const cl_mem_flags flags ) const;
 
  OpenCLSampler CreateSampler( const bool normalizedCoordinates,
    const OpenCLSampler::AddressingMode addressingMode,
    const OpenCLSampler::FilterMode filterMode );
 
  OpenCLUserEvent CreateUserEvent();
 
  void Flush();
 
  void Finish();
 
  cl_int Marker( const OpenCLEventList & event_list );
 
  OpenCLEvent MarkerAsync( const OpenCLEventList & event_list );
 
  cl_int Barrier( const OpenCLEventList & event_list );
 
  OpenCLEvent BarrierAsync( const OpenCLEventList & event_list );
 
  static cl_int WaitForFinished( const OpenCLEventList & event_list );
 
protected:
 
  OpenCLContext();
 
  ~OpenCLContext() override;
 
  void OpenCLProfile( cl_event clEvent, const std::string & message,
    const bool releaseEvent = false );
 
  void SetDefaultDevice( const OpenCLDevice & device );
 
  OpenCLProgram CreateOpenCLProgram( const std::string & filename,
    const std::string & source,
    const std::size_t sourceSize );
 
private:
 
  OpenCLContext( const Self & other );      // purposely not implemented
  const Self & operator=( const Self & );   // purposely not implemented
 
  ITK_OPENCL_DECLARE_PRIVATE( OpenCLContext )
 
  std::unique_ptr< OpenCLContextPimpl > d_ptr;
  static Pointer m_Instance;
 
  cl_command_queue GetActiveQueue();
 
  void CreateContext( const std::list< OpenCLDevice > & devices,
    OpenCLContextPimpl * d );
 
  void CreateContext( const OpenCLPlatform & platfrom,
    const OpenCLDevice::DeviceType type,
    OpenCLContextPimpl * d );
 
  void SetUpProfiling();
 
  void OpenCLDebug( const std::string & callname );
 
  friend class OpenCLMemoryObject;
  friend class OpenCLBuffer;
  friend class OpenCLImage;
  friend class OpenCLKernel;
  friend class OpenCLCommandQueue;
  friend class OpenCLProgram;
  friend class OpenCLVectorBase;
  friend class OpenCLSampler;
};
 
} // end namespace itk
 
#endif /* __itkOpenCLContext_h */