ceph/src/boost/libs/compute/test/test_strided_iterator.cpp

   1 //---------------------------------------------------------------------------//
   2 // Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com>
   3 //
   4 // Distributed under the Boost Software License, Version 1.0
   5 // See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt
   7 //
   8 // See http://boostorg.github.com/compute for more information.
   9 //---------------------------------------------------------------------------//
  10
  11 #define BOOST_TEST_MODULE TestStridedIterator
  12 #include <boost/test/unit_test.hpp>
  13
  14 #include <iterator>
  15
  16 #include <boost/type_traits.hpp>
  17 #include <boost/static_assert.hpp>
  18
  19 #include <boost/compute/algorithm/copy.hpp>
  20 #include <boost/compute/container/vector.hpp>
  21 #include <boost/compute/iterator/buffer_iterator.hpp>
  22 #include <boost/compute/iterator/strided_iterator.hpp>
  23
  24 #include "check_macros.hpp"
  25 #include "context_setup.hpp"
  26
  27 namespace bc = boost::compute;
  28
  29 BOOST_AUTO_TEST_CASE(value_type)
  30 {
  31     BOOST_STATIC_ASSERT((
  32         boost::is_same<
  33             boost::compute::strided_iterator<
  34                 boost::compute::buffer_iterator<int>
  35             >::value_type,
  36             int
  37         >::value
  38     ));
  39     BOOST_STATIC_ASSERT((
  40         boost::is_same<
  41             boost::compute::strided_iterator<
  42                 boost::compute::buffer_iterator<float>
  43             >::value_type,
  44             float
  45         >::value
  46     ));
  47 }
  48
  49 BOOST_AUTO_TEST_CASE(base_type)
  50 {
  51     BOOST_STATIC_ASSERT((
  52         boost::is_same<
  53             boost::compute::strided_iterator<
  54                 boost::compute::buffer_iterator<int>
  55             >::base_type,
  56             boost::compute::buffer_iterator<int>
  57         >::value
  58     ));
  59 }
  60
  61 BOOST_AUTO_TEST_CASE(distance)
  62 {
  63     int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
  64     boost::compute::vector<int> vec(data, data + 8, queue);
  65
  66     BOOST_CHECK_EQUAL(
  67          std::distance(
  68              boost::compute::make_strided_iterator(vec.begin(), 1),
  69              boost::compute::make_strided_iterator(vec.end(), 1)
  70          ),
  71          std::ptrdiff_t(8)
  72     );
  73     BOOST_CHECK_EQUAL(
  74         std::distance(
  75             boost::compute::make_strided_iterator(vec.begin(), 2),
  76             boost::compute::make_strided_iterator(vec.end(), 2)
  77         ),
  78         std::ptrdiff_t(4)
  79     );
  80
  81     BOOST_CHECK_EQUAL(
  82         std::distance(
  83             boost::compute::make_strided_iterator(vec.begin(), 3),
  84             boost::compute::make_strided_iterator(vec.begin()+6, 3)
  85         ),
  86         std::ptrdiff_t(2)
  87     );
  88 }
  89
  90 BOOST_AUTO_TEST_CASE(copy)
  91 {
  92     boost::compute::int_ data[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
  93     boost::compute::vector<boost::compute::int_> vec(data, data + 8, queue);
  94
  95     boost::compute::vector<boost::compute::int_> result(4, context);
  96
  97     // copy every other element to result
  98     boost::compute::copy(
  99         boost::compute::make_strided_iterator(vec.begin(), 2),
 100         boost::compute::make_strided_iterator(vec.end(), 2),
 101         result.begin(),
 102         queue
 103     );
 104     CHECK_RANGE_EQUAL(boost::compute::int_, 4, result, (1, 3, 5, 7));
 105
 106     // copy every 3rd element to result
 107     boost::compute::copy(
 108         boost::compute::make_strided_iterator(vec.begin(), 3),
 109         boost::compute::make_strided_iterator(vec.begin()+9, 3),
 110         result.begin(),
 111         queue
 112     );
 113     CHECK_RANGE_EQUAL(boost::compute::int_, 3, result, (1, 4, 7));
 114 }
 115
 116 BOOST_AUTO_TEST_CASE(make_strided_iterator_end)
 117 {
 118     boost::compute::int_ data[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 119     boost::compute::vector<boost::compute::int_> vec(data, data + 8, queue);
 120
 121     // stride equals 3
 122     typedef boost::compute::vector<boost::compute::int_>::iterator IterType;
 123     boost::compute::strided_iterator<IterType> end =
 124         boost::compute::make_strided_iterator_end(vec.begin(),
 125                                                   vec.end(),
 126                                                   3);
 127
 128     // end should be vec.begin() + 9 which is one step after last element
 129     // accessible through strided_iterator, i.e. vec.begin()+6
 130     BOOST_CHECK(boost::compute::make_strided_iterator(vec.begin()+9, 3) ==
 131                 end);
 132
 133     // stride equals 2
 134     end = boost::compute::make_strided_iterator_end(vec.begin(),
 135                                                     vec.end(),
 136                                                     2);
 137     // end should be vec.end(), because vector size is divisible by 2
 138     BOOST_CHECK(boost::compute::make_strided_iterator(vec.end(), 2) == end);
 139
 140     // stride equals 1000
 141     end = boost::compute::make_strided_iterator_end(vec.begin(),
 142                                                     vec.end(),
 143                                                     1000);
 144     // end should be vec.begin() + 1000, because stride > vector size
 145     BOOST_CHECK(boost::compute::make_strided_iterator(vec.begin()+1000, 1000) ==
 146                 end);
 147
 148
 149     // test boost::compute::make_strided_iterator_end with copy(..)
 150
 151     boost::compute::vector<boost::compute::int_> result(4, context);
 152
 153     // copy every other element to result
 154     boost::compute::copy(
 155         boost::compute::make_strided_iterator(vec.begin()+1, 2),
 156         boost::compute::make_strided_iterator_end(vec.begin()+1, vec.end(), 2),
 157         result.begin(),
 158         queue
 159     );
 160     CHECK_RANGE_EQUAL(boost::compute::int_, 4, result, (2, 4, 6, 8));
 161 }
 162
 163 BOOST_AUTO_TEST_CASE(iterator_tag)
 164 {
 165     typedef bc::buffer_iterator<bc::float_> i_type;
 166
 167     BOOST_STATIC_ASSERT((
 168         boost::is_same<
 169             std::iterator_traits<
 170                 i_type
 171             >::iterator_category,
 172             std::iterator_traits<
 173                 bc::strided_iterator<i_type>
 174             >::iterator_category
 175         >::value
 176     ));
 177 }
 178
 179 BOOST_AUTO_TEST_CASE(std_distance)
 180 {
 181     bc::vector<bc::float_> vec(
 182         size_t(300),
 183         bc::float_(1.1f),
 184         queue
 185     );
 186
 187     bc::strided_iterator<bc::buffer_iterator<bc::float_> > begin(vec.begin(), 1);
 188     bc::strided_iterator<bc::buffer_iterator<bc::float_> > end(vec.end(), 1);
 189
 190     BOOST_CHECK_EQUAL(std::distance(begin, end),  300);
 191     BOOST_CHECK_EQUAL(std::distance(end, begin), -300);
 192 }
 193
 194 BOOST_AUTO_TEST_SUITE_END()