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:
  using Self = OpenCLContext;
  using Superclass = LightObject;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  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) = delete;
  const Self &
  operator=(const Self &) = delete;
 
  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 */