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

   1 //---------------------------------------------------------------------------//
   2 // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@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 TestCount
  12 #include <boost/test/unit_test.hpp>
  13
  14 #include <string>
  15
  16 #include <boost/compute/command_queue.hpp>
  17 #include <boost/compute/function.hpp>
  18 #include <boost/compute/lambda.hpp>
  19 #include <boost/compute/system.hpp>
  20 #include <boost/compute/algorithm/copy.hpp>
  21 #include <boost/compute/algorithm/count.hpp>
  22 #include <boost/compute/algorithm/count_if.hpp>
  23 #include <boost/compute/algorithm/iota.hpp>
  24 #include <boost/compute/container/vector.hpp>
  25 #include <boost/compute/iterator/constant_iterator.hpp>
  26
  27 #include "context_setup.hpp"
  28
  29 namespace bc = boost::compute;
  30 namespace compute = boost::compute;
  31
  32 BOOST_AUTO_TEST_CASE(count_int)
  33 {
  34     int data[] = { 1, 2, 1, 2, 3 };
  35     bc::vector<int> vector(data, data + 5, queue);
  36     BOOST_CHECK_EQUAL(bc::count(vector.begin(), vector.end(), 1, queue), size_t(2));
  37     BOOST_CHECK_EQUAL(bc::count(vector.begin(), vector.end(), 2, queue), size_t(2));
  38     BOOST_CHECK_EQUAL(bc::count(vector.begin(), vector.end(), 3, queue), size_t(1));
  39     BOOST_CHECK_EQUAL(bc::count(vector.begin() + 1, vector.end(), 1, queue), size_t(1));
  40     BOOST_CHECK_EQUAL(bc::count(vector.begin() + 1, vector.end() - 1, 3, queue), size_t(0));
  41     BOOST_CHECK_EQUAL(bc::count(vector.begin() + 1, vector.end() - 1, 2, queue), size_t(2));
  42 }
  43
  44 BOOST_AUTO_TEST_CASE(count_constant_int_range)
  45 {
  46     BOOST_CHECK_EQUAL(
  47         bc::count(bc::make_constant_iterator(18, 0),
  48                   bc::make_constant_iterator(18, 5),
  49                   18,
  50                   queue),
  51         size_t(5)
  52     );
  53
  54     BOOST_CHECK_EQUAL(
  55         bc::count(bc::make_constant_iterator(19, 0),
  56                   bc::make_constant_iterator(19, 5),
  57                   18,
  58                   queue),
  59         size_t(0)
  60     );
  61 }
  62
  63 BOOST_AUTO_TEST_CASE(count_if_greater_than_two)
  64 {
  65     float data[] = { 1.0f, 2.5f, -1.0f, 3.0f, 5.0f, -8.0f };
  66     bc::vector<float> vector(data, data + 5, queue);
  67
  68     BOOST_CHECK_EQUAL(
  69         bc::count_if(vector.begin(), vector.end(), bc::_1 > 2.0f, queue),
  70         size_t(3)
  71     );
  72 }
  73
  74 BOOST_AUTO_TEST_CASE(count_int4)
  75 {
  76     int data[] = { 1, 2, 3, 4,
  77                    4, 5, 6, 7,
  78                    7, 8, 9, 1,
  79                    1, 2, 3, 4,
  80                    4, 5, 6, 7,
  81                    0, 3, 2, 2 };
  82     bc::vector<bc::int4_> vector(reinterpret_cast<bc::int4_ *>(data),
  83                                  reinterpret_cast<bc::int4_ *>(data) + 6,
  84                                  queue);
  85     BOOST_CHECK_EQUAL(vector.size(), size_t(6));
  86
  87     BOOST_CHECK_EQUAL(
  88         bc::count(vector.begin(), vector.end(), bc::int4_(1, 2, 3, 4), queue),
  89         size_t(2)
  90     );
  91     BOOST_CHECK_EQUAL(
  92         bc::count(vector.begin(), vector.end(), bc::int4_(4, 5, 6, 7), queue),
  93         size_t(2)
  94     );
  95     BOOST_CHECK_EQUAL(
  96         bc::count(vector.begin(), vector.end(), bc::int4_(7, 8, 9, 1), queue),
  97         size_t(1)
  98     );
  99     BOOST_CHECK_EQUAL(
 100         bc::count(vector.begin(), vector.end(), bc::int4_(0, 3, 2, 2), queue),
 101         size_t(1)
 102     );
 103     BOOST_CHECK_EQUAL(
 104         bc::count(vector.begin(), vector.end(), bc::int4_(3, 4, 4, 5), queue),
 105         size_t(0)
 106     );
 107     BOOST_CHECK_EQUAL(
 108         bc::count(vector.begin(), vector.end(), bc::int4_(1, 2, 3, 0), queue),
 109         size_t(0)
 110     );
 111     BOOST_CHECK_EQUAL(
 112         bc::count(vector.begin(), vector.end(), bc::int4_(1, 9, 8, 7), queue),
 113         size_t(0)
 114     );
 115 }
 116
 117 BOOST_AUTO_TEST_CASE(count_newlines)
 118 {
 119     std::string string = "abcdefg\nhijklmn\nopqrs\ntuv\nwxyz\n";
 120     compute::vector<char> data(string.size(), context);
 121     compute::copy(string.begin(), string.end(), data.begin(), queue);
 122
 123     BOOST_CHECK_EQUAL(
 124         compute::count(data.begin(), data.end(), '\n', queue),
 125         size_t(5)
 126     );
 127 }
 128
 129 BOOST_AUTO_TEST_CASE(count_uchar)
 130 {
 131     using boost::compute::uchar_;
 132
 133     unsigned char data[] = { 0x00, 0x10, 0x2F, 0x10, 0x01, 0x00, 0x01, 0x00 };
 134     compute::vector<uchar_> vector(8, context);
 135     compute::copy(data, data + 8, vector.begin(), queue);
 136
 137     BOOST_CHECK_EQUAL(
 138         compute::count(vector.begin(), vector.end(), 0x00, queue),
 139         size_t(3)
 140     );
 141     BOOST_CHECK_EQUAL(
 142         compute::count(vector.begin(), vector.end(), 0x10, queue),
 143         size_t(2)
 144     );
 145     BOOST_CHECK_EQUAL(
 146         compute::count(vector.begin(), vector.end(), 0x2F, queue),
 147         size_t(1)
 148     );
 149     BOOST_CHECK_EQUAL(
 150         compute::count(vector.begin(), vector.end(), 0x01, queue),
 151         size_t(2)
 152     );
 153     BOOST_CHECK_EQUAL(
 154         compute::count(vector.begin(), vector.end(), 0xFF, queue),
 155         size_t(0)
 156     );
 157 }
 158
 159 BOOST_AUTO_TEST_CASE(count_vector_component)
 160 {
 161     int data[] = {
 162         1, 2,
 163         3, 4,
 164         5, 6,
 165         7, 8
 166     };
 167
 168     using boost::compute::int2_;
 169
 170     compute::vector<int2_> vector(4, context);
 171     compute::copy(
 172         reinterpret_cast<int2_ *>(data),
 173         reinterpret_cast<int2_ *>(data) + 4,
 174         vector.begin(),
 175         queue
 176     );
 177
 178     using boost::compute::lambda::_1;
 179     using boost::compute::lambda::get;
 180
 181     BOOST_CHECK_EQUAL(
 182         compute::count_if(vector.begin(), vector.end(), get<0>(_1) < 4, queue),
 183         size_t(2)
 184     );
 185     BOOST_CHECK_EQUAL(
 186         compute::count_if(vector.begin(), vector.end(), get<1>(_1) > 3, queue),
 187         size_t(3)
 188     );
 189 }
 190
 191 BOOST_AUTO_TEST_CASE(count_if_odd)
 192 {
 193     compute::vector<int> vec(2048, context);
 194     compute::iota(vec.begin(), vec.end(), 0, queue);
 195
 196     BOOST_COMPUTE_FUNCTION(bool, is_odd, (int x),
 197     {
 198         return x & 1;
 199     });
 200
 201     BOOST_CHECK_EQUAL(
 202         compute::count_if(vec.begin(), vec.end(), is_odd, queue), vec.size() / 2
 203     );
 204 }
 205
 206 BOOST_AUTO_TEST_CASE(count_if_with_reduce)
 207 {
 208     compute::vector<int> vec(2048, context);
 209     compute::iota(vec.begin(), vec.end(), 0, queue);
 210
 211     using boost::compute::lambda::_1;
 212
 213     BOOST_CHECK_EQUAL(
 214         compute::detail::count_if_with_reduce(
 215             vec.begin(), vec.end(), _1 > 1024, queue
 216         ),
 217         size_t(1023)
 218     );
 219 }
 220
 221 BOOST_AUTO_TEST_SUITE_END()