itkOpenCLMemoryObject.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 itkOpenCLMemoryObject_h
#define itkOpenCLMemoryObject_h
 
#include "itkOpenCLEventList.h"
#include "itkOpenCLSize.h"
#include "itkPoint.h"
 
namespace itk
{
// Forward declaration
class OpenCLContext;
 
class ITKOpenCL_EXPORT OpenCLMemoryObject
{
protected:
  OpenCLMemoryObject(OpenCLContext * context = 0)
    : m_Context(context)
    , m_Id(0)
  {}
 
  OpenCLMemoryObject(OpenCLContext * context, const cl_mem id)
    : m_Context(context)
    , m_Id(id)
  {}
 
  ~OpenCLMemoryObject();
 
public:
  using Self = OpenCLMemoryObject;
  using RectangleType = Size<4>;
  using PointType = Point<std::size_t, 2>;
  using SizeType = Size<2>;
 
  enum Access
  {
    ReadWrite = 0x0001,
    WriteOnly = 0x0002,
    ReadOnly = 0x0004
  };
 
  bool
  IsNull() const
  {
    return this->m_Id == 0;
  }
 
  cl_mem
  GetMemoryId() const
  {
    return this->m_Id;
  }
 
  OpenCLContext *
  GetContext() const
  {
    return this->m_Context;
  }
 
  cl_mem_object_type
  GetMemoryType() const;
 
  cl_mem_flags
  GetFlags() const;
 
  std::size_t
  GetSize() const;
 
  void *
  GetHostPointer() const;
 
  cl_uint
  GetMapCount() const;
 
  cl_uint
  GetReferenceCount() const;
 
  OpenCLMemoryObject::Access
  GetAccess() const;
 
  void
  Unmap(void * ptr, const bool wait = false);
 
  OpenCLEvent
  UnmapAsync(void * ptr, const OpenCLEventList & event_list = OpenCLEventList());
 
  cl_int
  SetDestructorCallback(void(CL_CALLBACK * pfn_notify)(cl_mem, void *), void * user_data = nullptr);
 
protected:
  void
  SetId(OpenCLContext * context, const cl_mem id);
 
  cl_map_flags
  GetMapFlags(const OpenCLMemoryObject::Access access);
 
private:
  OpenCLContext * m_Context;
  cl_mem          m_Id;
 
  OpenCLMemoryObject(const Self & other) = delete;
  const Self &
  operator=(const Self &) = delete;
};
 
bool ITKOpenCL_EXPORT
     operator==(const OpenCLMemoryObject & lhs, const OpenCLMemoryObject & rhs);
 
bool ITKOpenCL_EXPORT
     operator!=(const OpenCLMemoryObject & lhs, const OpenCLMemoryObject & rhs);
 
template <typename charT, typename traits>
inline std::basic_ostream<charT, traits> &
operator<<(std::basic_ostream<charT, traits> & strm, const OpenCLMemoryObject & memoryObject)
{
  if (memoryObject.IsNull())
  {
    strm << "OpenCLMemoryObject(null)";
    return strm;
  }
 
  const char indent = ' ';
 
  strm << "OpenCLMemoryObject\n"
       << indent << "Id: " << memoryObject.GetMemoryId() << '\n'
       << indent << "Context: " << memoryObject.GetContext() << '\n'
       << indent << "Memory type: " << memoryObject.GetMemoryType() << '\n'
       << indent << "Flags: " << memoryObject.GetFlags() << '\n'
       << indent << "Size: " << memoryObject.GetSize() << '\n'
       << indent << "Map count: " << memoryObject.GetMapCount() << '\n'
       << indent << "Reference count: " << memoryObject.GetReferenceCount() << '\n'
       << indent << "Host pointer: " << memoryObject.GetHostPointer() << '\n'
       << indent << "Access: ";
 
  switch (memoryObject.GetAccess())
  {
    case OpenCLMemoryObject::ReadWrite:
      strm << "Read Write";
      break;
    case OpenCLMemoryObject::WriteOnly:
      strm << "Write Only";
      break;
    case OpenCLMemoryObject::ReadOnly:
      strm << "Read Only";
      break;
    default:
      strm << "Unknown";
      break;
  }
 
  strm << std::endl;
 
  return strm;
}
 
 
} // end namespace itk
 
#endif /* itkOpenCLMemoryObject_h */