1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
//---------------------------------------------------------------------------//
// 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.
//---------------------------------------------------------------------------//
#ifndef BOOST_COMPUTE_ITERATOR_TRANSFORM_ITERATOR_HPP
#define BOOST_COMPUTE_ITERATOR_TRANSFORM_ITERATOR_HPP
#include <cstddef>
#include <iterator>
#include <boost/config.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/compute/functional.hpp>
#include <boost/compute/detail/meta_kernel.hpp>
#include <boost/compute/detail/is_buffer_iterator.hpp>
#include <boost/compute/detail/read_write_single_value.hpp>
#include <boost/compute/iterator/detail/get_base_iterator_buffer.hpp>
#include <boost/compute/type_traits/is_device_iterator.hpp>
#include <boost/compute/type_traits/result_of.hpp>
namespace boost {
namespace compute {
// forward declaration for transform_iterator
template<class InputIterator, class UnaryFunction>
class transform_iterator;
namespace detail {
// meta-function returning the value_type for a transform_iterator
template<class InputIterator, class UnaryFunction>
struct make_transform_iterator_value_type
{
typedef typename std::iterator_traits<InputIterator>::value_type value_type;
typedef typename boost::compute::result_of<UnaryFunction(value_type)>::type type;
};
// helper class which defines the iterator_adaptor super-class
// type for transform_iterator
template<class InputIterator, class UnaryFunction>
class transform_iterator_base
{
public:
typedef ::boost::iterator_adaptor<
::boost::compute::transform_iterator<InputIterator, UnaryFunction>,
InputIterator,
typename make_transform_iterator_value_type<InputIterator, UnaryFunction>::type,
typename std::iterator_traits<InputIterator>::iterator_category,
typename make_transform_iterator_value_type<InputIterator, UnaryFunction>::type
> type;
};
template<class InputIterator, class UnaryFunction, class IndexExpr>
struct transform_iterator_index_expr
{
typedef typename
make_transform_iterator_value_type<
InputIterator,
UnaryFunction
>::type result_type;
transform_iterator_index_expr(const InputIterator &input_iter,
const UnaryFunction &transform_expr,
const IndexExpr &index_expr)
: m_input_iter(input_iter),
m_transform_expr(transform_expr),
m_index_expr(index_expr)
{
}
InputIterator m_input_iter;
UnaryFunction m_transform_expr;
IndexExpr m_index_expr;
};
template<class InputIterator, class UnaryFunction, class IndexExpr>
inline meta_kernel& operator<<(meta_kernel &kernel,
const transform_iterator_index_expr<InputIterator,
UnaryFunction,
IndexExpr> &expr)
{
return kernel << expr.m_transform_expr(expr.m_input_iter[expr.m_index_expr]);
}
} // end detail namespace
/// \class transform_iterator
/// \brief A transform iterator adaptor.
///
/// The transform_iterator adaptor applies a unary function to each element
/// produced from the underlying iterator when dereferenced.
///
/// For example, to copy from an input range to an output range while taking
/// the absolute value of each element:
///
/// \snippet test/test_transform_iterator.cpp copy_abs
///
/// \see buffer_iterator, make_transform_iterator()
template<class InputIterator, class UnaryFunction>
class transform_iterator :
public detail::transform_iterator_base<InputIterator, UnaryFunction>::type
{
public:
typedef typename
detail::transform_iterator_base<InputIterator,
UnaryFunction>::type super_type;
typedef typename super_type::value_type value_type;
typedef typename super_type::reference reference;
typedef typename super_type::base_type base_type;
typedef typename super_type::difference_type difference_type;
typedef UnaryFunction unary_function;
transform_iterator(InputIterator iterator, UnaryFunction transform)
: super_type(iterator),
m_transform(transform)
{
}
transform_iterator(const transform_iterator<InputIterator,
UnaryFunction> &other)
: super_type(other.base()),
m_transform(other.m_transform)
{
}
transform_iterator<InputIterator, UnaryFunction>&
operator=(const transform_iterator<InputIterator,
UnaryFunction> &other)
{
if(this != &other){
super_type::operator=(other);
m_transform = other.m_transform;
}
return *this;
}
~transform_iterator()
{
}
size_t get_index() const
{
return super_type::base().get_index();
}
const buffer& get_buffer() const
{
return detail::get_base_iterator_buffer(*this);
}
template<class IndexExpression>
detail::transform_iterator_index_expr<InputIterator, UnaryFunction, IndexExpression>
operator[](const IndexExpression &expr) const
{
return detail::transform_iterator_index_expr<InputIterator,
UnaryFunction,
IndexExpression>(super_type::base(),
m_transform,
expr);
}
private:
friend class ::boost::iterator_core_access;
reference dereference() const
{
const context &context = super_type::base().get_buffer().get_context();
command_queue queue(context, context.get_device());
detail::meta_kernel k("read");
size_t output_arg = k.add_arg<value_type *>(memory_object::global_memory, "output");
k << "*output = " << m_transform(super_type::base()[k.lit(0)]) << ";";
kernel kernel = k.compile(context);
buffer output_buffer(context, sizeof(value_type));
kernel.set_arg(output_arg, output_buffer);
queue.enqueue_task(kernel);
return detail::read_single_value<value_type>(output_buffer, queue);
}
private:
UnaryFunction m_transform;
};
/// Returns a transform_iterator for \p iterator with \p transform.
///
/// \param iterator the underlying iterator
/// \param transform the unary transform function
///
/// \return a \c transform_iterator for \p iterator with \p transform
///
/// For example, to create an iterator which returns the square-root of each
/// value in a \c vector<int>:
/// \code
/// auto sqrt_iterator = make_transform_iterator(vec.begin(), sqrt<int>());
/// \endcode
template<class InputIterator, class UnaryFunction>
inline transform_iterator<InputIterator, UnaryFunction>
make_transform_iterator(InputIterator iterator, UnaryFunction transform)
{
return transform_iterator<InputIterator,
UnaryFunction>(iterator, transform);
}
/// \internal_ (is_device_iterator specialization for transform_iterator)
template<class InputIterator, class UnaryFunction>
struct is_device_iterator<
transform_iterator<InputIterator, UnaryFunction> > : boost::true_type {};
} // end compute namespace
} // end boost namespace
#endif // BOOST_COMPUTE_ITERATOR_TRANSFORM_ITERATOR_HPP
|
