w4kek
/
WSJT-X
mirror of https://github.com/saitohirga/WSJT-X.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
WSJT-X/boost/boost/compute/device.hpp

674 lines
21 KiB
C++
Raw Blame History

//---------------------------------------------------------------------------//
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//
#ifndef BOOST_COMPUTE_DEVICE_HPP
#define BOOST_COMPUTE_DEVICE_HPP
#include <algorithm>
#include <string>
#include <vector>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <boost/compute/config.hpp>
#include <boost/compute/exception.hpp>
#include <boost/compute/types/fundamental.hpp>
#include <boost/compute/detail/duration.hpp>
#include <boost/compute/detail/get_object_info.hpp>
#include <boost/compute/detail/assert_cl_success.hpp>
namespace boost {
namespace compute {
class platform;
/// \class device
/// \brief A compute device.
///
/// Typical compute devices include GPUs and multi-core CPUs. A list
/// of all compute devices available on a platform can be obtained
/// via the platform::devices() method.
///
/// The default compute device for the system can be obtained with
/// the system::default_device() method. For example:
///
/// \snippet test/test_device.cpp default_gpu
///
/// \see platform, context, command_queue
class device
{
public:
enum type {
cpu = CL_DEVICE_TYPE_CPU,
gpu = CL_DEVICE_TYPE_GPU,
accelerator = CL_DEVICE_TYPE_ACCELERATOR
};
/// Creates a null device object.
device()
: m_id(0)
{
}
/// Creates a new device object for \p id. If \p retain is \c true,
/// the reference count for the device will be incremented.
explicit device(cl_device_id id, bool retain = true)
: m_id(id)
{
#ifdef BOOST_COMPUTE_CL_VERSION_1_2
if(m_id && retain && is_subdevice()){
clRetainDevice(m_id);
}
#else
(void) retain;
#endif
}
/// Creates a new device object as a copy of \p other.
device(const device &other)
: m_id(other.m_id)
{
#ifdef BOOST_COMPUTE_CL_VERSION_1_2
if(m_id && is_subdevice()){
clRetainDevice(m_id);
}
#endif
}
/// Copies the device from \p other to \c *this.
device& operator=(const device &other)
{
if(this != &other){
#ifdef BOOST_COMPUTE_CL_VERSION_1_2
if(m_id && is_subdevice()){
clReleaseDevice(m_id);
}
#endif
m_id = other.m_id;
#ifdef BOOST_COMPUTE_CL_VERSION_1_2
if(m_id && is_subdevice()){
clRetainDevice(m_id);
}
#endif
}
return *this;
}
#ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES
/// Move-constructs a new device object from \p other.
device(device&& other) BOOST_NOEXCEPT
: m_id(other.m_id)
{
other.m_id = 0;
}
/// Move-assigns the device from \p other to \c *this.
device& operator=(device&& other) BOOST_NOEXCEPT
{
#ifdef BOOST_COMPUTE_CL_VERSION_1_2
if(m_id && is_subdevice()){
clReleaseDevice(m_id);
}
#endif
m_id = other.m_id;
other.m_id = 0;
return *this;
}
#endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES
/// Destroys the device object.
~device()
{
#ifdef BOOST_COMPUTE_CL_VERSION_1_2
if(m_id && is_subdevice()){
BOOST_COMPUTE_ASSERT_CL_SUCCESS(
clReleaseDevice(m_id)
);
}
#endif
}
/// Returns the ID of the device.
cl_device_id id() const
{
return m_id;
}
/// Returns a reference to the underlying OpenCL device id.
cl_device_id& get() const
{
return const_cast<cl_device_id&>(m_id);
}
/// Returns the type of the device.
cl_device_type type() const
{
return get_info<cl_device_type>(CL_DEVICE_TYPE);
}
#ifdef BOOST_COMPUTE_DOXYGEN_INVOKED
/// Returns the platform for the device.
platform platform() const;
#else
boost::compute::platform platform() const;
#endif
/// Returns the name of the device.
std::string name() const
{
return get_info<std::string>(CL_DEVICE_NAME);
}
/// Returns the name of the vendor for the device.
std::string vendor() const
{
return get_info<std::string>(CL_DEVICE_VENDOR);
}
/// Returns the device profile string.
std::string profile() const
{
return get_info<std::string>(CL_DEVICE_PROFILE);
}
/// Returns the device version string.
std::string version() const
{
return get_info<std::string>(CL_DEVICE_VERSION);
}
/// Returns the driver version string.
std::string driver_version() const
{
return get_info<std::string>(CL_DRIVER_VERSION);
}
/// Returns a list of extensions supported by the device.
std::vector<std::string> extensions() const
{
std::string extensions_string =
get_info<std::string>(CL_DEVICE_EXTENSIONS);
std::vector<std::string> extensions_vector;
boost::split(extensions_vector,
extensions_string,
boost::is_any_of("\t "),
boost::token_compress_on);
return extensions_vector;
}
/// Returns \c true if the device supports the extension with
/// \p name.
bool supports_extension(const std::string &name) const
{
const std::vector<std::string> extensions = this->extensions();
return std::find(
extensions.begin(), extensions.end(), name) != extensions.end();
}
/// Returns the number of address bits.
uint_ address_bits() const
{
return get_info<uint_>(CL_DEVICE_ADDRESS_BITS);
}
/// Returns the global memory size in bytes.
ulong_ global_memory_size() const
{
return get_info<ulong_>(CL_DEVICE_GLOBAL_MEM_SIZE);
}
/// Returns the local memory size in bytes.
ulong_ local_memory_size() const
{
return get_info<ulong_>(CL_DEVICE_LOCAL_MEM_SIZE);
}
/// Returns the clock frequency for the device's compute units.
uint_ clock_frequency() const
{
return get_info<uint_>(CL_DEVICE_MAX_CLOCK_FREQUENCY);
}
/// Returns the number of compute units in the device.
uint_ compute_units() const
{
return get_info<uint_>(CL_DEVICE_MAX_COMPUTE_UNITS);
}
/// \internal_
ulong_ max_memory_alloc_size() const
{
return get_info<ulong_>(CL_DEVICE_MAX_MEM_ALLOC_SIZE);
}
/// \internal_
size_t max_work_group_size() const
{
return get_info<size_t>(CL_DEVICE_MAX_WORK_GROUP_SIZE);
}
/// \internal_
uint_ max_work_item_dimensions() const
{
return get_info<uint_>(CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS);
}
/// Returns the preferred vector width for type \c T.
template<class T>
uint_ preferred_vector_width() const
{
return 0;
}
/// Returns the profiling timer resolution in nanoseconds.
size_t profiling_timer_resolution() const
{
return get_info<size_t>(CL_DEVICE_PROFILING_TIMER_RESOLUTION);
}
/// Returns \c true if the device is a sub-device.
bool is_subdevice() const
{
#if defined(BOOST_COMPUTE_CL_VERSION_1_2)
try {
return get_info<cl_device_id>(CL_DEVICE_PARENT_DEVICE) != 0;
}
catch(opencl_error&){
// the get_info() call above will throw if the device's opencl version
// is less than 1.2 (in which case it can't be a sub-device).
return false;
}
#else
return false;
#endif
}
/// Returns information about the device.
///
/// For example, to get the number of compute units:
/// \code
/// device.get_info<cl_uint>(CL_DEVICE_MAX_COMPUTE_UNITS);
/// \endcode
///
/// Alternatively, the template-specialized version can be used which
/// automatically determines the result type:
/// \code
/// device.get_info<CL_DEVICE_MAX_COMPUTE_UNITS>();
/// \endcode
///
/// \see_opencl_ref{clGetDeviceInfo}
template<class T>
T get_info(cl_device_info info) const
{
return detail::get_object_info<T>(clGetDeviceInfo, m_id, info);
}
/// \overload
template<int Enum>
typename detail::get_object_info_type<device, Enum>::type
get_info() const;
#if defined(BOOST_COMPUTE_CL_VERSION_1_2) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)
/// Partitions the device into multiple sub-devices according to
/// \p properties.
///
/// \opencl_version_warning{1,2}
std::vector<device>
partition(const cl_device_partition_property *properties) const
{
// get sub-device count
uint_ count = 0;
int_ ret = clCreateSubDevices(m_id, properties, 0, 0, &count);
if(ret != CL_SUCCESS){
BOOST_THROW_EXCEPTION(opencl_error(ret));
}
// get sub-device ids
std::vector<cl_device_id> ids(count);
ret = clCreateSubDevices(m_id, properties, count, &ids[0], 0);
if(ret != CL_SUCCESS){
BOOST_THROW_EXCEPTION(opencl_error(ret));
}
// convert ids to device objects
std::vector<device> devices(count);
for(size_t i = 0; i < count; i++){
devices[i] = device(ids[i], false);
}
return devices;
}
/// \opencl_version_warning{1,2}
std::vector<device> partition_equally(size_t count) const
{
cl_device_partition_property properties[] = {
CL_DEVICE_PARTITION_EQUALLY,
static_cast<cl_device_partition_property>(count),
0
};
return partition(properties);
}
/// \opencl_version_warning{1,2}
std::vector<device>
partition_by_counts(const std::vector<size_t> &counts) const
{
std::vector<cl_device_partition_property> properties;
properties.push_back(CL_DEVICE_PARTITION_BY_COUNTS);
for(size_t i = 0; i < counts.size(); i++){
properties.push_back(
static_cast<cl_device_partition_property>(counts[i]));
}
properties.push_back(CL_DEVICE_PARTITION_BY_COUNTS_LIST_END);
properties.push_back(0);
return partition(&properties[0]);
}
/// \opencl_version_warning{1,2}
std::vector<device>
partition_by_affinity_domain(cl_device_affinity_domain domain) const
{
cl_device_partition_property properties[] = {
CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN,
static_cast<cl_device_partition_property>(domain),
0
};
return partition(properties);
}
#endif // BOOST_COMPUTE_CL_VERSION_1_2
#if defined(BOOST_COMPUTE_CL_VERSION_2_1) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)
/// Returns the current value of the host clock as seen by device
/// in nanoseconds.
///
/// \see_opencl21_ref{clGetHostTimer}
///
/// \opencl_version_warning{2,1}
ulong_ get_host_timer() const
{
ulong_ host_timestamp = 0;
cl_int ret = clGetHostTimer(m_id, &host_timestamp);
if(ret != CL_SUCCESS){
BOOST_THROW_EXCEPTION(opencl_error(ret));
}
return host_timestamp;
}
/// Returns a reasonably synchronized pair of timestamps from the device timer
/// and the host timer as seen by device in nanoseconds. The first of returned
/// std::pair is a device timer timestamp, the second is a host timer timestamp.
///
/// \see_opencl21_ref{clGetDeviceAndHostTimer}
///
/// \opencl_version_warning{2,1}
std::pair<ulong_, ulong_> get_device_and_host_timer() const
{
ulong_ host_timestamp;
ulong_ device_timestamp;
cl_int ret = clGetDeviceAndHostTimer(
m_id, &device_timestamp, &host_timestamp
);
if(ret != CL_SUCCESS){
BOOST_THROW_EXCEPTION(opencl_error(ret));
}
return std::make_pair(
device_timestamp, host_timestamp
);
}
#if !defined(BOOST_COMPUTE_NO_HDR_CHRONO) || !defined(BOOST_COMPUTE_NO_BOOST_CHRONO)
/// Returns the current value of the host clock as seen by device
/// as duration.
///
/// For example, to print the current value of the host clock as seen by device
/// in milliseconds:
/// \code
/// std::cout << device.get_host_timer<std::chrono::milliseconds>().count() << " ms";
/// \endcode
///
/// \see_opencl21_ref{clGetHostTimer}
///
/// \opencl_version_warning{2,1}
template<class Duration>
Duration get_host_timer() const
{
const ulong_ nanoseconds = this->get_host_timer();
return detail::make_duration_from_nanoseconds(Duration(), nanoseconds);
}
/// Returns a reasonably synchronized pair of timestamps from the device timer
/// and the host timer as seen by device as a std::pair<Duration, Duration> value.
/// The first of returned std::pair is a device timer timestamp, the second is
/// a host timer timestamp.
///
/// \see_opencl21_ref{clGetDeviceAndHostTimer}
///
/// \opencl_version_warning{2,1}
template<class Duration>
std::pair<Duration, Duration> get_device_and_host_timer() const
{
const std::pair<ulong_, ulong_> timestamps = this->get_device_and_host_timer();
return std::make_pair(
detail::make_duration_from_nanoseconds(Duration(), timestamps.first),
detail::make_duration_from_nanoseconds(Duration(), timestamps.second)
);
}
#endif // !defined(BOOST_COMPUTE_NO_HDR_CHRONO) || !defined(BOOST_COMPUTE_NO_BOOST_CHRONO)
#endif // BOOST_COMPUTE_CL_VERSION_2_1
/// Returns \c true if the device is the same at \p other.
bool operator==(const device &other) const
{
return m_id == other.m_id;
}
/// Returns \c true if the device is different from \p other.
bool operator!=(const device &other) const
{
return m_id != other.m_id;
}
/// Returns \c true if the device OpenCL version is major.minor
/// or newer; otherwise returns \c false.
bool check_version(int major, int minor) const
{
std::stringstream stream;
stream << version();
int actual_major, actual_minor;
stream.ignore(7); // 'OpenCL '
stream >> actual_major;
stream.ignore(1); // '.'
stream >> actual_minor;
return actual_major > major ||
(actual_major == major && actual_minor >= minor);
}
private:
cl_device_id m_id;
};
/// \internal_
template<>
inline uint_ device::preferred_vector_width<short_>() const
{
return get_info<uint_>(CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT);
}
/// \internal_
template<>
inline uint_ device::preferred_vector_width<int_>() const
{
return get_info<uint_>(CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT);
}
/// \internal_
template<>
inline uint_ device::preferred_vector_width<long_>() const
{
return get_info<uint_>(CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG);
}
/// \internal_
template<>
inline uint_ device::preferred_vector_width<float_>() const
{
return get_info<uint_>(CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT);
}
/// \internal_
template<>
inline uint_ device::preferred_vector_width<double_>() const
{
return get_info<uint_>(CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE);
}
/// \internal_ define get_info() specializations for device
BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(device,
((cl_uint, CL_DEVICE_ADDRESS_BITS))
((bool, CL_DEVICE_AVAILABLE))
((bool, CL_DEVICE_COMPILER_AVAILABLE))
((bool, CL_DEVICE_ENDIAN_LITTLE))
((bool, CL_DEVICE_ERROR_CORRECTION_SUPPORT))
((cl_device_exec_capabilities, CL_DEVICE_EXECUTION_CAPABILITIES))
((std::string, CL_DEVICE_EXTENSIONS))
((cl_ulong, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE))
((cl_device_mem_cache_type, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE))
((cl_uint, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE))
((cl_ulong, CL_DEVICE_GLOBAL_MEM_SIZE))
((bool, CL_DEVICE_IMAGE_SUPPORT))
((size_t, CL_DEVICE_IMAGE2D_MAX_HEIGHT))
((size_t, CL_DEVICE_IMAGE2D_MAX_WIDTH))
((size_t, CL_DEVICE_IMAGE3D_MAX_DEPTH))
((size_t, CL_DEVICE_IMAGE3D_MAX_HEIGHT))
((size_t, CL_DEVICE_IMAGE3D_MAX_WIDTH))
((cl_ulong, CL_DEVICE_LOCAL_MEM_SIZE))
((cl_device_local_mem_type, CL_DEVICE_LOCAL_MEM_TYPE))
((cl_uint, CL_DEVICE_MAX_CLOCK_FREQUENCY))
((cl_uint, CL_DEVICE_MAX_COMPUTE_UNITS))
((cl_uint, CL_DEVICE_MAX_CONSTANT_ARGS))
((cl_ulong, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE))
((cl_ulong, CL_DEVICE_MAX_MEM_ALLOC_SIZE))
((size_t, CL_DEVICE_MAX_PARAMETER_SIZE))
((cl_uint, CL_DEVICE_MAX_READ_IMAGE_ARGS))
((cl_uint, CL_DEVICE_MAX_SAMPLERS))
((size_t, CL_DEVICE_MAX_WORK_GROUP_SIZE))
((cl_uint, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS))
((std::vector<size_t>, CL_DEVICE_MAX_WORK_ITEM_SIZES))
((cl_uint, CL_DEVICE_MAX_WRITE_IMAGE_ARGS))
((cl_uint, CL_DEVICE_MEM_BASE_ADDR_ALIGN))
((cl_uint, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE))
((std::string, CL_DEVICE_NAME))
((cl_platform_id, CL_DEVICE_PLATFORM))
((cl_uint, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR))
((cl_uint, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT))
((cl_uint, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT))
((cl_uint, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG))
((cl_uint, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT))
((cl_uint, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE))
((std::string, CL_DEVICE_PROFILE))
((size_t, CL_DEVICE_PROFILING_TIMER_RESOLUTION))
((cl_command_queue_properties, CL_DEVICE_QUEUE_PROPERTIES))
((cl_device_fp_config, CL_DEVICE_SINGLE_FP_CONFIG))
((cl_device_type, CL_DEVICE_TYPE))
((std::string, CL_DEVICE_VENDOR))
((cl_uint, CL_DEVICE_VENDOR_ID))
((std::string, CL_DEVICE_VERSION))
((std::string, CL_DRIVER_VERSION))
)
#ifdef CL_DEVICE_DOUBLE_FP_CONFIG
BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(device,
((cl_device_fp_config, CL_DEVICE_DOUBLE_FP_CONFIG))
)
#endif
#ifdef CL_DEVICE_HALF_FP_CONFIG
BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(device,
((cl_device_fp_config, CL_DEVICE_HALF_FP_CONFIG))
)
#endif
#ifdef BOOST_COMPUTE_CL_VERSION_1_1
BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(device,
((bool, CL_DEVICE_HOST_UNIFIED_MEMORY))
((cl_uint, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR))
((cl_uint, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT))
((cl_uint, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT))
((cl_uint, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG))
((cl_uint, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT))
((cl_uint, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE))
((std::string, CL_DEVICE_OPENCL_C_VERSION))
)
#endif // BOOST_COMPUTE_CL_VERSION_1_1
#ifdef BOOST_COMPUTE_CL_VERSION_1_2
BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(device,
((std::string, CL_DEVICE_BUILT_IN_KERNELS))
((bool, CL_DEVICE_LINKER_AVAILABLE))
((cl_device_id, CL_DEVICE_PARENT_DEVICE))
((cl_uint, CL_DEVICE_PARTITION_MAX_SUB_DEVICES))
((cl_device_partition_property, CL_DEVICE_PARTITION_PROPERTIES))
((cl_device_affinity_domain, CL_DEVICE_PARTITION_AFFINITY_DOMAIN))
((cl_device_partition_property, CL_DEVICE_PARTITION_TYPE))
((size_t, CL_DEVICE_PRINTF_BUFFER_SIZE))
((bool, CL_DEVICE_PREFERRED_INTEROP_USER_SYNC))
((cl_uint, CL_DEVICE_REFERENCE_COUNT))
)
#endif // BOOST_COMPUTE_CL_VERSION_1_2
#ifdef BOOST_COMPUTE_CL_VERSION_2_0
BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(device,
((size_t, CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE))
((size_t, CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE))
((cl_uint, CL_DEVICE_MAX_ON_DEVICE_EVENTS))
((cl_uint, CL_DEVICE_MAX_ON_DEVICE_QUEUES))
((cl_uint, CL_DEVICE_MAX_PIPE_ARGS))
((cl_uint, CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS))
((cl_uint, CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS))
((cl_uint, CL_DEVICE_PIPE_MAX_PACKET_SIZE))
((cl_uint, CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT))
((cl_uint, CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT))
((cl_uint, CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT))
((cl_uint, CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE))
((cl_uint, CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE))
((cl_command_queue_properties, CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES))
((cl_device_svm_capabilities, CL_DEVICE_SVM_CAPABILITIES))
((cl_uint, CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT))
((cl_uint, CL_DEVICE_IMAGE_PITCH_ALIGNMENT))
)
#endif // BOOST_COMPUTE_CL_VERSION_2_0
#ifdef BOOST_COMPUTE_CL_VERSION_2_1
BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(device,
((std::string, CL_DEVICE_IL_VERSION))
((cl_uint, CL_DEVICE_MAX_NUM_SUB_GROUPS))
((bool, CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS))
)
#endif // BOOST_COMPUTE_CL_VERSION_2_1
} // end compute namespace
} // end boost namespace
#endif // BOOST_COMPUTE_DEVICE_HPP
Reference in New Issue View Git Blame Copy Permalink