device_vector.h

Go to the documentation of this file.

/***************************************************************************
*   © 2012,2014 Advanced Micro Devices, Inc. All rights reserved.
*
*   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
#if !defined( BOLT_AMP_DEVICE_VECTOR_H )
#define BOLT_AMP_DEVICE_VECTOR_H

#include <iterator>
#include <type_traits>
#include <numeric>
#include <amp.h>
#include <bolt/amp/control.h>
#include <exception> // For exception class
#include <boost/iterator/iterator_facade.hpp>
#include <boost/iterator/reverse_iterator.hpp>
#include <boost/shared_array.hpp>


namespace bolt
{
namespace amp
{
    struct device_vector_tag
        : public std::random_access_iterator_tag
        {   // identifying tag for random-access iterators
        };



    template <typename T>
    class create_empty_array
    {
    public:
        // Create an AV on the CPU
        static concurrency::array<T> getav() restrict(cpu)
        {
            static T type_default;
            return concurrency::array<T>(1);
        }
    };
template< typename T, template < typename, int RANK = 1 > class CONT= concurrency::array_view >
class device_vector
{
    typedef T* naked_pointer;
    typedef const T* const_naked_pointer;

public:
    //  Useful typedefs specific to this container
    typedef T value_type;
    typedef ptrdiff_t difference_type;
    typedef difference_type distance_type;
    typedef int size_type;

    // These typedefs help define the template template parameter that represents our AMP container
    typedef concurrency::array_view< T > arrayview_type;
    typedef concurrency::array< T > array_type;
    
    typedef CONT< T > container_type;

    typedef naked_pointer pointer;
    typedef const_naked_pointer const_pointer;

    template< typename Container >
    class reference_base
    {
    public:
        reference_base( Container& rhs, size_type index ): m_Container( rhs, false ), m_Index( index )
        {}

        //  Automatic type conversion operator to turn the reference object into a value_type
        operator value_type( ) const
        {
            arrayview_type av( m_Container.m_devMemory );
            value_type &result = av[static_cast< int >( m_Index )];

            return result;
        }

        reference_base< Container >& operator=( const value_type& rhs )
        {
            arrayview_type av( m_Container.m_devMemory );
            av[static_cast< int >( m_Index )] = rhs;

            return *this;
        }

        Container& getContainer( ) const
        {
            return m_Container;
        }

        size_type getIndex() const
        {
            return m_Index;
        }

    private:
        Container m_Container;
        size_type m_Index;
    };

    typedef reference_base< device_vector< value_type, CONT > > reference;

    template< typename Container >
    class const_reference_base
    {
    public:
        const_reference_base( const Container& rhs, size_type index ): m_Container( rhs, false ), m_Index( index )
        {}

        //  Automatic type conversion operator to turn the reference object into a value_type
        operator value_type( ) const
        {
            arrayview_type av( m_Container.m_devMemory );
            value_type &result = av[static_cast< int >( m_Index )];

            return result;
        }

        const_reference_base< const Container >& operator=( const value_type& rhs )
        {
            arrayview_type av( m_Container.m_devMemory );
            av[static_cast< int >( m_Index )] = rhs;

            return *this;
        }

        const Container& getContainer( ) const
        {
            return m_Container;
        }

        size_type getIndex() const
        {
            return m_Index;
        }

    private:
        const Container m_Container;
        size_type m_Index;
    };

    typedef const_reference_base< device_vector< value_type, CONT > > const_reference;

    //  Handy for the reference class to get at the wrapped ::cl objects
    friend class reference;

    template< typename Container >
    class iterator_base: public boost::iterator_facade< iterator_base< Container >,
        value_type, device_vector_tag, typename device_vector::reference >
    {
    public:

        iterator_base( ): m_Container( create_empty_array< value_type >::getav( ) ), m_Index( 0 )
        {}

        //  Basic constructor requires a reference to the container and a positional element
        iterator_base( Container& rhs, size_type index ): m_Container( rhs, false ), m_Index( static_cast<int>(index) )
        {}

        //  This copy constructor allows an iterator to convert into a const_iterator, but not vica versa
        template< typename OtherContainer >
        iterator_base( const iterator_base< OtherContainer >& rhs ):
            m_Container( rhs.m_Container, false ), m_Index( rhs.m_Index )
        {}
        iterator_base( const iterator_base& rhs ):
            m_Container( rhs.m_Container, false ), m_Index( rhs.m_Index )
        {}
        //  This copy constructor allows an iterator to convert into a const_iterator, but not vica versa
        iterator_base< Container >& operator= ( const iterator_base< Container >& rhs )
        {
            m_Container = rhs.m_Container;
            m_Index = rhs.m_Index;
            return *this;
        }

        iterator_base< Container >& operator+= ( const difference_type & n )
        {
            advance( n );
            return *this;
        }

        const iterator_base< Container > operator+ ( const difference_type & n ) const
        {
            iterator_base< Container > result(*this);
            result.advance(n);
            return result;
        }

        Container getContainer( ) const
        {
          return m_Container;
        }

        size_type getIndex() const
        {
            return m_Index;
        }


        difference_type distance_to( const iterator_base< Container >& rhs ) const
        {
            return ( rhs.m_Index - m_Index );
        }
        int m_Index;

        //  Implementation detail of boost.iterator
        friend class boost::iterator_core_access;

        //  Handy for the device_vector erase methods
        friend class device_vector< value_type >;

        //  Used for templatized copy constructor and the templatized equal operator
        template < typename > friend class iterator_base;

        void advance( difference_type n )
        {
            m_Index += static_cast<int>(n);
        }

        void increment( )
        {
            advance( 1 );
        }

        void decrement( )
        {
            advance( -1 );
        }


        template< typename OtherContainer >
        bool equal( const iterator_base< OtherContainer >& rhs ) const
        {
            bool sameIndex = rhs.m_Index == m_Index;
            bool sameContainer = &m_Container.m_devMemory[m_Index] == &rhs.m_Container.m_devMemory[rhs.m_Index];
            return ( sameIndex && sameContainer );
        }

        value_type& operator[](int x) const restrict(cpu,amp)
        {
            return m_Container[m_Index + x];
        }

        value_type& operator*() const restrict(cpu,amp)
        {
            return m_Container[m_Index];
        }

private:
        Container m_Container;

    };


    template< typename Container >
    class reverse_iterator_base: public boost::iterator_facade< reverse_iterator_base< Container >,
        value_type, std::random_access_iterator_tag, typename device_vector::reference >
    {
    public:

        reverse_iterator_base( ): m_Container( create_empty_array< value_type >::getav( ) ), m_Index( 0 )
        {}

        //  Basic constructor requires a reference to the container and a positional element
        reverse_iterator_base( Container& lhs, int index ): m_Container( lhs, false ), m_Index( static_cast<int>(index-1) )
        {}

        //  This copy constructor allows an iterator to convert into a const_iterator, but not vica versa
        template< typename OtherContainer >
        reverse_iterator_base( const reverse_iterator_base< OtherContainer >& lhs ):
            m_Container( lhs.m_Container, false ), m_Index( lhs.m_Index )
        {}

        reverse_iterator_base( const reverse_iterator_base& lhs ):
            m_Container( lhs.m_Container, false ), m_Index( lhs.m_Index )
        {}
        //  This copy constructor allows an iterator to convert into a const_iterator, but not vica versa
        reverse_iterator_base< Container >& operator= ( const reverse_iterator_base< Container >& lhs )
        {
            m_Container = lhs.m_Container;
            m_Index = lhs.m_Index;
            return *this;
        }

        reverse_iterator_base< Container >& operator+= ( const difference_type & n )
        {
            advance( -n );
            return *this;
        }

        const reverse_iterator_base< Container > operator+ ( const difference_type & n ) const
        {
            reverse_iterator_base< Container > result(*this);
            result.advance(-n);
            return result;
        }

        int getIndex() const
        {
            return m_Index;
        }

        Container& getContainer( ) const
        {
          return m_Container;
        }


        difference_type distance_to( const reverse_iterator_base< Container >& lhs ) const
        {
            return static_cast< difference_type >( m_Index - lhs.m_Index );
        }

        int m_Index;

        //  Implementation detail of boost.iterator
        friend class boost::iterator_core_access;

        //  Handy for the device_vector erase methods
        friend class device_vector< value_type >;

        //  Used for templatized copy constructor and the templatized equal operator
        template < typename > friend class reverse_iterator_base;

        void advance( difference_type n )
        {
            m_Index += static_cast<int>(n);
        }

        void increment( )
        {
            advance( -1 );
        }

        void decrement( )
        {
            advance( 1 );
        }

        template< typename OtherContainer >
        bool equal( const reverse_iterator_base< OtherContainer >& lhs ) const
        {
            bool sameIndex = lhs.m_Index == m_Index;
            bool sameContainer = &m_Container.m_devMemory[m_Index] == &lhs.m_Container.m_devMemory[lhs.m_Index];
            return ( sameIndex && sameContainer );
        }

        value_type& operator[](int x) const restrict(cpu,amp)
        {
            return m_Container[m_Index - x];
        }

        value_type& operator*() const restrict(cpu,amp)
        {
            return m_Container[m_Index];
        }

    private:
        Container m_Container;

    };


    typedef iterator_base< device_vector< value_type, CONT > > iterator;

    typedef iterator_base< const device_vector< value_type, CONT > > const_iterator;

    typedef reverse_iterator_base< device_vector< value_type, CONT > > reverse_iterator;

    typedef reverse_iterator_base< const device_vector< value_type, CONT > > const_reverse_iterator;


    device_vector( control& ctl = control::getDefault( ) )
        : m_Size( static_cast<int>(0) ), m_devMemory( create_empty_array<value_type>::getav() )
    { 
        
    }

    device_vector( size_type newSize, const value_type& initValue = value_type( ), bool init = true,
        control& ctl = control::getDefault( ) )
        : m_Size( static_cast<int>(newSize) ), m_devMemory( create_empty_array<value_type>::getav() )
    {
        if( m_Size > 0 )
        {
            concurrency::array<value_type> tmp = array_type( static_cast< int >( m_Size ), ctl.getAccelerator().default_view );
            m_devMemory = tmp.view_as(tmp.get_extent());
            if( init )
            {
                arrayview_type m_devMemoryAV( m_devMemory );
                Concurrency::parallel_for_each( m_devMemoryAV.extent, [=](Concurrency::index<1> idx) restrict(amp)
                {
                    m_devMemoryAV[idx] = initValue;
                }
                );
            }
        }
    }

    template< typename InputIterator >
    device_vector( const InputIterator begin, size_type newSize, bool discard = false, control& ctl = control::getDefault( ), 
                typename std::enable_if< !std::is_integral< InputIterator >::value &&
                                    std::is_same< arrayview_type, container_type >::value>::type* = 0 )
                                    : m_Size( static_cast<int>(newSize) ), m_devMemory( create_empty_array<value_type>::getav() )
    {
        if( m_Size > 0 )
        {
            concurrency::extent<1> ext( static_cast< int >( m_Size ) );
            concurrency::array_view<value_type> tmp = arrayview_type( ext, reinterpret_cast< value_type* >(&begin[ 0 ])  );
            m_devMemory = tmp;
        }
        if(discard)
            m_devMemory.discard_data();
    };


    template< typename InputIterator >
    device_vector( const InputIterator begin, size_type newSize, bool discard = false, control& ctl = control::getDefault( ), 
                typename std::enable_if< !std::is_integral< InputIterator >::value &&
                                    std::is_same< array_type, container_type >::value>::type* = 0 )
                                    : m_Size( static_cast<int>(newSize) ), m_devMemory( create_empty_array<value_type>::getav() )
    {
        if( m_Size > 0 )
        {
            concurrency::extent<1> ext( static_cast< int >( m_Size ) );
            concurrency::array<value_type> tmp = array_type( ext, reinterpret_cast< value_type* >(&begin[ 0 ])  );
            m_devMemory = tmp.view_as(tmp.get_extent());
        }
    };


    template< typename T >
    device_vector( const device_vector<T, CONT> &cont, bool copy = true,control& ctl = control::getDefault( ) ): m_Size( cont.size( ) ),
                                                        m_devMemory( cont.m_devMemory.view_as(cont.m_devMemory.get_extent()))
    {
        if(!copy)
            return;
        if( m_Size > 0 )
        {
            concurrency::array<value_type> tmp = array_type( m_devMemory );
            m_devMemory = tmp.view_as(tmp.get_extent());
        }
    };
    
    device_vector( arrayview_type &cont): m_Size(cont.get_extent().size()), m_devMemory(cont)
    {
    };


    device_vector( array_type &cont): m_Size(cont.get_extent().size()), m_devMemory( cont.view_as(cont.get_extent()))
    {
    };

    template< typename InputIterator >
    device_vector( const InputIterator begin, const InputIterator end, bool discard = false, control& ctl = control::getDefault( ),
        typename std::enable_if< std::is_same< arrayview_type, container_type >::value &&
                                   !std::is_integral< InputIterator >::value>::type* = 0 )
                                    : m_devMemory( create_empty_array<value_type>::getav() )
    {
        m_Size =  static_cast<int>(std::distance( begin, end ));

        if( m_Size > 0 )
        {
            concurrency::extent<1> ext( static_cast< int >( m_Size ) );
            concurrency::array_view<value_type> tmp = arrayview_type( ext, reinterpret_cast< value_type* >(&begin[ 0 ])  );
            m_devMemory = tmp;
        }
        if(discard)
            m_devMemory.discard_data();

    };


    template< typename InputIterator >
    device_vector( const InputIterator begin, const InputIterator end, bool discard = false, control& ctl = control::getDefault( ),
        typename std::enable_if< std::is_same< array_type, container_type >::value &&
                                    !std::is_integral< InputIterator >::value>::type* = 0 )
                                    : m_devMemory( create_empty_array<value_type>::getav() )
    {
        m_Size =  static_cast<int>(std::distance( begin, end ));

        if( m_Size > 0 )
        {
            concurrency::extent<1> ext( static_cast< int >( m_Size ) );
            concurrency::array<value_type> tmp = array_type( ext, reinterpret_cast< value_type* >(&begin[ 0 ])  );
            m_devMemory = tmp.view_as(tmp.get_extent());
        }
    };


        //destructor for device_vector
    ~device_vector()
    {
    }

    //  Member functions

    arrayview_type getBuffer( ) const
    {
        concurrency::extent<1> ext( static_cast< int >( m_Size ) );
        return m_devMemory.view_as( ext );
    }

    arrayview_type getBuffer( const_iterator itr, unsigned int size ) const
    {
        if(size == static_cast<unsigned int>(m_Size))
        {
            concurrency::extent<1> ext( static_cast< int >( m_Size ) );
            return m_devMemory.view_as( ext );
        }
        else
        {
            size_type offset = itr.getIndex();
            concurrency::extent<1> ext( static_cast< int >( size ) );
            return m_devMemory.section( Concurrency::index<1>(offset), ext );
        }
    }


    arrayview_type getBuffer( const_reverse_iterator itr, unsigned int size  ) const
    {
        if(size == static_cast<unsigned int>(m_Size))
        {
            concurrency::extent<1> ext( static_cast< int >( m_Size ) );
            return m_devMemory.view_as( ext );
        }
        else
        {
            size_type offset = itr.getIndex();
            concurrency::extent<1> ext( static_cast< int >( size ) );
            return m_devMemory.section( Concurrency::index<1>(offset), ext );
        }
    }

    void resize( size_type reqSize, const value_type& val = value_type( ) )
    {
        size_type cap = capacity( );

        if( reqSize == cap )
            return;

        //TODO - Add if statement for max size allowed in array class
        array_type l_tmpArray = array_type(reqSize);
        arrayview_type l_tmpBuffer = arrayview_type(l_tmpArray);
        if( m_Size > 0 )
        {
            //1622 Arrays are logically considered to be value types in that when an array is copied to another array,
            //a deep copy is performed. Two arrays never point to the same data.
            //m_Size data elements are copied

            if( reqSize > m_Size )
            {
                m_devMemory.copy_to(l_tmpBuffer.section( 0, m_devMemory.get_extent().size() ) );
                arrayview_type l_tmpBufferSectionAV =
                l_tmpBuffer.section(m_Size, (reqSize - m_Size));
                concurrency::parallel_for_each(l_tmpBufferSectionAV.extent, [=](Concurrency::index<1> idx) restrict(amp)
                {
                    l_tmpBufferSectionAV[idx] = val;
                });
            }
            else
            {
                arrayview_type l_devMemoryAV = m_devMemory.section(0, reqSize);
                l_devMemoryAV.copy_to(l_tmpBuffer);
            }
        }
        else
        {
            arrayview_type l_tmpBufferAV(l_tmpBuffer);
            Concurrency::parallel_for_each(l_tmpBufferAV.extent, [=](Concurrency::index<1> idx) restrict(amp)
            {
                l_tmpBufferAV[idx] = val;
            });
        }
        //  Remember the new size
        m_Size = reqSize;
        m_devMemory = l_tmpBuffer;
    }

    size_type size( void ) const
    {
        return m_Size;
    }

  

    void reserve( size_type reqSize )
    {
       if( reqSize <= capacity( ) )
           return;

        concurrency::array<value_type> tmp =  array_type( static_cast< int >( reqSize ) );
        arrayview_type l_tmpBuffer = arrayview_type( tmp );
        if( m_Size > 0 )
        {
            if( capacity() != 0 )
            {
                arrayview_type l_tmpBuffer = arrayview_type( tmp );
                m_devMemory.copy_to(l_tmpBuffer.section(0, m_devMemory.get_extent().size()));
            }
        }
        m_devMemory = l_tmpBuffer;

    }

    size_type capacity( void ) const
    {
        Concurrency::extent<1> ext = m_devMemory.get_extent();
        return ext.size();
    }

    void shrink_to_fit( )
    {   
        if( m_Size == capacity( ) )
             return;

        array_type l_tmpArray = array_type( static_cast< int >( size( ) ) );
        arrayview_type l_tmpBuffer = arrayview_type(l_tmpArray);
        arrayview_type l_devMemoryAV = m_devMemory.section( 0,(int)size() );
        arrayview_type l_tmpBufferAV = l_tmpBuffer.section( 0,(int)size() );

        l_devMemoryAV.copy_to( l_tmpBufferAV );
        m_devMemory = l_tmpBuffer;
    }

    value_type& operator[]( size_type n ) restrict(cpu,amp)
    {
        return m_devMemory[n];
    }

    value_type& operator[]( size_type ix ) const restrict(cpu,amp)
    {
        return m_devMemory[ix];
    }

    iterator begin( void )
    {
        return iterator( *this, 0 );
    }

    const_iterator begin( void ) const
    {
        return const_iterator( *this, 0 );
    }

    const_iterator cbegin( void ) const
    {
        return const_iterator( *this, 0 );
    }

    reverse_iterator rbegin( void )
    {
        return reverse_iterator(*this,m_Size);
    }

    const_reverse_iterator rbegin( void ) const
    {
        return const_reverse_iterator(*this,m_Size);
    }

    const_reverse_iterator crbegin( void ) const
    {
        return const_reverse_iterator(*this,m_Size);
    }

    iterator end( void )
    {
        return iterator( *this, m_Size );
    }

    const_iterator end( void ) const
    {
        return const_iterator( *this, m_Size );
    }

    const_iterator cend( void ) const
    {
        return const_iterator( *this, m_Size );
    }

    reverse_iterator rend( void )
    {
        return reverse_iterator( *this, 0  );
    }

    const_reverse_iterator rend( void ) const
    {
        return const_reverse_iterator( *this, 0  );
    }

    const_reverse_iterator crend( void ) const
    {
        return const_reverse_iterator( *this, 0  );
    }

    value_type& front( void )
    {
        return (*begin());
    }

    const value_type& front( void ) const
    {
        return (*begin());
    }

    value_type& back( void )
    {
        return (*(end() - 1));
    }

    const value_type& back( void ) const
    {
        return ( *(end() - 1) );
    }

    //Yes you need the shared_array object.
    //Ask kent for a better solution.
    pointer data( void )
    {
        // below av.data(). It should anyway be freed in the UnMapBufferFunctor Functor
        if(0 == size())
        {

             return NULL;
        }
        synchronize( *this );
        arrayview_type av( m_devMemory );
        return av.data( );
    }

    const_pointer data( void ) const
    {
        if(0 == size())
        {
             return NULL;
        }
        synchronize( *this );
        arrayview_type av( m_devMemory );
        return av.data( );
    }

    void clear( void )
    {   
        m_devMemory = create_empty_array<value_type>::getav();
        m_Size = 0;
    }

    bool empty( void ) const
    {
        return m_Size ? false: true;
    }

    void push_back( const value_type& value )
    {
        if( m_Size > capacity( ) )
            throw std::exception( "device_vector size can not be greater than capacity( )" );

        //  Need to grow the vector to push new value.
        //  Vectors double their capacity on push_back if the array is not big enough.
        if( m_Size == capacity( ) )
        {
            m_Size ? reserve( m_Size * 2 ) : reserve( 1 );
        }

        arrayview_type av( m_devMemory );
        //insert(end(),value);
        av[static_cast<int>( m_Size )] = value;
        ++m_Size;
    }

    void pop_back( void )
    {
        if( m_Size > 0 )
        {
            --m_Size;
        }
    }

    void swap( device_vector& vec )
    {
        if( this == &vec )
            return;

        arrayview_type swapBuffer( m_devMemory );
        m_devMemory = vec.m_devMemory;
        vec.m_devMemory = swapBuffer;

        size_type sizeTmp = m_Size;
        m_Size = vec.m_Size;
        vec.m_Size = static_cast<int>(sizeTmp);
    }

    iterator erase( const_iterator index )
    {
        iterator l_End = end( );
        if( index.m_Index >= l_End.m_Index )
            throw std::exception( "Iterator is pointing past the end of this container" );

        size_type sizeRegion = l_End.m_Index - index.m_Index;

        arrayview_type av( m_devMemory );
        naked_pointer ptrBuff = av.data();
        naked_pointer ptrBuffTemp = ptrBuff + index.m_Index;
        ::memmove( ptrBuffTemp, ptrBuffTemp + 1, (sizeRegion - 1)*sizeof( value_type ) );

        --m_Size;

        size_type newIndex = (m_Size < index.m_Index) ? m_Size : index.m_Index;
        return iterator( *this, newIndex );
    }

    iterator erase( const_iterator first, const_iterator last )
    {
        if( last.m_Index > m_Size )
            throw std::exception( "Iterator is pointing past the end of this container" );

        if( (first == begin( )) && (last == end( )) )
        {
            clear( );
            return iterator( *this, m_Size );
        }

        iterator l_End = end( );
        size_type sizeMap = l_End.m_Index - first.m_Index;

        arrayview_type av( m_devMemory );
        naked_pointer ptrBuff = av.data();
        ptrBuff = ptrBuff + first.m_Index;
        size_type sizeErase = last.m_Index - first.m_Index;
        ::memmove( ptrBuff, ptrBuff + sizeErase, (sizeMap - sizeErase)*sizeof( value_type ) );

        m_Size -= static_cast<int>(sizeErase);

        size_type newIndex = (m_Size < last.m_Index) ? m_Size : last.m_Index;
        return iterator( *this, newIndex );
    }

    iterator insert( const_iterator index, const value_type& value )
    {
        if( index.m_Index > m_Size )
            throw std::exception( "Iterator is pointing past the end of this container" );

        if( index.m_Index == m_Size )
        {
            push_back( value );
            return iterator( *this, index.m_Index );
        }

        //  Need to grow the vector to insert a new value.
        //  TODO:  What is an appropriate growth strategy for GPU memory allocation?  Exponential growth does not seem
        //  right at first blush.
        if( m_Size == capacity( ) )
        {
            m_Size ? reserve( m_Size * 2 ) : reserve( 1 );
        }

        size_type sizeMap = (m_Size - index.m_Index) + 1;

        arrayview_type av( m_devMemory );
        naked_pointer ptrBuff = av.data();
        ptrBuff = ptrBuff + index.m_Index;

        //  Shuffle the old values 1 element down
        ::memmove( ptrBuff + 1, ptrBuff, (sizeMap - 1)*sizeof( value_type ) );

        //  Write the new value in its place
        *ptrBuff = value;

        ++m_Size;

        return iterator( *this, index.m_Index );
    }

    void insert( const_iterator index, size_type n, const value_type& value )
    {
        if( index.m_Index > m_Size )
            throw std::exception(  "Iterator is pointing past the end of this container" );

        //  Need to grow the vector to insert n new values
        if( ( m_Size + n ) > capacity( ) )
        {
            reserve( m_Size + n );
        }

        size_type sizeMap = (m_Size - index.m_Index) + n;

        arrayview_type av( m_devMemory );
        naked_pointer ptrBuff = av.data( );
        ptrBuff = ptrBuff + index.m_Index;

        //  Shuffle the old values n element down.
        ::memmove( ptrBuff + n, ptrBuff, (sizeMap - n)*sizeof( value_type ) );

        //  Copy the new value n times in the buffer.
        for( size_type i = 0; i < n; ++i )
        {
            ptrBuff[ i ] = value;
        }

        m_Size += n;
    }

    template< typename InputIterator >
    void insert( const_iterator index, InputIterator begin, InputIterator end )
    {
        if( index.m_Index > m_Size )
            throw std::exception(  "Iterator is pointing past the end of this container" );

        //  Need to grow the vector to insert the range of new values
        size_type n = static_cast<int>(std::distance( begin, end ));
        if( ( m_Size + n ) > capacity( ) )
        {
            reserve( m_Size + n );
        }
        size_type sizeMap = (m_Size - index.m_Index) + n;

        arrayview_type av( m_devMemory );
        naked_pointer ptrBuff = av.data() + index.m_Index;

        //  Shuffle the old values n element down.
        ::memmove( ptrBuff + n, ptrBuff, (sizeMap - n)*sizeof( value_type ) );

#if( _WIN32 )
        std::copy( begin, end, stdext::checked_array_iterator< naked_pointer >( ptrBuff, n ) );
#else
        std::copy( begin, end, ptrBuff );
#endif

        m_Size += static_cast<int>(n);
    }

    void assign( size_type newSize, const value_type& value )
    {
        if( newSize > m_Size )
        {
            reserve( newSize );
        }
        m_Size = newSize;

        arrayview_type m_devMemoryAV( m_devMemory );
        Concurrency::parallel_for_each( m_devMemoryAV.extent, [=](Concurrency::index<1> idx) restrict(amp)
        {
            m_devMemoryAV[idx] = value;
        }
        );
    }
#if 1

    template<typename InputIterator>
    typename std::enable_if< std::_Is_iterator<InputIterator>::value, void>::type
    assign( InputIterator begin, InputIterator end )
    {
        size_type l_Count = static_cast<int>(std::distance( begin, end ));

        if( l_Count > m_Size )
        {
            reserve( l_Count );
        }
        m_Size = static_cast<int>(l_Count);

        arrayview_type m_devMemoryAV( m_devMemory );
        naked_pointer ptrBuff = m_devMemoryAV.data();
#if( _WIN32 )
        std::copy( begin, end, stdext::checked_array_iterator< naked_pointer >( ptrBuff, m_Size ) );
#else
        std::copy( begin, end, ptrBuff );
#endif
    }
#endif
private:

    //  These private routines make sure that the data that resides in the concurrency::array* object are
    //  reflected back in the host memory.  However, the complication is that the concurrency::array object
    //  does not expose a synchronize method, whereas the concurrency::array_view does.  These routines
    //  differentiate between the two different containers
    void synchronize( device_vector< T, concurrency::array >& rhs )
    {
    };
    void synchronize( device_vector< T, concurrency::array_view >& rhs )
    {
        rhs.m_devMemory.synchronize( );
    };

    int m_Size;
    concurrency::array_view<T, 1> m_devMemory;
};

}
}

#endif