Kokkos_DynRankView.hpp
fda492ea48eclammps-icms

Kokkos_DynRankView.hpp
View Options

			/*
			//@HEADER
			// ************************************************************************
			//
			// Kokkos v. 2.0
			// Copyright (2014) Sandia Corporation
			//
			// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
			// the U.S. Government retains certain rights in this software.
			//
			// 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.
			//
			// 3. Neither the name of the Corporation nor the names of the
			// contributors may be used to endorse or promote products derived from
			// this software without specific prior written permission.
			//
			// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
			// 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.
			//
			// Questions? Contact H. Carter Edwards (hcedwar@sandia.gov)
			//
			// ************************************************************************
			//@HEADER
			*/

			/// \file Kokkos_DynRankView.hpp
			/// \brief Declaration and definition of Kokkos::Experimental::DynRankView.
			///
			/// This header file declares and defines Kokkos::Experimental::DynRankView and its
			/// related nonmember functions.
			/*
			* Changes from View
			* 1. The rank of the DynRankView is returned by the method rank()
			* 2. Max rank of a DynRankView is 7
			* 3. subview name is subdynrankview
			* 4. Every subdynrankview is returned with LayoutStride
			*/

			#ifndef KOKKOS_DYNRANKVIEW_HPP
			#define KOKKOS_DYNRANKVIEW_HPP

			#include <Kokkos_Core.hpp>
			#include <impl/Kokkos_Error.hpp>
			#include <type_traits>

			namespace Kokkos {
			namespace Experimental {

			namespace Impl {

			template <typename Specialize>
			struct DynRankDimTraits {

			// Compute the rank of the view from the nonzero dimension arguments.
			KOKKOS_INLINE_FUNCTION
			static size_t computeRank( const size_t N0
			, const size_t N1
			, const size_t N2
			, const size_t N3
			, const size_t N4
			, const size_t N5
			, const size_t N6
			, const size_t N7 )
			{
			return
			( (N6 == 0 && N5 == 0 && N4 == 0 && N3 == 0 && N2 == 0 && N1 == 0 && N0 == 0) ? 0
			: ( (N6 == 0 && N5 == 0 && N4 == 0 && N3 == 0 && N2 == 0 && N1 == 0) ? 1
			: ( (N6 == 0 && N5 == 0 && N4 == 0 && N3 == 0 && N2 == 0) ? 2
			: ( (N6 == 0 && N5 == 0 && N4 == 0 && N3 == 0) ? 3
			: ( (N6 == 0 && N5 == 0 && N4 == 0) ? 4
			: ( (N6 == 0 && N5 == 0) ? 5
			: ( (N6 == 0) ? 6
			: 7 ) ) ) ) ) ) );
			}

			// Compute the rank of the view from the nonzero layout arguments.
			template <typename Layout>
			KOKKOS_INLINE_FUNCTION
			static size_t computeRank( const Layout& layout )
			{
			return computeRank( layout.dimension[0]
			, layout.dimension[1]
			, layout.dimension[2]
			, layout.dimension[3]
			, layout.dimension[4]
			, layout.dimension[5]
			, layout.dimension[6]
			, layout.dimension[7] );
			}

			// Create the layout for the rank-7 view.
			// Non-strided Layout
			template <typename Layout>
			KOKKOS_INLINE_FUNCTION
			static typename std::enable_if< (std::is_same<Layout , Kokkos::LayoutRight>::value \|\| std::is_same<Layout , Kokkos::LayoutLeft>::value) , Layout >::type createLayout( const Layout& layout )
			{
			return Layout( layout.dimension[0] != 0 ? layout.dimension[0] : 1
			, layout.dimension[1] != 0 ? layout.dimension[1] : 1
			, layout.dimension[2] != 0 ? layout.dimension[2] : 1
			, layout.dimension[3] != 0 ? layout.dimension[3] : 1
			, layout.dimension[4] != 0 ? layout.dimension[4] : 1
			, layout.dimension[5] != 0 ? layout.dimension[5] : 1
			, layout.dimension[6] != 0 ? layout.dimension[6] : 1
			, layout.dimension[7] != 0 ? layout.dimension[7] : 1
			);
			}

			// LayoutStride
			template <typename Layout>
			KOKKOS_INLINE_FUNCTION
			static typename std::enable_if< (std::is_same<Layout , Kokkos::LayoutStride>::value) , Layout>::type createLayout( const Layout& layout )
			{
			return Layout( layout.dimension[0] != 0 ? layout.dimension[0] : 1
			, layout.stride[0]
			, layout.dimension[1] != 0 ? layout.dimension[1] : 1
			, layout.stride[1]
			, layout.dimension[2] != 0 ? layout.dimension[2] : 1
			, layout.stride[2]
			, layout.dimension[3] != 0 ? layout.dimension[3] : 1
			, layout.stride[3]
			, layout.dimension[4] != 0 ? layout.dimension[4] : 1
			, layout.stride[4]
			, layout.dimension[5] != 0 ? layout.dimension[5] : 1
			, layout.stride[5]
			, layout.dimension[6] != 0 ? layout.dimension[6] : 1
			, layout.stride[6]
			, layout.dimension[7] != 0 ? layout.dimension[7] : 1
			, layout.stride[7]
			);
			}

			// Create a view from the given dimension arguments.
			// This is only necessary because the shmem constructor doesn't take a layout.
			template <typename ViewType, typename ViewArg>
			static ViewType createView( const ViewArg& arg
			, const size_t N0
			, const size_t N1
			, const size_t N2
			, const size_t N3
			, const size_t N4
			, const size_t N5
			, const size_t N6
			, const size_t N7 )
			{
			return ViewType( arg
			, N0 != 0 ? N0 : 1
			, N1 != 0 ? N1 : 1
			, N2 != 0 ? N2 : 1
			, N3 != 0 ? N3 : 1
			, N4 != 0 ? N4 : 1
			, N5 != 0 ? N5 : 1
			, N6 != 0 ? N6 : 1
			, N7 != 0 ? N7 : 1 );
			}
			};

			} //end Impl

			/* \class DynRankView
			* \brief Container that creates a Kokkos view with rank determined at runtime.
			* Essentially this is a rank 7 view that wraps the access operators
			* to yield the functionality of a view
			*
			* Changes from View
			* 1. The rank of the DynRankView is returned by the method rank()
			* 2. Max rank of a DynRankView is 7
			* 3. subview name is subdynrankview
			* 4. Every subdynrankview is returned with LayoutStride
			*
			*/

			template< typename DataType , class ... Properties >
			class DynRankView : private View< DataType*******, Properties... >
			{
			static_assert( !std::is_array<DataType>::value && !std::is_pointer<DataType>::value , "Cannot template DynRankView with array or pointer datatype - must be pod" );

			public:
			using view_type = View< DataType******* , Properties...>;
			using reference_type = typename view_type::reference_type;

			private:
			template < class , class ... > friend class DynRankView ;
			template< class , class ... > friend class Impl::ViewMapping ;
			unsigned m_rank;

			public:
			KOKKOS_INLINE_FUNCTION
			view_type & DownCast() const { return static_cast< view_type & > (*this); }
			KOKKOS_INLINE_FUNCTION
			const view_type & ConstDownCast() const { return static_cast< const view_type & > (*this); }

			typedef ViewTraits< DataType , Properties ... > traits ;

			// Data type traits:
			typedef typename traits::data_type data_type;
			typedef typename traits::const_data_type const_data_type;
			typedef typename traits::non_const_data_type non_const_data_type;

			// Compatible array of trivial type traits:
			typedef typename traits::scalar_array_type scalar_array_type ;
			typedef typename traits::const_scalar_array_type const_scalar_array_type ;
			typedef typename traits::non_const_scalar_array_type non_const_scalar_array_type ;

			// Value type traits:
			typedef typename traits::value_type value_type ;
			typedef typename traits::const_value_type const_value_type ;
			typedef typename traits::non_const_value_type non_const_value_type ;

			// Mapping traits:
			typedef typename traits::array_layout array_layout ;
			typedef typename traits::specialize specialize ;

			// Execution space, memory space, memory access traits, and host mirror space:
			typedef typename traits::execution_space execution_space ;
			typedef typename traits::memory_space memory_space ;
			typedef typename traits::device_type device_type ;
			typedef typename traits::memory_traits memory_traits ;
			typedef typename traits::host_mirror_space host_mirror_space ;

			typedef typename traits::size_type size_type ;

			using view_type::is_hostspace ;
			using view_type::is_managed ;
			using view_type::is_random_access ;

			/** \brief Compatible view of array of scalar types */
			typedef DynRankView< typename traits::scalar_array_type ,
			typename traits::array_layout ,
			typename traits::device_type ,
			typename traits::memory_traits >
			array_type ;

			/** \brief Compatible view of const data type */
			typedef DynRankView< typename traits::const_data_type ,
			typename traits::array_layout ,
			typename traits::device_type ,
			typename traits::memory_traits >
			const_type ;

			/** \brief Compatible view of non-const data type */
			typedef DynRankView< typename traits::non_const_data_type ,
			typename traits::array_layout ,
			typename traits::device_type ,
			typename traits::memory_traits >
			non_const_type ;

			/** \brief Compatible HostMirror view */
			typedef DynRankView< typename traits::non_const_data_type ,
			typename traits::array_layout ,
			typename traits::host_mirror_space >
			HostMirror ;

			//----------------------------------------
			// Domain rank and extents

			KOKKOS_INLINE_FUNCTION
			DynRankView() : view_type() , m_rank(0) {}

			KOKKOS_INLINE_FUNCTION
			constexpr unsigned rank() const { return m_rank; }

			using view_type::extent;
			using view_type::extent_int;
			using view_type::layout;
			using view_type::dimension;
			using view_type::size;
			using view_type::stride;

			using pointer_type = typename view_type::pointer_type;
			using view_type::reference_type_is_lvalue_reference;
			using view_type::span;
			using view_type::capacity;
			using view_type::span_is_contiguous;
			using view_type::data;
			using view_type::implementation_map;

			using view_type::is_contiguous;
			using view_type::ptr_on_device;

			//Deprecated, remove soon (add for test)
			using view_type::dimension_0;
			using view_type::dimension_1;
			using view_type::dimension_2;
			using view_type::dimension_3;
			using view_type::dimension_4;
			using view_type::dimension_5;
			using view_type::dimension_6;
			using view_type::dimension_7;
			using view_type::stride_0;
			using view_type::stride_1;
			using view_type::stride_2;
			using view_type::stride_3;
			using view_type::stride_4;
			using view_type::stride_5;
			using view_type::stride_6;
			using view_type::stride_7;

			//operators ()
			// Rank 0
			KOKKOS_INLINE_FUNCTION
			reference_type operator()() const
			{ return view_type::operator()(0,0,0,0,0,0,0); }

			// Rank 1
			// This assumes a contiguous underlying memory (i.e. no padding, no striding...)
			template< typename iType >
			KOKKOS_INLINE_FUNCTION
			typename std::enable_if< std::is_same<value_type, scalar_array_type>::value && std::is_integral<iType>::value, reference_type>::type
			operator[](const iType & i0) const
			{
			return data()[i0];
			}

			// This assumes a contiguous underlying memory (i.e. no padding, no striding...
			// AND a Trilinos/Sacado scalar type )
			template< typename iType >
			KOKKOS_INLINE_FUNCTION
			typename std::enable_if< !std::is_same<value_type, scalar_array_type>::value && std::is_integral<iType>::value, reference_type>::type
			operator[](const iType & i0) const
			{
			auto map = implementation_map();

			const size_t dim_scalar = map.dimension_scalar();
			const size_t bytes = this->span() / dim_scalar;

			typedef Kokkos::View<DataType*, array_layout, device_type, Kokkos::MemoryTraits<Kokkos::Unmanaged \| memory_traits::RandomAccess \| memory_traits::Atomic> > tmp_view_type;
			tmp_view_type rankone_view(this->data(), bytes, dim_scalar);
			return rankone_view(i0);
			}

			template< typename iType >
			KOKKOS_INLINE_FUNCTION
			reference_type operator()(const iType & i0 ) const
			{ return view_type::operator()(i0,0,0,0,0,0,0); }

			// Rank 2
			template< typename iType0 , typename iType1 >
			KOKKOS_INLINE_FUNCTION
			reference_type operator()(const iType0 & i0 , const iType1 & i1 ) const
			{ return view_type::operator()(i0,i1,0,0,0,0,0); }

			// Rank 3
			template< typename iType0 , typename iType1 , typename iType2 >
			KOKKOS_INLINE_FUNCTION
			reference_type operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 ) const
			{ return view_type::operator()(i0,i1,i2,0,0,0,0); }

			// Rank 4
			template< typename iType0 , typename iType1 , typename iType2 , typename iType3 >
			KOKKOS_INLINE_FUNCTION
			reference_type operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 ) const
			{ return view_type::operator()(i0,i1,i2,i3,0,0,0); }

			// Rank 5
			template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 >
			KOKKOS_INLINE_FUNCTION
			reference_type operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 ) const
			{ return view_type::operator()(i0,i1,i2,i3,i4,0,0); }

			// Rank 6
			template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 , typename iType5 >
			KOKKOS_INLINE_FUNCTION
			reference_type operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 , const iType5 & i5 ) const
			{ return view_type::operator()(i0,i1,i2,i3,i4,i5,0); }

			// Rank 7
			template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 , typename iType5 , typename iType6 >
			KOKKOS_INLINE_FUNCTION
			reference_type operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 , const iType5 & i5 , const iType6 & i6 ) const
			{ return view_type::operator()(i0,i1,i2,i3,i4,i5,i6); }

			//----------------------------------------
			// Standard constructor, destructor, and assignment operators...

			KOKKOS_INLINE_FUNCTION
			~DynRankView() {}

			KOKKOS_INLINE_FUNCTION
			DynRankView( const DynRankView & ) = default ;

			KOKKOS_INLINE_FUNCTION
			DynRankView( DynRankView && ) = default ;

			KOKKOS_INLINE_FUNCTION
			DynRankView & operator = ( const DynRankView & ) = default ;

			KOKKOS_INLINE_FUNCTION
			DynRankView & operator = ( DynRankView && ) = default ;

			//----------------------------------------
			// Compatible view copy constructor and assignment
			// may assign unmanaged from managed.

			template< class RT , class ... RP >
			KOKKOS_INLINE_FUNCTION
			DynRankView( const DynRankView<RT,RP...> & rhs )
			: view_type( rhs.ConstDownCast() )
			, m_rank(rhs.m_rank)
			{}

			template< class RT , class ... RP >
			KOKKOS_INLINE_FUNCTION
			DynRankView & operator = (const DynRankView<RT,RP...> & rhs )
			{
			view_type::operator = ( rhs.ConstDownCast() );
			m_rank = rhs.rank();
			return *this;
			}

			//----------------------------------------
			// Allocation tracking properties

			using view_type::use_count;
			using view_type::label;

			//----------------------------------------
			// Allocation according to allocation properties and array layout

			template< class ... P >
			explicit inline
			DynRankView( const Impl::ViewCtorProp< P ... > & arg_prop
			, typename std::enable_if< ! Impl::ViewCtorProp< P... >::has_pointer
			, typename traits::array_layout
			>::type const & arg_layout
			)
			: view_type( arg_prop
			, Impl::DynRankDimTraits<typename traits::specialize>::createLayout(arg_layout) )
			, m_rank( Impl::DynRankDimTraits<typename traits::specialize>::computeRank(arg_layout) )
			{}

			//Wrappers
			template< class ... P >
			explicit KOKKOS_INLINE_FUNCTION
			DynRankView( const Impl::ViewCtorProp< P ... > & arg_prop
			, typename std::enable_if< Impl::ViewCtorProp< P... >::has_pointer
			, typename traits::array_layout
			>::type const & arg_layout
			)
			: view_type( arg_prop
			, Impl::DynRankDimTraits<typename traits::specialize>::createLayout(arg_layout) )
			, m_rank( Impl::DynRankDimTraits<typename traits::specialize>::computeRank(arg_layout) )
			{}

			//----------------------------------------
			//Constructor(s)

			// Simple dimension-only layout
			template< class ... P >
			explicit inline
			DynRankView( const Impl::ViewCtorProp< P ... > & arg_prop
			, typename std::enable_if< ! Impl::ViewCtorProp< P... >::has_pointer
			, size_t
			>::type const arg_N0 = 0
			, const size_t arg_N1 = 0
			, const size_t arg_N2 = 0
			, const size_t arg_N3 = 0
			, const size_t arg_N4 = 0
			, const size_t arg_N5 = 0
			, const size_t arg_N6 = 0
			, const size_t arg_N7 = 0
			)
			: DynRankView( arg_prop
			, typename traits::array_layout
			( arg_N0 , arg_N1 , arg_N2 , arg_N3 , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
			)
			{}

			template< class ... P >
			explicit KOKKOS_INLINE_FUNCTION
			DynRankView( const Impl::ViewCtorProp< P ... > & arg_prop
			, typename std::enable_if< Impl::ViewCtorProp< P... >::has_pointer
			, size_t
			>::type const arg_N0 = 0
			, const size_t arg_N1 = 0
			, const size_t arg_N2 = 0
			, const size_t arg_N3 = 0
			, const size_t arg_N4 = 0
			, const size_t arg_N5 = 0
			, const size_t arg_N6 = 0
			, const size_t arg_N7 = 0
			)
			: DynRankView( arg_prop
			, typename traits::array_layout
			( arg_N0 , arg_N1 , arg_N2 , arg_N3 , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
			)
			{}

			// Allocate with label and layout
			template< typename Label >
			explicit inline
			DynRankView( const Label & arg_label
			, typename std::enable_if<
			Kokkos::Experimental::Impl::is_view_label<Label>::value ,
			typename traits::array_layout >::type const & arg_layout
			)
			: DynRankView( Impl::ViewCtorProp< std::string >( arg_label ) , arg_layout )
			{}

			// Allocate label and layout
			template< typename Label >
			explicit inline
			DynRankView( const Label & arg_label
			, typename std::enable_if<
			Kokkos::Experimental::Impl::is_view_label<Label>::value ,
			const size_t >::type arg_N0 = 0
			, const size_t arg_N1 = 0
			, const size_t arg_N2 = 0
			, const size_t arg_N3 = 0
			, const size_t arg_N4 = 0
			, const size_t arg_N5 = 0
			, const size_t arg_N6 = 0
			, const size_t arg_N7 = 0
			)
			: DynRankView( Impl::ViewCtorProp< std::string >( arg_label )
			, typename traits::array_layout
			( arg_N0 , arg_N1 , arg_N2 , arg_N3 , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
			)
			{}

			// For backward compatibility
			/*
			explicit inline
			DynRankView( const ViewAllocateWithoutInitializing & arg_prop
			, const typename traits::array_layout & arg_layout
			)
			: view_type( Impl::ViewCtorProp< std::string , Kokkos::Experimental::Impl::WithoutInitializing_t >( arg_prop.label , Kokkos::Experimental::WithoutInitializing )
			, arg_layout
			)
			//, m_rank(arg_N0 == 0 ? 0 : ( arg_N1 == 0 ? 1 : ( arg_N2 == 0 ? 2 : ( arg_N3 == 0 ? 3 : ( arg_N4 == 0 ? 4 : ( arg_N5 == 0 ? 5 : ( arg_N6 == 0 ? 6 : ( arg_N7 == 0 ? 7 : 8 ) ) ) ) ) ) ) ) //how to extract rank?
			{}
			*/

			explicit inline
			DynRankView( const ViewAllocateWithoutInitializing & arg_prop
			, const size_t arg_N0 = 0
			, const size_t arg_N1 = 0
			, const size_t arg_N2 = 0
			, const size_t arg_N3 = 0
			, const size_t arg_N4 = 0
			, const size_t arg_N5 = 0
			, const size_t arg_N6 = 0
			, const size_t arg_N7 = 0
			)
			: DynRankView(Impl::ViewCtorProp< std::string , Kokkos::Experimental::Impl::WithoutInitializing_t >( arg_prop.label , Kokkos::Experimental::WithoutInitializing ), arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7 )
			{}

			using view_type::memory_span;

			explicit KOKKOS_INLINE_FUNCTION
			DynRankView( pointer_type arg_ptr
			, const size_t arg_N0 = 0
			, const size_t arg_N1 = 0
			, const size_t arg_N2 = 0
			, const size_t arg_N3 = 0
			, const size_t arg_N4 = 0
			, const size_t arg_N5 = 0
			, const size_t arg_N6 = 0
			, const size_t arg_N7 = 0
			)
			: DynRankView( Impl::ViewCtorProp<pointer_type>(arg_ptr) , arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7 )
			{}

			explicit KOKKOS_INLINE_FUNCTION
			DynRankView( pointer_type arg_ptr
			, typename traits::array_layout & arg_layout
			)
			: DynRankView( Impl::ViewCtorProp<pointer_type>(arg_ptr) , arg_layout )
			{}


			//----------------------------------------
			// Shared scratch memory constructor

			using view_type::shmem_size;

			explicit KOKKOS_INLINE_FUNCTION
			DynRankView( const typename traits::execution_space::scratch_memory_space & arg_space
			, const size_t arg_N0 = 0
			, const size_t arg_N1 = 0
			, const size_t arg_N2 = 0
			, const size_t arg_N3 = 0
			, const size_t arg_N4 = 0
			, const size_t arg_N5 = 0
			, const size_t arg_N6 = 0
			, const size_t arg_N7 = 0 )
			: view_type( Impl::DynRankDimTraits<typename traits::specialize>::template createView<view_type>( arg_space
			, arg_N0
			, arg_N1
			, arg_N2
			, arg_N3
			, arg_N4
			, arg_N5
			, arg_N6
			, arg_N7 ) )
			, m_rank( Impl::DynRankDimTraits<typename traits::specialize>::computeRank( arg_N0
			, arg_N1
			, arg_N2
			, arg_N3
			, arg_N4
			, arg_N5
			, arg_N6
			, arg_N7 ) )
			{}

			};

			//----------------------------------------------------------------------------
			// Subview mapping.
			// Deduce destination view type from source view traits and subview arguments

			namespace Impl {

			struct DynRankSubviewTag {};

			template< class SrcTraits , class ... Args >
			struct ViewMapping
			< typename std::enable_if<(
			std::is_same< typename SrcTraits::specialize , void >::value
			&&
			(
			std::is_same< typename SrcTraits::array_layout
			, Kokkos::LayoutLeft >::value \|\|
			std::is_same< typename SrcTraits::array_layout
			, Kokkos::LayoutRight >::value \|\|
			std::is_same< typename SrcTraits::array_layout
			, Kokkos::LayoutStride >::value
			)
			), DynRankSubviewTag >::type
			, SrcTraits
			, Args ... >
			{
			private:

			enum
			{ RZ = false
			, R0 = bool(is_integral_extent<0,Args...>::value)
			, R1 = bool(is_integral_extent<1,Args...>::value)
			, R2 = bool(is_integral_extent<2,Args...>::value)
			, R3 = bool(is_integral_extent<3,Args...>::value)
			, R4 = bool(is_integral_extent<4,Args...>::value)
			, R5 = bool(is_integral_extent<5,Args...>::value)
			, R6 = bool(is_integral_extent<6,Args...>::value)
			};

			enum { rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3)
			+ unsigned(R4) + unsigned(R5) + unsigned(R6) };

			typedef Kokkos::LayoutStride array_layout ;

			typedef typename SrcTraits::value_type value_type ;

			typedef value_type******* data_type ;

			public:

			typedef Kokkos::Experimental::ViewTraits
			< data_type
			, array_layout
			, typename SrcTraits::device_type
			, typename SrcTraits::memory_traits > traits_type ;

			typedef Kokkos::Experimental::View
			< data_type
			, array_layout
			, typename SrcTraits::device_type
			, typename SrcTraits::memory_traits > type ;


			template< class MemoryTraits >
			struct apply {

			static_assert( Kokkos::Impl::is_memory_traits< MemoryTraits >::value , "" );

			typedef Kokkos::Experimental::ViewTraits
			< data_type
			, array_layout
			, typename SrcTraits::device_type
			, MemoryTraits > traits_type ;

			typedef Kokkos::Experimental::View
			< data_type
			, array_layout
			, typename SrcTraits::device_type
			, MemoryTraits > type ;
			};


			typedef typename SrcTraits::dimension dimension ;

			template < class Arg0 = int, class Arg1 = int, class Arg2 = int, class Arg3 = int, class Arg4 = int, class Arg5 = int, class Arg6 = int >
			struct ExtentGenerator {
			KOKKOS_INLINE_FUNCTION
			static SubviewExtents< 7 , rank > generator ( const dimension & dim , Arg0 arg0 = Arg0(), Arg1 arg1 = Arg1(), Arg2 arg2 = Arg2(), Arg3 arg3 = Arg3(), Arg4 arg4 = Arg4(), Arg5 arg5 = Arg5(), Arg6 arg6 = Arg6() )
			{
			return SubviewExtents< 7 , rank>( dim , arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
			}
			};


			typedef DynRankView< value_type , array_layout , typename SrcTraits::device_type , typename SrcTraits::memory_traits > ret_type;

			template < typename T , class ... P >
			KOKKOS_INLINE_FUNCTION
			static ret_type subview( const unsigned src_rank , Kokkos::Experimental::View< T******* , P...> const & src
			, Args ... args )
			{

			typedef ViewMapping< traits_type, void > DstType ;

			typedef typename std::conditional< (rank==0) , ViewDimension<>
			, typename std::conditional< (rank==1) , ViewDimension<0>
			, typename std::conditional< (rank==2) , ViewDimension<0,0>
			, typename std::conditional< (rank==3) , ViewDimension<0,0,0>
			, typename std::conditional< (rank==4) , ViewDimension<0,0,0,0>
			, typename std::conditional< (rank==5) , ViewDimension<0,0,0,0,0>
			, typename std::conditional< (rank==6) , ViewDimension<0,0,0,0,0,0>
			, ViewDimension<0,0,0,0,0,0,0>
			>::type >::type >::type >::type >::type >::type >::type DstDimType ;

			typedef ViewOffset< DstDimType , Kokkos::LayoutStride > dst_offset_type ;
			typedef typename DstType::handle_type dst_handle_type ;

			ret_type dst ;

			const SubviewExtents< 7 , rank > extents =
			ExtentGenerator< Args ... >::generator( src.m_map.m_offset.m_dim , args... ) ;

			dst_offset_type tempdst( src.m_map.m_offset , extents ) ;

			dst.m_track = src.m_track ;

			dst.m_map.m_offset.m_dim.N0 = tempdst.m_dim.N0 ;
			dst.m_map.m_offset.m_dim.N1 = tempdst.m_dim.N1 ;
			dst.m_map.m_offset.m_dim.N2 = tempdst.m_dim.N2 ;
			dst.m_map.m_offset.m_dim.N3 = tempdst.m_dim.N3 ;
			dst.m_map.m_offset.m_dim.N4 = tempdst.m_dim.N4 ;
			dst.m_map.m_offset.m_dim.N5 = tempdst.m_dim.N5 ;
			dst.m_map.m_offset.m_dim.N6 = tempdst.m_dim.N6 ;

			dst.m_map.m_offset.m_stride.S0 = tempdst.m_stride.S0 ;
			dst.m_map.m_offset.m_stride.S1 = tempdst.m_stride.S1 ;
			dst.m_map.m_offset.m_stride.S2 = tempdst.m_stride.S2 ;
			dst.m_map.m_offset.m_stride.S3 = tempdst.m_stride.S3 ;
			dst.m_map.m_offset.m_stride.S4 = tempdst.m_stride.S4 ;
			dst.m_map.m_offset.m_stride.S5 = tempdst.m_stride.S5 ;
			dst.m_map.m_offset.m_stride.S6 = tempdst.m_stride.S6 ;

			dst.m_map.m_handle = dst_handle_type( src.m_map.m_handle +
			src.m_map.m_offset( extents.domain_offset(0)
			, extents.domain_offset(1)
			, extents.domain_offset(2)
			, extents.domain_offset(3)
			, extents.domain_offset(4)
			, extents.domain_offset(5)
			, extents.domain_offset(6)
			) );

			dst.m_rank = ( src_rank > 0 ? unsigned(R0) : 0 )
			+ ( src_rank > 1 ? unsigned(R1) : 0 )
			+ ( src_rank > 2 ? unsigned(R2) : 0 )
			+ ( src_rank > 3 ? unsigned(R3) : 0 )
			+ ( src_rank > 4 ? unsigned(R4) : 0 )
			+ ( src_rank > 5 ? unsigned(R5) : 0 )
			+ ( src_rank > 6 ? unsigned(R6) : 0 ) ;

			return dst ;
			}
			};

			} // end Impl


			template< class V , class ... Args >
			using Subdynrankview = typename Kokkos::Experimental::Impl::ViewMapping< Kokkos::Experimental::Impl::DynRankSubviewTag , V , Args... >::ret_type ;

			template< class D , class ... P , class ...Args >
			KOKKOS_INLINE_FUNCTION
			Subdynrankview< ViewTraits<D******* , P...> , Args... >
			subdynrankview( const Kokkos::Experimental::DynRankView< D , P... > &src , Args...args)
			{
			if ( src.rank() > sizeof...(Args) ) //allow sizeof...(Args) >= src.rank(), ignore the remaining args
			{ Kokkos::abort("subdynrankview: num of args must be >= rank of the source DynRankView"); }

			typedef Kokkos::Experimental::Impl::ViewMapping< Kokkos::Experimental::Impl::DynRankSubviewTag , Kokkos::Experimental::ViewTraits< D*******, P... > , Args... > metafcn ;

			return metafcn::subview( src.rank() , src.ConstDownCast() , args... );
			}

			} // namespace Experimental
			} // namespace Kokkos


			namespace Kokkos {
			namespace Experimental {

			// overload == and !=
			template< class LT , class ... LP , class RT , class ... RP >
			KOKKOS_INLINE_FUNCTION
			bool operator == ( const DynRankView<LT,LP...> & lhs ,
			const DynRankView<RT,RP...> & rhs )
			{
			// Same data, layout, dimensions
			typedef ViewTraits<LT,LP...> lhs_traits ;
			typedef ViewTraits<RT,RP...> rhs_traits ;

			return
			std::is_same< typename lhs_traits::const_value_type ,
			typename rhs_traits::const_value_type >::value &&
			std::is_same< typename lhs_traits::array_layout ,
			typename rhs_traits::array_layout >::value &&
			std::is_same< typename lhs_traits::memory_space ,
			typename rhs_traits::memory_space >::value &&
			lhs.rank() == rhs.rank() &&
			lhs.data() == rhs.data() &&
			lhs.span() == rhs.span() &&
			lhs.dimension(0) == rhs.dimension(0) &&
			lhs.dimension(1) == rhs.dimension(1) &&
			lhs.dimension(2) == rhs.dimension(2) &&
			lhs.dimension(3) == rhs.dimension(3) &&
			lhs.dimension(4) == rhs.dimension(4) &&
			lhs.dimension(5) == rhs.dimension(5) &&
			lhs.dimension(6) == rhs.dimension(6) &&
			lhs.dimension(7) == rhs.dimension(7);
			}

			template< class LT , class ... LP , class RT , class ... RP >
			KOKKOS_INLINE_FUNCTION
			bool operator != ( const DynRankView<LT,LP...> & lhs ,
			const DynRankView<RT,RP...> & rhs )
			{
			return ! ( operator==(lhs,rhs) );
			}

			} //end Experimental
			} //end Kokkos

			//----------------------------------------------------------------------------
			//----------------------------------------------------------------------------

			namespace Kokkos {
			namespace Experimental {

			/** \brief Deep copy a value from Host memory into a view. */
			template< class DT , class ... DP >
			inline
			void deep_copy
			( const DynRankView<DT,DP...> & dst
			, typename ViewTraits<DT,DP...>::const_value_type & value )
			{
			deep_copy( dst.ConstDownCast() , value );
			}

			/** \brief Deep copy into a value in Host memory from a view. */
			template< class ST , class ... SP >
			inline
			void deep_copy
			( typename ViewTraits<ST,SP...>::non_const_value_type & dst
			, const DynRankView<ST,SP...> & src )
			{
			deep_copy( dst , src.ConstDownCast() );
			}


			//----------------------------------------------------------------------------
			/** \brief A deep copy between views of compatible type */
			template< class DT , class ... DP , class ST , class ... SP >
			inline
			void deep_copy
			( const DynRankView<DT,DP...> & dst
			, const DynRankView<ST,SP...> & src )
			{
			deep_copy( dst.ConstDownCast() , src.ConstDownCast() );
			}

			} //end Experimental
			} //end Kokkos


			//----------------------------------------------------------------------------
			//----------------------------------------------------------------------------

			namespace Kokkos {
			namespace Experimental {

			template< class T , class ... P >
			inline
			typename DynRankView<T,P...>::HostMirror
			create_mirror( const DynRankView<T,P...> & src
			, typename std::enable_if<
			! std::is_same< typename Kokkos::Experimental::ViewTraits<T,P...>::array_layout
			, Kokkos::LayoutStride >::value
			>::type * = 0
			)
			{
			typedef DynRankView<T,P...> src_type ;
			typedef typename src_type::HostMirror dst_type ;

			return dst_type( std::string( src.label() ).append("_mirror")
			, src.dimension(0)
			, src.dimension(1)
			, src.dimension(2)
			, src.dimension(3)
			, src.dimension(4)
			, src.dimension(5)
			, src.dimension(6)
			, src.dimension(7) );
			}


			template< class T , class ... P >
			inline
			typename DynRankView<T,P...>::HostMirror
			create_mirror( const DynRankView<T,P...> & src
			, typename std::enable_if<
			std::is_same< typename Kokkos::Experimental::ViewTraits<T,P...>::array_layout
			, Kokkos::LayoutStride >::value
			>::type * = 0
			)
			{
			typedef DynRankView<T,P...> src_type ;
			typedef typename src_type::HostMirror dst_type ;

			Kokkos::LayoutStride layout ;

			layout.dimension[0] = src.dimension(0);
			layout.dimension[1] = src.dimension(1);
			layout.dimension[2] = src.dimension(2);
			layout.dimension[3] = src.dimension(3);
			layout.dimension[4] = src.dimension(4);
			layout.dimension[5] = src.dimension(5);
			layout.dimension[6] = src.dimension(6);
			layout.dimension[7] = src.dimension(7);

			layout.stride[0] = src.stride(0);
			layout.stride[1] = src.stride(1);
			layout.stride[2] = src.stride(2);
			layout.stride[3] = src.stride(3);
			layout.stride[4] = src.stride(4);
			layout.stride[5] = src.stride(5);
			layout.stride[6] = src.stride(6);
			layout.stride[7] = src.stride(7);

			return dst_type( std::string( src.label() ).append("_mirror") , layout );
			}

			template< class T , class ... P >
			inline
			typename DynRankView<T,P...>::HostMirror
			create_mirror_view( const DynRankView<T,P...> & src
			, typename std::enable_if<(
			std::is_same< typename DynRankView<T,P...>::memory_space
			, typename DynRankView<T,P...>::HostMirror::memory_space
			>::value
			&&
			std::is_same< typename DynRankView<T,P...>::data_type
			, typename DynRankView<T,P...>::HostMirror::data_type
			>::value
			)>::type * = 0
			)
			{
			return src ;
			}

			template< class T , class ... P >
			inline
			typename DynRankView<T,P...>::HostMirror
			create_mirror_view( const DynRankView<T,P...> & src
			, typename std::enable_if< ! (
			std::is_same< typename DynRankView<T,P...>::memory_space
			, typename DynRankView<T,P...>::HostMirror::memory_space
			>::value
			&&
			std::is_same< typename DynRankView<T,P...>::data_type
			, typename DynRankView<T,P...>::HostMirror::data_type
			>::value
			)>::type * = 0
			)
			{
			return Kokkos::Experimental::create_mirror( src );
			}

			} //end Experimental
			} //end Kokkos


			//----------------------------------------------------------------------------
			//----------------------------------------------------------------------------

			namespace Kokkos {
			namespace Experimental {

			/** \brief Resize a view with copying old data to new data at the corresponding indices. */
			template< class T , class ... P >
			inline
			void resize( DynRankView<T,P...> & v ,
			const size_t n0 = 0 ,
			const size_t n1 = 0 ,
			const size_t n2 = 0 ,
			const size_t n3 = 0 ,
			const size_t n4 = 0 ,
			const size_t n5 = 0 ,
			const size_t n6 = 0 ,
			const size_t n7 = 0 )
			{
			typedef DynRankView<T,P...> drview_type ;

			static_assert( Kokkos::Experimental::ViewTraits<T,P...>::is_managed , "Can only resize managed views" );

			drview_type v_resized( v.label(), n0, n1, n2, n3, n4, n5, n6, n7 );

			Kokkos::Experimental::Impl::ViewRemap< drview_type , drview_type >( v_resized , v );

			v = v_resized ;
			}

			/** \brief Resize a view with copying old data to new data at the corresponding indices. */
			template< class T , class ... P >
			inline
			void realloc( DynRankView<T,P...> & v ,
			const size_t n0 = 0 ,
			const size_t n1 = 0 ,
			const size_t n2 = 0 ,
			const size_t n3 = 0 ,
			const size_t n4 = 0 ,
			const size_t n5 = 0 ,
			const size_t n6 = 0 ,
			const size_t n7 = 0 )
			{
			typedef DynRankView<T,P...> view_type ;

			static_assert( Kokkos::Experimental::ViewTraits<T,P...>::is_managed , "Can only realloc managed views" );

			const std::string label = v.label();

			v = view_type(); // Deallocate first, if the only view to allocation
			v = view_type( label, n0, n1, n2, n3, n4, n5, n6, n7 );
			}

			} //end Experimental

			} //end Kokkos


			namespace Kokkos {

			template< typename D , class ... P >
			using DynRankView = Kokkos::Experimental::DynRankView< D , P... > ;

			using Kokkos::Experimental::deep_copy ;
			using Kokkos::Experimental::create_mirror ;
			using Kokkos::Experimental::create_mirror_view ;
			using Kokkos::Experimental::subdynrankview ;
			using Kokkos::Experimental::resize ;
			using Kokkos::Experimental::realloc ;

			} //end Kokkos
			#endif

lammps/lib/kokkos/containers/src/Kokkos_DynRankView.hppfda492ea48eclammps-icms

Kokkos_DynRankView.hppView Options

lammps/lib/kokkos/containers/src/Kokkos_DynRankView.hpp
fda492ea48eclammps-icms

Kokkos_DynRankView.hpp
View Options