itkOpenCLDevice.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 __itkOpenCLDevice_h
#define __itkOpenCLDevice_h
 
#include "itkOpenCLPlatform.h"
#include "itkOpenCLSize.h"
 
namespace itk
{
class ITKOpenCL_EXPORT OpenCLDevice
{
public:
 
  typedef OpenCLDevice Self;
 
  OpenCLDevice() : m_Id( 0 ), m_Version( 0 ) {}
 
  OpenCLDevice( cl_device_id id ) : m_Id( id ), m_Version( 0 ) {}
 
  enum DeviceType {
    Default     = ( 1 << 0 ),
    CPU         = ( 1 << 1 ),
    GPU         = ( 1 << 2 ),
    Accelerator = ( 1 << 3 ),
    Custom      = ( 1 << 4 ),
    All         = 0xFFFFFFFF
  };
 
  enum Endian {
    BigEndian,
    LittleEndian
  };
 
  bool IsNull() const { return this->m_Id == 0; }
 
  cl_device_id GetDeviceId() const { return this->m_Id; }
 
  OpenCLVersion GetOpenCLVersion() const;
 
  std::string GetVersion() const;
 
  OpenCLDevice::DeviceType GetDeviceType() const;
 
  OpenCLPlatform GetPlatform() const;
 
  unsigned int GetVendorId() const;
 
  bool IsAvailable() const;
 
  bool HasCompiler() const;
 
  bool HasNativeKernels() const;
 
  bool HasOutOfOrderExecution() const;
 
  bool HasDouble() const;
 
  bool HasHalfFloat() const;
 
  bool HasErrorCorrectingMemory() const;
 
  bool HasUnifiedMemory() const;
 
  unsigned int GetComputeUnits() const;
 
  unsigned int GetClockFrequency() const;
 
  unsigned int GetAddressBits() const;
 
  OpenCLDevice::Endian GetByteOrder() const;
 
  OpenCLSize GetMaximumWorkItemSize() const;
 
  std::size_t GetMaximumWorkItemsPerGroup() const;
 
  bool HasImage2D() const;
 
  bool HasImage3D() const;
 
  bool HasWritableImage3D() const;
 
  OpenCLSize GetMaximumImage2DSize() const;
 
  OpenCLSize GetMaximumImage3DSize() const;
 
  unsigned int GetMaximumSamplers() const;
 
  unsigned int GetMaximumReadImages() const;
 
  unsigned int GetMaximumWriteImages() const;
 
  unsigned int GetPreferredCharVectorSize() const;
 
  unsigned int GetPreferredShortVectorSize() const;
 
  unsigned int GetPreferredIntVectorSize() const;
 
  unsigned int GetPreferredLongVectorSize() const;
 
  unsigned int GetPreferredFloatVectorSize() const;
 
  unsigned int GetPreferredDoubleVectorSize() const;
 
  unsigned int GetPreferredHalfFloatVectorSize() const;
 
  unsigned int GetNativeCharVectorSize() const;
 
  unsigned int GetNativeShortVectorSize() const;
 
  unsigned int GetNativeIntVectorSize() const;
 
  unsigned int GetNativeLongVectorSize() const;
 
  unsigned int GetNativeFloatVectorSize() const;
 
  unsigned int GetNativeDoubleVectorSize() const;
 
  unsigned int GetNativeHalfFloatVectorSize() const;
 
  enum FloatCapability {
    NotSupported     = 0x0000,
    Denorm           = 0x0001,
    InfinityNaN      = 0x0002,
    RoundNearest     = 0x0004,
    RoundZero        = 0x0008,
    RoundInfinity    = 0x0010,
    FusedMultiplyAdd = 0x0020
  };
 
  FloatCapability GetFloatCapabilities() const;
 
  FloatCapability GetDoubleCapabilities() const;
 
  FloatCapability GetHalfFloatCapabilities() const;
 
  std::size_t GetProfilingTimerResolution() const;
 
  unsigned long GetMaximumAllocationSize() const;
 
  unsigned long GetGlobalMemorySize() const;
 
  enum CacheType {
    NoCache        = 0,
    ReadOnlyCache  = 1,
    ReadWriteCache = 2
  };
 
  CacheType GetGlobalMemoryCacheType() const;
 
  unsigned long GetGlobalMemoryCacheSize() const;
 
  unsigned int GetGlobalMemoryCacheLineSize() const;
 
  unsigned long GetLocalMemorySize() const;
 
  bool IsLocalMemorySeparate() const;
 
  unsigned long GetMaximumConstantBufferSize() const;
 
  unsigned int GetMaximumConstantArguments() const;
 
  unsigned int GetDefaultAlignment() const;
 
  unsigned int GetMinimumAlignment() const;
 
  std::size_t GetMaximumParameterBytes() const;
 
  bool IsFullProfile() const;
 
  bool IsEmbeddedProfile() const;
 
  std::string GetProfile() const;
 
  std::string GetDriverVersion() const;
 
  std::string GetName() const;
 
  std::string GetVendor() const;
 
  std::list< std::string > GetExtensions() const;
 
  std::string GetLanguageVersion() const;
 
  bool HasExtension( const std::string & name ) const;
 
  static std::list< OpenCLDevice > GetAllDevices();
 
  static std::list< OpenCLDevice > GetDevices( const OpenCLDevice::DeviceType types,
    const OpenCLPlatform & platform = OpenCLPlatform() );
 
  static std::list< OpenCLDevice > GetDevices( const OpenCLDevice::DeviceType type,
    const OpenCLPlatform::VendorType vendor );
 
  static OpenCLDevice GetMaximumFlopsDevice( const std::list< OpenCLDevice > & devices,
    const OpenCLDevice::DeviceType type );
 
  static OpenCLDevice GetMaximumFlopsDevice( const OpenCLDevice::DeviceType type );
 
  static OpenCLDevice GetMaximumFlopsDeviceByVendor( const OpenCLDevice::DeviceType type,
    const OpenCLPlatform::VendorType vendor );
 
  static OpenCLDevice GetMaximumFlopsDeviceByPlatform( const OpenCLDevice::DeviceType types,
    const OpenCLPlatform & platform = OpenCLPlatform() );
 
  static std::list< OpenCLDevice > GetMaximumFlopsDevices( const OpenCLDevice::DeviceType type,
    const OpenCLPlatform & platform = OpenCLPlatform() );
 
private:
 
  cl_device_id m_Id;
  mutable int  m_Version;
};
 
bool ITKOpenCL_EXPORT operator==( const OpenCLDevice & lhs, const OpenCLDevice & rhs );
 
bool ITKOpenCL_EXPORT operator!=( const OpenCLDevice & lhs, const OpenCLDevice & rhs );
 
template< typename charT, typename traits >
inline
std::basic_ostream< charT, traits > &
operator<<( std::basic_ostream< charT, traits > & strm,
  const OpenCLDevice & device )
{
  if( device.IsNull() )
  {
    strm << "OpenCLDevice(null)";
    return strm;
  }
 
  const char indent = ' ';
 
  strm << "OpenCLDevice" << std::endl
       << indent << "Id: " << device.GetDeviceId() << std::endl;
 
  strm << indent << "OpenCL version: ";
  switch( device.GetOpenCLVersion() )
  {
    case VERSION_1_0:
      strm << "1.0"; break;
    case VERSION_1_1:
      strm << "1.1"; break;
    case VERSION_1_2:
      strm << "1.2"; break;
    case VERSION_2_0:
      strm << "2.0"; break;
    case VERSION_2_1:
      strm << "2.1"; break;
    default:
      strm << "Unknown"; break;
  }
 
  strm << std::endl << indent << "Version: " << device.GetVersion() << std::endl;
 
  strm << indent << "Device type: ";
  switch( device.GetDeviceType() )
  {
    case OpenCLDevice::Default:
      strm << "Default"; break;
    case OpenCLDevice::CPU:
      strm << "CPU"; break;
    case OpenCLDevice::GPU:
      strm << "GPU"; break;
    case OpenCLDevice::Accelerator:
      strm << "Accelerator"; break;
    case OpenCLDevice::All:
      strm << "All"; break;
    default:
      strm << "Unknown"; break;
  }
 
  // strm << device.GetPlatform() << std::endl;
  strm << std::endl << indent << "Vendor Id: " << device.GetVendorId() << std::endl
       << indent << "Available: " << ( device.IsAvailable() ? "Yes" : "No" ) << std::endl
       << indent << "Has compiler: " << ( device.HasCompiler() ? "Yes" : "No" ) << std::endl
       << indent << "Has native kernels: " << ( device.HasNativeKernels() ? "Yes" : "No" ) << std::endl
       << indent << "Has out of order execution: " << ( device.HasOutOfOrderExecution() ? "Yes" : "No" ) << std::endl
       << indent << "Has double: " << ( device.HasDouble() ? "Yes" : "No" ) << std::endl
       << indent << "Has half float: " << ( device.HasHalfFloat() ? "Yes" : "No" ) << std::endl
       << indent << "Has error correcting memory: " << ( device.HasErrorCorrectingMemory() ? "Yes" : "No" ) << std::endl
       << indent << "Has unified memory: " << ( device.HasUnifiedMemory() ? "Yes" : "No" ) << std::endl
       << indent << "Compute units: " << device.GetComputeUnits() << std::endl
       << indent << "Clock frequency: " << device.GetClockFrequency() << std::endl
       << indent << "Address bits: " << device.GetAddressBits() << std::endl;
 
  strm << indent << "Byte order: ";
  switch( device.GetByteOrder() )
  {
    case OpenCLDevice::BigEndian:
      strm << "Big Endian"; break;
    case OpenCLDevice::LittleEndian:
      strm << "Little Endian"; break;
    default:
      strm << "Unknown"; break;
  }
 
  strm << std::endl << indent << "Maximum work item size: " << device.GetMaximumWorkItemSize() << std::endl
       << indent << "Maximum work items per group: " << device.GetMaximumWorkItemsPerGroup() << std::endl
       << indent << "Maximum work items per group: " << device.GetMaximumWorkItemsPerGroup() << std::endl;
 
  // Has Image 2D
  const bool hasImage2D = device.HasImage2D();
  strm << indent << "Has image 2D: " << ( hasImage2D ? "Yes" : "No" ) << std::endl;
  if( hasImage2D )
  {
    strm << indent << "Maximum image 2D size: " << device.GetMaximumImage2DSize() << std::endl;
  }
 
  // Has Image 3D
  const bool hasImage3D = device.HasImage3D();
  strm << indent << "Has image 3D: " << ( hasImage3D ? "Yes" : "No" ) << std::endl;
  if( hasImage3D )
  {
    strm << indent << "Maximum image 3D size: " << device.GetMaximumImage3DSize() << std::endl;
  }
 
  strm << indent << "Has writable image 3D: " << ( device.HasWritableImage3D() ? "Yes" : "No" ) << std::endl
       << indent << "Maximum samplers: " << device.GetMaximumSamplers() << std::endl
       << indent << "Maximum read images: " << device.GetMaximumReadImages() << std::endl
       << indent << "Maximum write images: " << device.GetMaximumWriteImages() << std::endl
 
       << indent << "Preferred char vector size: " << device.GetPreferredCharVectorSize() << std::endl
       << indent << "Preferred short vector size: " << device.GetPreferredShortVectorSize() << std::endl
       << indent << "Preferred int vector size: " << device.GetPreferredIntVectorSize() << std::endl
       << indent << "Preferred long vector size: " << device.GetPreferredLongVectorSize() << std::endl
       << indent << "Preferred float vector size: " << device.GetPreferredFloatVectorSize() << std::endl
       << indent << "Preferred double vector size: " << device.GetPreferredDoubleVectorSize() << std::endl
       << indent << "Preferred half float vector size: " << device.GetPreferredHalfFloatVectorSize() << std::endl
 
       << indent << "Native char vector size: " << device.GetNativeCharVectorSize() << std::endl
       << indent << "Native short vector size: " << device.GetNativeShortVectorSize() << std::endl
       << indent << "Native int vector size: " << device.GetNativeIntVectorSize() << std::endl
       << indent << "Native long vector size: " << device.GetNativeLongVectorSize() << std::endl
       << indent << "Native float vector size: " << device.GetNativeFloatVectorSize() << std::endl
       << indent << "Native double vector size: " << device.GetNativeDoubleVectorSize() << std::endl
       << indent << "Native half float vector size: " << device.GetNativeHalfFloatVectorSize() << std::endl;
 
  strm << indent << "Float capabilities: ";
  switch( device.GetFloatCapabilities() )
  {
    case OpenCLDevice::NotSupported:
      strm << "Not supported"; break;
    case OpenCLDevice::Denorm:
      strm << "Denorm"; break;
    case OpenCLDevice::InfinityNaN:
      strm << "Infinity nan"; break;
    case OpenCLDevice::RoundNearest:
      strm << "Round nearest"; break;
    case OpenCLDevice::RoundZero:
      strm << "Round zero"; break;
    case OpenCLDevice::RoundInfinity:
      strm << "Round infinity"; break;
    case OpenCLDevice::FusedMultiplyAdd:
      strm << "Fused multiply add"; break;
    default:
      strm << "Unknown"; break;
  }
 
  strm << std::endl << indent << "Double capabilities: ";
  switch( device.GetDoubleCapabilities() )
  {
    case OpenCLDevice::NotSupported:
      strm << "Not supported"; break;
    case OpenCLDevice::Denorm:
      strm << "Denorm"; break;
    case OpenCLDevice::InfinityNaN:
      strm << "Infinity NaN"; break;
    case OpenCLDevice::RoundNearest:
      strm << "Round nearest"; break;
    case OpenCLDevice::RoundZero:
      strm << "Round zero"; break;
    case OpenCLDevice::RoundInfinity:
      strm << "Round infinity"; break;
    case OpenCLDevice::FusedMultiplyAdd:
      strm << "Fused multiply add"; break;
    default:
      strm << "Unknown"; break;
  }
 
  strm << std::endl << indent << "Half float capabilities: ";
  switch( device.GetHalfFloatCapabilities() )
  {
    case OpenCLDevice::NotSupported:
      strm << "Not supported"; break;
    case OpenCLDevice::Denorm:
      strm << "Denorm"; break;
    case OpenCLDevice::InfinityNaN:
      strm << "Infinity NaN"; break;
    case OpenCLDevice::RoundNearest:
      strm << "Round nearest"; break;
    case OpenCLDevice::RoundZero:
      strm << "Round zero"; break;
    case OpenCLDevice::RoundInfinity:
      strm << "Round infinity"; break;
    case OpenCLDevice::FusedMultiplyAdd:
      strm << "Fused multiply add"; break;
    default:
      strm << "Unknown"; break;
  }
 
  strm << std::endl << indent << "Profiling timer resolution: " << device.GetProfilingTimerResolution() << std::endl
       << indent << "Maximum allocation size: " << device.GetMaximumAllocationSize() << std::endl
       << indent << "Global memory size: " << device.GetGlobalMemorySize() << std::endl;
 
  strm << indent << "Global memory cache type: ";
  switch( device.GetGlobalMemoryCacheType() )
  {
    case OpenCLDevice::NoCache:
      strm << "No cache"; break;
    case OpenCLDevice::ReadOnlyCache:
      strm << "Read only cache"; break;
    case OpenCLDevice::ReadWriteCache:
      strm << "Read write cache"; break;
    default:
      strm << "Unknown"; break;
  }
 
  strm << std::endl << indent << "Global memory cache size: " << device.GetGlobalMemoryCacheSize() << std::endl
       << indent << "Global memory cache line size: " << device.GetGlobalMemoryCacheLineSize() << std::endl
       << indent << "Local memory size: " << device.GetLocalMemorySize() << std::endl
       << indent << "Local memory separated: " << ( device.IsLocalMemorySeparate() ? "Yes" : "No" ) << std::endl
       << indent << "Maximum constant buffer size: " << device.GetMaximumConstantBufferSize() << std::endl
       << indent << "Maximum constant arguments: " << device.GetMaximumConstantArguments() << std::endl
       << indent << "Default alignment: " << device.GetDefaultAlignment() << std::endl
       << indent << "Minimum alignment: " << device.GetMinimumAlignment() << std::endl
       << indent << "Maximum parameter bytes: " << device.GetMaximumParameterBytes() << std::endl
       << indent << "Full profile: " << ( device.IsFullProfile() ? "Yes" : "No" ) << std::endl
       << indent << "Embedded profile: " << ( device.IsEmbeddedProfile() ? "Yes" : "No" ) << std::endl
       << indent << "Profile: " << device.GetProfile() << std::endl
       << indent << "Driver version: " << device.GetDriverVersion() << std::endl
       << indent << "Name: " << device.GetName() << std::endl
       << indent << "Vendor: " << device.GetVendor() << std::endl
       << indent << "Language Version: " << device.GetLanguageVersion() << std::endl;
 
  const std::list< std::string > extensions     = device.GetExtensions();
  const std::size_t              extensionsSize = extensions.size();
  strm << indent << "Extensions(" << extensionsSize << "): ";
  if( extensionsSize == 0 )
  {
    strm << "none";
  }
  else
  {
    strm << std::endl;
    for( std::list< std::string >::const_iterator it = extensions.begin(); it != extensions.end(); ++it )
    {
      strm << indent << indent << "- " << *it << std::endl;
    }
  }
 
  return strm;
}
 
 
} // end namespace itk
 
#endif /* __itkOpenCLDevice_h */