123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293 |
- //---------------------------------------------------------------------------//
- // 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.
- //---------------------------------------------------------------------------//
- #define BOOST_TEST_MODULE TestDevice
- #include <boost/test/unit_test.hpp>
- #include <iostream>
- #include <boost/compute/device.hpp>
- #include <boost/compute/system.hpp>
- #include <boost/compute/detail/nvidia_compute_capability.hpp>
- #include "opencl_version_check.hpp"
- BOOST_AUTO_TEST_CASE(null_device)
- {
- boost::compute::device null;
- BOOST_CHECK(null.id() == cl_device_id());
- BOOST_CHECK(null.get() == cl_device_id());
- }
- BOOST_AUTO_TEST_CASE(default_device_doctest)
- {
- //! [default_gpu]
- boost::compute::device gpu = boost::compute::system::default_device();
- //! [default_gpu]
- BOOST_CHECK(gpu.id());
- }
- BOOST_AUTO_TEST_CASE(device_platform)
- {
- boost::compute::platform p = boost::compute::system::platforms().at(0);
- BOOST_CHECK(p == p.devices().at(0).platform());
- }
- BOOST_AUTO_TEST_CASE(get_device_name)
- {
- boost::compute::device gpu = boost::compute::system::default_device();
- if(gpu.id()){
- BOOST_CHECK(!gpu.name().empty());
- }
- }
- BOOST_AUTO_TEST_CASE(equality_operator)
- {
- boost::compute::device device1 = boost::compute::system::default_device();
- BOOST_CHECK(device1 == device1);
- boost::compute::device device2 = device1;
- BOOST_CHECK(device1 == device2);
- }
- BOOST_AUTO_TEST_CASE(get_max_work_item_sizes)
- {
- boost::compute::device device = boost::compute::system::default_device();
- std::vector<size_t> max_work_item_sizes =
- device.get_info<std::vector<size_t> >(CL_DEVICE_MAX_WORK_ITEM_SIZES);
- BOOST_CHECK_GE(max_work_item_sizes.size(), size_t(3));
- BOOST_CHECK_GE(max_work_item_sizes[0], size_t(1));
- BOOST_CHECK_GE(max_work_item_sizes[1], size_t(1));
- BOOST_CHECK_GE(max_work_item_sizes[2], size_t(1));
- }
- #ifdef BOOST_COMPUTE_CL_VERSION_1_2
- // returns true if the device supports the partitioning type
- bool supports_partition_type(const boost::compute::device &device,
- cl_device_partition_property type)
- {
- const std::vector<cl_device_partition_property> properties =
- device.get_info<std::vector<cl_device_partition_property> >(
- CL_DEVICE_PARTITION_PROPERTIES
- );
- return std::find(properties.begin(),
- properties.end(),
- type) != properties.end();
- }
- BOOST_AUTO_TEST_CASE(partition_device_equally)
- {
- // get default device and ensure it has at least two compute units
- boost::compute::device device = boost::compute::system::default_device();
- REQUIRES_OPENCL_VERSION(1,2);
- if(device.compute_units() < 2){
- std::cout << "skipping test: "
- << "device does not have enough compute units"
- << std::endl;
- return;
- }
- // check that the device supports partitioning equally
- if(!supports_partition_type(device, CL_DEVICE_PARTITION_EQUALLY)){
- std::cout << "skipping test: "
- << "device does not support CL_DEVICE_PARTITION_EQUALLY"
- << std::endl;
- return;
- }
- // ensure device is not a sub-device
- BOOST_CHECK(device.is_subdevice() == false);
- // partition default device into sub-devices with one compute unit each
- std::vector<boost::compute::device>
- sub_devices = device.partition_equally(1);
- BOOST_CHECK_EQUAL(sub_devices.size(), size_t(device.compute_units()));
- // verify each of the sub-devices
- for(size_t i = 0; i < sub_devices.size(); i++){
- const boost::compute::device &sub_device = sub_devices[i];
- // ensure parent device id is correct
- cl_device_id parent_id =
- sub_device.get_info<cl_device_id>(CL_DEVICE_PARENT_DEVICE);
- BOOST_CHECK(parent_id == device.id());
- // ensure device is a sub-device
- BOOST_CHECK(sub_device.is_subdevice() == true);
- // check number of compute units
- BOOST_CHECK_EQUAL(sub_device.compute_units(), size_t(1));
- }
- }
- // used to sort devices by number of compute units
- bool compare_compute_units(const boost::compute::device &a,
- const boost::compute::device &b)
- {
- return a.compute_units() < b.compute_units();
- }
- BOOST_AUTO_TEST_CASE(partition_by_counts)
- {
- // get default device and ensure it has at least four compute units
- boost::compute::device device = boost::compute::system::default_device();
- REQUIRES_OPENCL_VERSION(1,2);
- if(device.compute_units() < 4){
- std::cout << "skipping test: "
- << "device does not have enough compute units"
- << std::endl;
- return;
- }
- // check that the device supports partitioning by counts
- if(!supports_partition_type(device, CL_DEVICE_PARTITION_BY_COUNTS)){
- std::cout << "skipping test: "
- << "device does not support CL_DEVICE_PARTITION_BY_COUNTS"
- << std::endl;
- return;
- }
- // ensure device is not a sub-device
- BOOST_CHECK(device.is_subdevice() == false);
- // create vector of sub-device compute unit counts
- std::vector<size_t> counts;
- counts.push_back(2);
- counts.push_back(1);
- counts.push_back(1);
- // partition default device into sub-devices according to counts
- std::vector<boost::compute::device>
- sub_devices = device.partition_by_counts(counts);
- BOOST_CHECK_EQUAL(sub_devices.size(), size_t(3));
- // sort sub-devices by number of compute units (see issue #185)
- std::sort(sub_devices.begin(), sub_devices.end(), compare_compute_units);
- // verify each of the sub-devices
- BOOST_CHECK_EQUAL(sub_devices[0].compute_units(), size_t(1));
- BOOST_CHECK_EQUAL(sub_devices[1].compute_units(), size_t(1));
- BOOST_CHECK_EQUAL(sub_devices[2].compute_units(), size_t(2));
- }
- BOOST_AUTO_TEST_CASE(partition_by_affinity_domain)
- {
- // get default device and ensure it has at least two compute units
- boost::compute::device device = boost::compute::system::default_device();
- REQUIRES_OPENCL_VERSION(1,2);
- if(device.compute_units() < 2){
- std::cout << "skipping test: "
- << "device does not have enough compute units"
- << std::endl;
- return;
- }
- // check that the device supports splitting by affinity domains
- if(!supports_partition_type(device, CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE)){
- std::cout << "skipping test: "
- << "device does not support partitioning by affinity domain"
- << std::endl;
- return;
- }
- // ensure device is not a sub-device
- BOOST_CHECK(device.is_subdevice() == false);
- std::vector<boost::compute::device> sub_devices =
- device.partition_by_affinity_domain(
- CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE);
- BOOST_CHECK(sub_devices.size() > 0);
- BOOST_CHECK(sub_devices[0].is_subdevice() == true);
- }
- #endif // BOOST_COMPUTE_CL_VERSION_1_2
- BOOST_AUTO_TEST_CASE(nvidia_compute_capability)
- {
- boost::compute::device device = boost::compute::system::default_device();
- int major, minor;
- boost::compute::detail::get_nvidia_compute_capability(device, major, minor);
- boost::compute::detail::check_nvidia_compute_capability(device, 3, 0);
- }
- BOOST_AUTO_TEST_CASE(get_info_specializations)
- {
- boost::compute::device device = boost::compute::system::default_device();
- 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();
- REQUIRES_OPENCL_VERSION(2, 1);
- 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();
- REQUIRES_OPENCL_VERSION(2, 1);
- 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();
- REQUIRES_OPENCL_VERSION(2, 1);
- 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
|