join_iterator.h

Go to the documentation of this file.

/*
 *  Copyright 2008-2014 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.
 */
 
#pragma once
 
#include <cusp/detail/config.h>
 
#include <cusp/memory.h>
 
#include <thrust/distance.h>
#include <thrust/functional.h>
 
#include <thrust/iterator/transform_iterator.h>
 
namespace cusp
{
 
// Helper struct that does the actual work
template <::cuda::std::size_t N, typename T, typename Indices = ::cuda::std::make_index_sequence<N>>
struct make_tuple_of_impl;
 
// Specialization that expands the index sequence into tuple parameters
template <::cuda::std::size_t N, typename T, ::cuda::std::size_t... Is>
struct make_tuple_of_impl<N, T, ::cuda::std::index_sequence<Is...>> {
    // A helper that ignores its template argument and always yields T
    template<::cuda::std::size_t>
    using type_t = T;
    
    // Expand the indices `Is...` to create a pack of N types T
    using type = ::cuda::std::tuple<type_t<Is>...>;
};
 
// Final user-facing alias template
template <::cuda::std::size_t N, typename T>
using make_tuple_of = typename make_tuple_of_impl<N, T>::type;
 
template<typename T, typename V, int SIZE>
struct join_search
{
    template<typename SizesTuple, typename Tuple>
    _CCCL_HOST_DEVICE
    V operator()(const SizesTuple &t1, const Tuple& t2, const T i) const
    {
        return (i >= T(::cuda::std::get<SIZE-2>(t1))) ? V(::cuda::std::get<SIZE-1>(t2)[i]) : join_search<T,V,SIZE-1>()(t1,t2,i);
    }
};
 
template<typename T, typename V>
struct join_search<T,V,2>
{
    template<typename SizesTuple, typename Tuple>
    _CCCL_HOST_DEVICE
    V operator()(const SizesTuple &t1, const Tuple& t2, const T i) const
    {
        if (i >= T(::cuda::std::get<0>(t1)))
            return ::cuda::std::get<1>(t2)[i];
        else
            return ::cuda::std::get<0>(t2)[i];
    }
};
template <typename Tuple>
class join_iterator
{
public:
 
    typedef typename ::cuda::std::tuple_element<0,Tuple>::type          Iterator1;
    typedef typename ::cuda::std::iterator_traits<Iterator1>::value_type       value_type;
    typedef typename ::cuda::std::iterator_traits<Iterator1>::pointer     pointer;
    typedef typename ::cuda::std::iterator_traits<Iterator1>::reference   reference;
    typedef typename ::cuda::std::iterator_traits<Iterator1>::difference_type  difference_type;
    typedef typename ::cuda::std::iterator_traits<Iterator1>::difference_type  size_type;
    typedef typename thrust::iterator_system<Iterator1>::type      space;
    typedef typename cusp::iterator_system<space>::type            memory_space;
 
    const static size_t tuple_size = ::cuda::std::tuple_size<Tuple>::value;
 
    // forward definition
    struct join_select_functor;
 
    typedef make_tuple_of<tuple_size-1,size_t>                            SizesTuple;
    typedef typename ::cuda::std::tuple_element<tuple_size-1,Tuple>::type      IndexIterator;
    typedef thrust::transform_iterator<join_select_functor,IndexIterator> TransformIterator;
 
    struct join_select_functor
    {
        SizesTuple t1;
        Tuple t2;
 
        _CCCL_HOST_DEVICE
        join_select_functor(void) {}
 
        _CCCL_HOST_DEVICE
        join_select_functor(const SizesTuple& t1, const Tuple& t2)
            : t1(t1), t2(t2) {}
 
        _CCCL_HOST_DEVICE
        value_type operator()(const difference_type& i)
        {
            return join_search<difference_type,value_type,tuple_size-1>()(t1,t2,i);
        }
    };
    typedef TransformIterator iterator;
 
    join_iterator(const SizesTuple& t1, const Tuple& t2) : t1(t1), t2(t2) {}
 
    iterator begin(void) const
    {
        return TransformIterator(::cuda::std::get<tuple_size-1>(t2), join_select_functor(t1,t2));
    }
 
    iterator end(void) const
    {
        return begin() + ::cuda::std::get<tuple_size-2>(t1);
    }
 
    reference operator[](size_type n) const
    {
        return *(begin() + n);
    }
 
protected:
 
    const SizesTuple& t1;
    const Tuple& t2;
};
 
template <typename T1, typename T2, typename T3>
typename join_iterator< ::cuda::std::tuple<T1,T2,T3> >::iterator
make_join_iterator(const size_t s1, const size_t s2, const T1& t1, const T2& t2, const T3& t3)
{
    typedef ::cuda::std::tuple<T1,T2,T3>  Tuple;
    return join_iterator<Tuple>(::cuda::std::make_tuple(s1, s1+s2),
                                ::cuda::std::make_tuple(t1, t2-s1, t3)).begin();
}
 
template <typename T1, typename T2, typename T3, typename T4>
typename join_iterator< ::cuda::std::tuple<T1,T2,T3,T4> >::iterator
make_join_iterator(const size_t s1, const size_t s2, const size_t s3,
                   const T1& t1, const T2& t2, const T3& t3, const T4& t4)
{
    typedef ::cuda::std::tuple<T1,T2,T3,T4>  Tuple;
    return join_iterator<Tuple>(::cuda::std::make_tuple(s1, s1+s2, s1+s2+s3),
                                ::cuda::std::make_tuple(t1, t2-s1, t3-s1-s2, t4)).begin();
}
 
template <typename T1, typename T2, typename T3, typename T4, typename T5>
typename join_iterator< ::cuda::std::tuple<T1,T2,T3,T4,T5> >::iterator
make_join_iterator(const size_t s1, const size_t s2, const size_t s3, const size_t s4,
                   const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
{
    typedef ::cuda::std::tuple<T1,T2,T3,T4,T5>  Tuple;
    return join_iterator<Tuple>(::cuda::std::make_tuple(s1, s1+s2, s1+s2+s3, s1+s2+s3+s4),
                                ::cuda::std::make_tuple(t1, t2-s1, t3-s1-s2, t4-s1-s2-s3, t5)).begin();
}
 
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
typename join_iterator< ::cuda::std::tuple<T1,T2,T3,T4,T5,T6> >::iterator
make_join_iterator(const size_t s1, const size_t s2, const size_t s3, const size_t s4, const size_t s5,
                   const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
{
    typedef ::cuda::std::tuple<T1,T2,T3,T4,T5,T6>  Tuple;
    return join_iterator<Tuple>(::cuda::std::make_tuple(s1, s1+s2, s1+s2+s3, s1+s2+s3+s4, s1+s2+s3+s4+s5),
                                ::cuda::std::make_tuple(t1, t2-s1, t3-s1-s2, t4-s1-s2-s3, t5-s1-s2-s3-s4, t6)).begin();
}
 
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
typename join_iterator< ::cuda::std::tuple<T1,T2,T3,T4,T5,T6,T7> >::iterator
make_join_iterator(const size_t s1, const size_t s2, const size_t s3, const size_t s4, const size_t s5, const size_t s6,
                   const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
{
    typedef ::cuda::std::tuple<T1,T2,T3,T4,T5,T6,T7>  Tuple;
    return join_iterator<Tuple>(::cuda::std::make_tuple(s1, s1+s2, s1+s2+s3, s1+s2+s3+s4, s1+s2+s3+s4+s5, s1+s2+s3+s4+s5+s6),
                                ::cuda::std::make_tuple(t1, t2-s1, t3-s1-s2, t4-s1-s2-s3, t5-s1-s2-s3-s4, t6-s1-s2-s3-s4-s5, t7)).begin();
}
 
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
typename join_iterator< ::cuda::std::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >::iterator
make_join_iterator(const size_t s1, const size_t s2, const size_t s3, const size_t s4, const size_t s5, const size_t s6, const size_t s7,
                   const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8)
{
    typedef ::cuda::std::tuple<T1,T2,T3,T4,T5,T6,T7,T8>  Tuple;
    return join_iterator<Tuple>(::cuda::std::make_tuple(s1, s1+s2, s1+s2+s3, s1+s2+s3+s4, s1+s2+s3+s4+s5, s1+s2+s3+s4+s5+s6, s1+s2+s3+s4+s5+s6+s7),
                                ::cuda::std::make_tuple(t1, t2-s1, t3-s1-s2, t4-s1-s2-s3, t5-s1-s2-s3-s4, t6-s1-s2-s3-s4-s5, t7-s1-s2-s3-s4-s5-s6, t8)).begin();
}
 
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
typename join_iterator< ::cuda::std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::iterator
make_join_iterator(const size_t s1, const size_t s2, const size_t s3, const size_t s4, const size_t s5, const size_t s6, const size_t s7, const size_t s8,
                   const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9)
{
    typedef ::cuda::std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>  Tuple;
    return join_iterator<Tuple>(::cuda::std::make_tuple(s1, s1+s2, s1+s2+s3, s1+s2+s3+s4, s1+s2+s3+s4+s5, s1+s2+s3+s4+s5+s6, s1+s2+s3+s4+s5+s6+s7, s1+s2+s3+s4+s5+s6+s7+s8),
                                ::cuda::std::make_tuple(t1, t2-s1, t3-s1-s2, t4-s1-s2-s3, t5-s1-s2-s3-s4, t6-s1-s2-s3-s4-s5, t7-s1-s2-s3-s4-s5-s6, t8-s1-s2-s3-s4-s5-s6-s7, t9)).begin();
}
 
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
typename join_iterator< ::cuda::std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> >::iterator
make_join_iterator(const size_t s1, const size_t s2, const size_t s3, const size_t s4, const size_t s5, const size_t s6, const size_t s7, const size_t s8, const size_t s9,
                   const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10)
{
    typedef ::cuda::std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>  Tuple;
    return join_iterator<Tuple>(::cuda::std::make_tuple(s1, s1+s2, s1+s2+s3, s1+s2+s3+s4, s1+s2+s3+s4+s5, s1+s2+s3+s4+s5+s6, s1+s2+s3+s4+s5+s6+s7, s1+s2+s3+s4+s5+s6+s7+s8, s1+s2+s3+s4+s5+s6+s7+s8+s9),
                                ::cuda::std::make_tuple(t1, t2-s1, t3-s1-s2, t4-s1-s2-s3, t5-s1-s2-s3-s4, t6-s1-s2-s3-s4-s5, t7-s1-s2-s3-s4-s5-s6, t8-s1-s2-s3-s4-s5-s6-s7, t9-s1-s2-s3-s4-s5-s6-s7-s8, t10)).begin();
}
 
} // end namespace cusp