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 TestTuple
12 #include <boost/test/unit_test.hpp>
13
14 #include <iostream>
15
16 #include <boost/tuple/tuple.hpp>
17 #include <boost/tuple/tuple_io.hpp>
18 #include <boost/tuple/tuple_comparison.hpp>
19
20 #include <boost/compute/algorithm/copy.hpp>
21 #include <boost/compute/algorithm/fill.hpp>
22 #include <boost/compute/algorithm/find.hpp>
23 #include <boost/compute/algorithm/transform.hpp>
24 #include <boost/compute/container/vector.hpp>
25 #include <boost/compute/types/tuple.hpp>
26
27 #include "quirks.hpp"
28 #include "check_macros.hpp"
29 #include "context_setup.hpp"
30
31 namespace compute = boost::compute;
32
BOOST_AUTO_TEST_CASE(vector_tuple_int_float)33 BOOST_AUTO_TEST_CASE(vector_tuple_int_float)
34 {
35 boost::compute::vector<boost::tuple<int, float> > vector(context);
36
37 vector.push_back(boost::make_tuple(1, 2.1f), queue);
38 vector.push_back(boost::make_tuple(2, 3.2f), queue);
39 vector.push_back(boost::make_tuple(3, 4.3f), queue);
40 }
41
BOOST_AUTO_TEST_CASE(copy_vector_tuple)42 BOOST_AUTO_TEST_CASE(copy_vector_tuple)
43 {
44 // create vector of tuples on device
45 boost::compute::vector<boost::tuple<char, int, float> > input(context);
46 input.push_back(boost::make_tuple('a', 1, 2.3f), queue);
47 input.push_back(boost::make_tuple('c', 3, 4.5f), queue);
48 input.push_back(boost::make_tuple('f', 6, 7.8f), queue);
49
50 // copy on device
51 boost::compute::vector<boost::tuple<char, int, float> > output(context);
52
53 boost::compute::copy(
54 input.begin(),
55 input.end(),
56 output.begin(),
57 queue
58 );
59
60 // copy to host
61 std::vector<boost::tuple<char, int, float> > host_output(3);
62
63 boost::compute::copy(
64 input.begin(),
65 input.end(),
66 host_output.begin(),
67 queue
68 );
69
70 // check tuple data
71 BOOST_CHECK_EQUAL(host_output[0], boost::make_tuple('a', 1, 2.3f));
72 BOOST_CHECK_EQUAL(host_output[1], boost::make_tuple('c', 3, 4.5f));
73 BOOST_CHECK_EQUAL(host_output[2], boost::make_tuple('f', 6, 7.8f));
74 }
75
BOOST_AUTO_TEST_CASE(extract_tuple_elements)76 BOOST_AUTO_TEST_CASE(extract_tuple_elements)
77 {
78 compute::vector<boost::tuple<char, int, float> > vector(context);
79 vector.push_back(boost::make_tuple('a', 1, 2.3f), queue);
80 vector.push_back(boost::make_tuple('c', 3, 4.5f), queue);
81 vector.push_back(boost::make_tuple('f', 6, 7.8f), queue);
82
83 compute::vector<char> chars(3, context);
84 compute::transform(
85 vector.begin(), vector.end(), chars.begin(), compute::get<0>(), queue
86 );
87 CHECK_RANGE_EQUAL(char, 3, chars, ('a', 'c', 'f'));
88
89 compute::vector<int> ints(3, context);
90 compute::transform(
91 vector.begin(), vector.end(), ints.begin(), compute::get<1>(), queue
92 );
93 CHECK_RANGE_EQUAL(int, 3, ints, (1, 3, 6));
94
95 compute::vector<float> floats(3, context);
96 compute::transform(
97 vector.begin(), vector.end(), floats.begin(), compute::get<2>(), queue
98 );
99 CHECK_RANGE_EQUAL(float, 3, floats, (2.3f, 4.5f, 7.8f));
100 }
101
BOOST_AUTO_TEST_CASE(fill_tuple_vector)102 BOOST_AUTO_TEST_CASE(fill_tuple_vector)
103 {
104 if(bug_in_struct_assignment(device)){
105 std::cerr << "skipping fill_tuple_vector test" << std::endl;
106 return;
107 }
108
109 compute::vector<boost::tuple<char, int, float> > vector(5, context);
110 compute::fill(vector.begin(), vector.end(), boost::make_tuple('z', 4, 3.14f), queue);
111
112 std::vector<boost::tuple<char, int, float> > host_output(5);
113 compute::copy(vector.begin(), vector.end(), host_output.begin(), queue);
114 BOOST_CHECK_EQUAL(host_output[0], boost::make_tuple('z', 4, 3.14f));
115 BOOST_CHECK_EQUAL(host_output[1], boost::make_tuple('z', 4, 3.14f));
116 BOOST_CHECK_EQUAL(host_output[2], boost::make_tuple('z', 4, 3.14f));
117 BOOST_CHECK_EQUAL(host_output[3], boost::make_tuple('z', 4, 3.14f));
118 BOOST_CHECK_EQUAL(host_output[4], boost::make_tuple('z', 4, 3.14f));
119 }
120
121 #ifndef BOOST_COMPUTE_NO_VARIADIC_TEMPLATES
BOOST_AUTO_TEST_CASE(variadic_tuple)122 BOOST_AUTO_TEST_CASE(variadic_tuple)
123 {
124 BOOST_CHECK_EQUAL(
125 (compute::type_name<boost::tuple<char, short, int, float> >()),
126 "boost_tuple_char_short_int_float_t"
127 );
128 }
129 #endif // BOOST_COMPUTE_NO_VARIADIC_TEMPLATES
130
131 #ifndef BOOST_COMPUTE_NO_STD_TUPLE
BOOST_AUTO_TEST_CASE(std_tuple)132 BOOST_AUTO_TEST_CASE(std_tuple)
133 {
134 BOOST_CHECK_EQUAL(
135 (compute::type_name<std::tuple<char, short, int, float>>()),
136 "std_tuple_char_short_int_float_t"
137 );
138 }
139 #endif // BOOST_COMPUTE_NO_STD_TUPLE
140
141 BOOST_AUTO_TEST_SUITE_END()
142