array.hpp

Go to the documentation of this file.

/*
Copyright (c) 2014-2016, Scott Zuyderduyn
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
*/

//----------------------------------------------------------------------------
// array.hpp
//
// An STL-like structure that resides in video memory.
//
// Author: Scott D. Zuyderduyn, Ph.D. (scott.zuyderduyn@utoronto.ca)
//----------------------------------------------------------------------------

#pragma once
#ifndef ECUDA_ARRAY_HPP
#define ECUDA_ARRAY_HPP

#include <algorithm>
#include <limits>
#include <stdexcept>
#ifdef ECUDA_CPP11_AVAILABLE
#include <initializer_list>
#include <utility>
#include <vector>
#endif

#include "global.hpp"
#include "algorithm.hpp"   // for copy
#include "allocators.hpp"  // for device_allocator
#include "memory.hpp"      // for shared_ptr

#include "model/device_fixed_sequence.hpp"

namespace ecuda {

namespace impl {

template<typename T,std::size_t N> class array_kernel_argument; // forward declaration

} // namespace impl

template< typename T, std::size_t N, class P=shared_ptr<T> >
class array : private model::device_fixed_sequence< T, N, P > {

private:
    typedef model::device_fixed_sequence< T, N, P > base_type;

public:
    typedef typename base_type::value_type      value_type;      
    typedef typename base_type::size_type       size_type;       
    typedef typename base_type::difference_type difference_type; 
    typedef typename base_type::reference       reference;       
    typedef typename base_type::const_reference const_reference; 
    typedef typename base_type::pointer         pointer;         
    typedef typename make_const<pointer>::type  const_pointer;   

    typedef typename base_type::iterator               iterator;               
    typedef typename base_type::const_iterator         const_iterator;         
    typedef typename base_type::reverse_iterator       reverse_iterator;       
    typedef typename base_type::const_reverse_iterator const_reverse_iterator; 

    typedef       impl::array_kernel_argument<T,N> kernel_argument;       
    typedef const impl::array_kernel_argument<T,N> const_kernel_argument; 

    template<typename U,std::size_t M,class Q> friend class array;

protected:
    template<class Q> __HOST__ __DEVICE__ array( const array<T,N,Q>& src, ecuda::true_type ) : base_type( unmanaged_cast(src.get_pointer()) ) {}

    template<class Q>
    __HOST__ __DEVICE__ array& shallow_assign( const array<T,N,Q>& other )
    {
        base_type::get_pointer() = unmanaged_cast(other.get_pointer());
        return *this;
    }

public:
    __HOST__ array() : base_type( shared_ptr<T>( device_allocator<T>().allocate(N) ) )
    {
        fill( value_type() );
    }

    __HOST__ array( const array& src ) : base_type( shared_ptr<T>( device_allocator<T>().allocate(src.size()) ) )
    {
        ecuda::copy( src.begin(), src.end(), begin() );
    }

    #ifdef ECUDA_CPP11_AVAILABLE
    template<typename U>
    __HOST__ array( std::initializer_list<U> il ) : base_type( shared_ptr<T>( device_allocator<T>().allocate(N) ) )
    {
        #ifdef ECUDA_CONSTEXPR_KEYWORD_ENABLED
        static_assert( il.size() <= N, EXCEPTION_MSG("size of initializer list must not be greater than the array size") );
        #else
        if( il.size() > N ) throw std::invalid_argument( EXCEPTION_MSG("size of initializer list must not be greater than the array size") );
        #endif
        ecuda::copy( il.begin(), il.end(), begin() );
    }
    #endif

    __HOST__ array& operator=( const array& other )
    {
        ecuda::copy( other.begin(), other.end(), begin() );
        return *this;
    }

    #ifdef ECUDA_CPP11_AVAILABLE
    __HOST__ array( array&& src ) : base_type(std::move(src)) {}

    __HOST__ array& operator=( array&& src )
    {
        base_type::operator=(std::move(src));
        return *this;
    }
    #endif

    __DEVICE__ inline reference at( size_type index )
    {
        if( !(index < size()) ) {
            #ifndef __CUDACC__
            throw std::out_of_range( EXCEPTION_MSG("ecuda::array::at() index parameter is out of range") );
            #else
            // this strategy is taken from:
            // http://stackoverflow.com/questions/12521721/crashing-a-kernel-gracefully
            ecuda::threadfence();
            //__threadfence();
            asm("trap;");
            #endif
        }
        return base_type::operator[](index);
    }

    __DEVICE__ inline const_reference at( size_type index ) const
    {
        if( !(index < size()) ) {
            #ifndef __CUDACC__
            throw std::out_of_range( EXCEPTION_MSG("ecuda::array::at() index parameter is out of range") );
            #else
            // this strategy is taken from:
            // http://stackoverflow.com/questions/12521721/crashing-a-kernel-gracefully
            ecuda::threadfence();
            //__threadfence();
            asm("trap;");
            #endif
        }
        return base_type::operator[](index);
    }

    __DEVICE__ inline reference operator[]( size_type index ) { return base_type::operator[](index); }

    __DEVICE__ inline const_reference operator[]( size_type index ) const { return base_type::operator[](index); }

    __DEVICE__ inline reference operator()( const size_type index ) { return base_type::operator[](index); }

    __DEVICE__ inline const_reference operator()( const size_type index ) const { return base_type::operator[](index); }

    __DEVICE__ inline reference front() { return base_type::operator[](0); }

    __DEVICE__ inline reference back() { return base_type::operator[](size()-1); }
    __DEVICE__ inline const_reference front() const { return base_type::operator[](0); }

    __DEVICE__ inline const_reference back() const { return base_type::operator[](size()-1); }

    __HOST__ __DEVICE__ inline pointer data() __NOEXCEPT__ { return base_type::get_pointer(); }

    __HOST__ __DEVICE__ inline const_pointer data() const __NOEXCEPT__ { return base_type::get_pointer(); }

    __HOST__ __DEVICE__ inline iterator begin() __NOEXCEPT__ { return base_type::begin(); }

    __HOST__ __DEVICE__ inline iterator end() __NOEXCEPT__ { return base_type::end(); }

    __HOST__ __DEVICE__ inline const_iterator begin() const __NOEXCEPT__ { return base_type::begin(); }

    __HOST__ __DEVICE__ inline const_iterator end() const __NOEXCEPT__ { return base_type::end(); }

    __HOST__ __DEVICE__ inline reverse_iterator rbegin() __NOEXCEPT__ { return base_type::rbegin(); }

    __HOST__ __DEVICE__ inline reverse_iterator rend() __NOEXCEPT__ { return base_type::rend(); }

    __HOST__ __DEVICE__ inline const_reverse_iterator rbegin() const __NOEXCEPT__ { return base_type::rbegin(); }

    __HOST__ __DEVICE__ inline const_reverse_iterator rend() const __NOEXCEPT__ { return base_type::rend(); }

    #ifdef ECUDA_CPP11_AVAILABLE

    __HOST__ __DEVICE__ inline const_iterator         cbegin()  const __NOEXCEPT__ { return base_type::cbegin();  }

    __HOST__ __DEVICE__ inline const_iterator         cend()    const __NOEXCEPT__ { return base_type::cend();    }

    __HOST__ __DEVICE__ inline const_reverse_iterator crbegin() const __NOEXCEPT__ { return base_type::crbegin(); }

    __HOST__ __DEVICE__ inline const_reverse_iterator crend() const   __NOEXCEPT__ { return base_type::crend();   }

    #endif

    __HOST__ __DEVICE__ __CONSTEXPR__ inline bool empty() const __NOEXCEPT__ { return size() == 0; }

    __HOST__ __DEVICE__ __CONSTEXPR__ inline size_type size() const __NOEXCEPT__ { return base_type::size(); }

    __HOST__ __CONSTEXPR__ inline size_type max_size() const __NOEXCEPT__ { return std::numeric_limits<size_type>::max(); }


    __HOST__ __DEVICE__ inline void fill( const value_type& value ) { ecuda::fill( begin(), end(), value ); }

    __HOST__ __DEVICE__ inline void swap( array& other )
    #if defined(ECUDA_CPP11_AVAILABLE) && defined(ECUDA_NOEXCEPT_KEYWORD_ENABLED)
    noexcept(noexcept(swap(std::declval<T&>(),std::declval<T&>())))
    #endif
    {
        base_type::swap( other );
    }

    __HOST__ __DEVICE__ inline bool operator==( const array& other ) const { return ecuda::equal( begin(), end(), other.begin() ); }

    __HOST__ __DEVICE__ inline bool operator!=( const array& other ) const { return !operator==(other); }

    __HOST__ __DEVICE__ inline bool operator<( const array& other ) const { return ecuda::lexicographical_compare( begin(), end(), other.begin(), other.end() ); }

    __HOST__ __DEVICE__ inline bool operator>( const array& other ) const { return ecuda::lexicographical_compare( other.begin(), other.end(), begin(), end() ); }

    __HOST__ __DEVICE__ inline bool operator<=( const array& other ) const { return !operator>(other); }

    __HOST__ __DEVICE__ inline bool operator>=( const array& other ) const { return !operator<(other); }

};

namespace impl {

template<typename T,std::size_t N>
class array_kernel_argument : public array<T,N,typename ecuda::add_pointer<T>::type>
{

private:
    typedef array<T,N,typename ecuda::add_pointer<T>::type> base_type;

public:
    template<class P>
    __HOST__ array_kernel_argument( const array<T,N,P>& src ) : base_type( src, ecuda::true_type() ) {}

    __HOST__ __DEVICE__ array_kernel_argument( const array_kernel_argument& src ) : base_type( src, ecuda::true_type() ) {}

    template<class P>
    __HOST__ array_kernel_argument& operator=( const array<T,N,P>& src )
    {
        base_type::shallow_assign(src);
        return *this;
    }

    #ifdef ECUDA_CPP11_AVAILABLE
    array_kernel_argument( array_kernel_argument&& src ) : base_type(std::move(src)) {}

    array_kernel_argument& operator=( array_kernel_argument&& src )
    {
        base_type::operator=(std::move(src));
        return *this;
    }
    #endif

};

} // namespace impl

} // namespace ecuda

#endif