Merge pull request #726 from jszuppe/pr_device_host_timers

Add wrappers for clGetHostTimer and clGetDeviceAndHostTimer

Author: kylelutz

include/boost/compute/device.hpp

@@ -21,6 +21,7 @@
 #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>
 
@@ -395,6 +396,85 @@ class device
     }
     #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_opencl_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_opencl_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_opencl_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_opencl_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
     {
@@ -579,6 +659,14 @@ BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(device,
 )
 #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
 

include/boost/compute/platform.hpp

@@ -241,6 +241,12 @@ BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(platform,
     ((std::string, CL_PLATFORM_EXTENSIONS))
 )
 
+#ifdef BOOST_COMPUTE_CL_VERSION_2_1
+BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(platform,
+    ((cl_ulong, CL_PLATFORM_HOST_TIMER_RESOLUTION))
+)
+#endif // BOOST_COMPUTE_CL_VERSION_2_1
+
 inline boost::compute::platform device::platform() const
 {
     return boost::compute::platform(get_info<CL_DEVICE_PLATFORM>());

test/test_device.cpp

@@ -232,3 +232,54 @@ BOOST_AUTO_TEST_CASE(get_info_specializations)
 
     std::cout << device.get_info<CL_DEVICE_NAME>() << std::endl;
 }
+
+#ifdef BOOST_COMPUTE_CL_VERSION_2_1
+BOOST_AUTO_TEST_CASE(get_host_timer)
+{
+    boost::compute::device device = boost::compute::system::default_device();
+    BOOST_CHECK(device.get_host_timer() != 0);
+
+    #ifndef BOOST_COMPUTE_NO_HDR_CHRONO
+    typedef std::chrono::milliseconds stdms;
+    BOOST_CHECK(device.get_host_timer<stdms>().count() != 0);
+    #endif
+
+    #ifndef BOOST_COMPUTE_NO_BOOST_CHRONO
+    typedef boost::chrono::milliseconds bms;
+    BOOST_CHECK(device.get_host_timer<bms>().count() != 0);
+    #endif
+}
+
+BOOST_AUTO_TEST_CASE(get_device_and_host_timer)
+{
+    boost::compute::device device = boost::compute::system::default_device();
+    typedef std::pair<boost::compute::ulong_, boost::compute::ulong_> dah_timer;
+    dah_timer timer;
+    BOOST_CHECK_NO_THROW(timer = device.get_device_and_host_timer());
+    BOOST_CHECK(timer.first != 0);
+    BOOST_CHECK(timer.second != 0);
+
+    #ifndef BOOST_COMPUTE_NO_HDR_CHRONO
+    typedef std::chrono::milliseconds stdms;
+    BOOST_CHECK(device.get_device_and_host_timer<stdms>().first.count() != 0);
+    BOOST_CHECK(device.get_device_and_host_timer<stdms>().second.count() != 0);
+    #endif
+
+    #ifndef BOOST_COMPUTE_NO_BOOST_CHRONO
+    typedef boost::chrono::milliseconds bms;
+    BOOST_CHECK(device.get_device_and_host_timer<bms>().first.count() != 0);
+    BOOST_CHECK(device.get_device_and_host_timer<bms>().second.count() != 0);
+    #endif
+}
+
+BOOST_AUTO_TEST_CASE(get_info_opencl21_queries)
+{
+    boost::compute::device device = boost::compute::system::default_device();
+
+    BOOST_CHECK(!device.get_info<CL_DEVICE_IL_VERSION>().empty());
+    BOOST_CHECK(device.get_info<CL_DEVICE_MAX_NUM_SUB_GROUPS>() > 0);
+    BOOST_CHECK_NO_THROW(
+        device.get_info<CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS>()
+    );
+}
+#endif // BOOST_COMPUTE_CL_VERSION_2_1