GOSTCoin CUDA miner project, compatible with most nvidia cards, containing only gostd algo
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

246 lines
7.7 KiB

/*
* Copyright 2008-2012 NVIDIA Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*! \file thrust/iterator/zip_iterator.h
* \brief An iterator which returns a tuple of the result of dereferencing
* a tuple of iterators when dereferenced
*/
/*
* Copyright David Abrahams and Thomas Becker 2000-2006.
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying NOTICE file for the complete license)
*
* For more information, see http://www.boost.org
*/
#pragma once
#include <thrust/detail/config.h>
#include <thrust/iterator/detail/zip_iterator_base.h>
#include <thrust/iterator/iterator_facade.h>
#include <thrust/detail/type_traits.h>
namespace thrust
{
/*! \addtogroup iterators
* \{
*/
/*! \addtogroup fancyiterator Fancy Iterators
* \ingroup iterators
* \{
*/
/*! \p zip_iterator is an iterator which represents a pointer into a range
* of \p tuples whose elements are themselves taken from a \p tuple of input
* iterators. This iterator is useful for creating a virtual array of structures
* while achieving the same performance and bandwidth as the structure of arrays
* idiom. \p zip_iterator also facilitates kernel fusion by providing a convenient
* means of amortizing the execution of the same operation over multiple ranges.
*
* The following code snippet demonstrates how to create a \p zip_iterator
* which represents the result of "zipping" multiple ranges together.
*
* \code
* #include <thrust/iterator/zip_iterator.h>
* #include <thrust/tuple.h>
* #include <thrust/device_vector.h>
* ...
* thrust::device_vector<int> int_v(3);
* int_v[0] = 0; int_v[1] = 1; int_v[2] = 2;
*
* thrust::device_vector<float> float_v(3);
* float_v[0] = 0.0f; float_v[1] = 1.0;f float_v[2] = 2.0f;
*
* thrust::device_vector<char> char_v(3);
* char_v[0] = 'a'; char_v[1] = 'b'; char_v[2] = 'c';
*
* // typedef these iterators for shorthand
* typedef thrust::device_vector<int>::iterator IntIterator;
* typedef thrust::device_vector<float>::iterator FloatIterator;
* typedef thrust::device_vector<char>::iterator CharIterator;
*
* // typedef a tuple of these iterators
* typedef thrust::tuple<IntIterator, FloatIterator, CharIterator> IteratorTuple;
*
* // typedef the zip_iterator of this tuple
* typedef thrust::zip_iterator<IteratorTuple> ZipIterator;
*
* // finally, create the zip_iterator
* ZipIterator iter(thrust::make_tuple(int_v.begin(), float_v.begin(), char_v.begin()));
*
* *iter; // returns (0, 0.0f, 'a')
* iter[0]; // returns (0, 0.0f, 'a')
* iter[1]; // returns (1, 1.0f, 'b')
* iter[2]; // returns (2, 2.0f, 'c')
*
* thrust::get<0>(iter[2]); // returns 2
* thrust::get<1>(iter[0]); // returns 0.0f
* thrust::get<2>(iter[1]); // returns 'b'
*
* // iter[3] is an out-of-bounds error
* \endcode
*
* Defining the type of a \p zip_iterator can be complex. The next code example demonstrates
* how to use the \p make_zip_iterator function with the \p make_tuple function to avoid
* explicitly specifying the type of the \p zip_iterator. This example shows how to use
* \p zip_iterator to copy multiple ranges with a single call to \p thrust::copy.
*
* \code
* #include <thrust/zip_iterator.h>
* #include <thrust/tuple.h>
* #include <thrust/device_vector.h>
*
* int main(void)
* {
* thrust::device_vector<int> int_in(3), int_out(3);
* int_in[0] = 0;
* int_in[1] = 1;
* int_in[2] = 2;
*
* thrust::device_vector<float> float_in(3), float_out(3);
* float_in[0] = 0.0f;
* float_in[1] = 10.0f;
* float_in[2] = 20.0f;
*
* thrust::copy(thrust::make_zip_iterator(thrust::make_tuple(int_in.begin(), float_in.begin())),
* thrust::make_zip_iterator(thrust::make_tuple(int_in.end(), float_in.end())),
* thrust::make_zip_iterator(thrust::make_tuple(int_out.begin(),float_out.begin())));
*
* // int_out is now [0, 1, 2]
* // float_out is now [0.0f, 10.0f, 20.0f]
*
* return 0;
* }
* \endcode
*
* \see make_zip_iterator
* \see make_tuple
* \see tuple
* \see get
*/
template <typename IteratorTuple>
class zip_iterator
: public detail::zip_iterator_base<IteratorTuple>::type
{
public:
/*! Null constructor does nothing.
*/
inline __host__ __device__
zip_iterator(void);
/*! This constructor creates a new \p zip_iterator from a
* \p tuple of iterators.
*
* \param iterator_tuple The \p tuple of iterators to copy from.
*/
inline __host__ __device__
zip_iterator(IteratorTuple iterator_tuple);
/*! This copy constructor creates a new \p zip_iterator from another
* \p zip_iterator.
*
* \param other The \p zip_iterator to copy.
*/
template<typename OtherIteratorTuple>
inline __host__ __device__
zip_iterator(const zip_iterator<OtherIteratorTuple> &other,
typename thrust::detail::enable_if_convertible<
OtherIteratorTuple,
IteratorTuple
>::type * = 0);
/*! This method returns a \c const reference to this \p zip_iterator's
* \p tuple of iterators.
*
* \return A \c const reference to this \p zip_iterator's \p tuple
* of iterators.
*/
inline __host__ __device__
const IteratorTuple &get_iterator_tuple() const;
/*! \cond
*/
private:
typedef typename
detail::zip_iterator_base<IteratorTuple>::type super_t;
friend class thrust::iterator_core_access;
// Dereferencing returns a tuple built from the dereferenced
// iterators in the iterator tuple.
__host__ __device__
typename super_t::reference dereference() const;
// Two zip_iterators are equal if the two first iterators of the
// tuple are equal. Note this differs from Boost's implementation, which
// considers the entire tuple.
template<typename OtherIteratorTuple>
inline __host__ __device__
bool equal(const zip_iterator<OtherIteratorTuple> &other) const;
// Advancing a zip_iterator means to advance all iterators in the tuple
inline __host__ __device__
void advance(typename super_t::difference_type n);
// Incrementing a zip iterator means to increment all iterators in the tuple
inline __host__ __device__
void increment();
// Decrementing a zip iterator means to decrement all iterators in the tuple
inline __host__ __device__
void decrement();
// Distance is calculated using the first iterator in the tuple.
template<typename OtherIteratorTuple>
inline __host__ __device__
typename super_t::difference_type
distance_to(const zip_iterator<OtherIteratorTuple> &other) const;
// The iterator tuple.
IteratorTuple m_iterator_tuple;
/*! \endcond
*/
}; // end zip_iterator
/*! \p make_zip_iterator creates a \p zip_iterator from a \p tuple
* of iterators.
*
* \param t The \p tuple of iterators to copy.
* \return A newly created \p zip_iterator which zips the iterators encapsulated in \p t.
*
* \see zip_iterator
*/
template<typename IteratorTuple>
inline __host__ __device__
zip_iterator<IteratorTuple> make_zip_iterator(IteratorTuple t);
/*! \} // end fancyiterators
*/
/*! \} // end iterators
*/
} // end thrust
#include <thrust/iterator/detail/zip_iterator.inl>