EIC code displayed by LXR master/​include/​boost/​compute/​device.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2024-11-15 09:04:31

 //---------------------------------------------------------------------------//
 // 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

This page was automatically generated by the 2.3.7 LXR engine. The LXR team