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:
 
  typedef OpenCLMemoryObject      Self;
  typedef Size< 4 >               RectangleType;
  typedef Point< std::size_t, 2 > PointType;
  typedef Size< 2 >               SizeType;
 
  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 ); // purposely not implemented
  const Self & operator=( const Self & );   // purposely not implemented
 
};
 
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" << std::endl
       << indent << "Id: " << memoryObject.GetMemoryId() << std::endl
       << indent << "Context: " << memoryObject.GetContext() << std::endl
       << indent << "Memory type: " << memoryObject.GetMemoryType() << std::endl
       << indent << "Flags: " << memoryObject.GetFlags() << std::endl
       << indent << "Size: " << memoryObject.GetSize() << std::endl
       << indent << "Map count: " << memoryObject.GetMapCount() << std::endl
       << indent << "Reference count: " << memoryObject.GetReferenceCount() << std::endl
       << indent << "Host pointer: " << memoryObject.GetHostPointer() << std::endl
       << 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 */