Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F120446830
TestViewAPI.hpp
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Fri, Jul 4, 11:15
Size
45 KB
Mime Type
text/x-c
Expires
Sun, Jul 6, 11:15 (2 d)
Engine
blob
Format
Raw Data
Handle
27190507
Attached To
rLAMMPS lammps
TestViewAPI.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
*/
#include <gtest/gtest.h>
#include <Kokkos_Core.hpp>
#include <stdexcept>
#include <sstream>
#include <iostream>
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
namespace Test {
#if KOKKOS_USING_EXP_VIEW
template< class T , class ... P >
size_t allocation_count( const Kokkos::View<T,P...> & view )
{
const size_t card = view.size();
const size_t alloc = view.span();
const int memory_span = Kokkos::View<int*>::required_allocation_size(100);
return (card <= alloc && memory_span == 400) ? alloc : 0 ;
}
#else
template< class T , class L , class D , class M , class S >
size_t allocation_count( const Kokkos::View<T,L,D,M,S> & view )
{
const size_t card = Kokkos::Impl::cardinality_count( view.shape() );
const size_t alloc = view.capacity();
return card <= alloc ? alloc : 0 ;
}
#endif
/*--------------------------------------------------------------------------*/
template< typename T, class DeviceType>
struct TestViewOperator
{
typedef typename DeviceType::execution_space execution_space ;
static const unsigned N = 100 ;
static const unsigned D = 3 ;
typedef Kokkos::View< T*[D] , execution_space > view_type ;
const view_type v1 ;
const view_type v2 ;
TestViewOperator()
: v1( "v1" , N )
, v2( "v2" , N )
{}
static void testit()
{
Kokkos::parallel_for( N , TestViewOperator() );
}
KOKKOS_INLINE_FUNCTION
void operator()( const unsigned i ) const
{
const unsigned X = 0 ;
const unsigned Y = 1 ;
const unsigned Z = 2 ;
v2(i,X) = v1(i,X);
v2(i,Y) = v1(i,Y);
v2(i,Z) = v1(i,Z);
}
};
/*--------------------------------------------------------------------------*/
template< class DataType ,
class DeviceType ,
unsigned Rank = Kokkos::ViewTraits< DataType >::rank >
struct TestViewOperator_LeftAndRight ;
template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 8 >
{
typedef typename DeviceType::execution_space execution_space ;
typedef typename DeviceType::memory_space memory_space ;
typedef typename execution_space::size_type size_type ;
typedef int value_type ;
KOKKOS_INLINE_FUNCTION
static void join( volatile value_type & update ,
const volatile value_type & input )
{ update |= input ; }
KOKKOS_INLINE_FUNCTION
static void init( value_type & update )
{ update = 0 ; }
typedef Kokkos::
View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutRight, execution_space > right_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutStride, execution_space > stride_view ;
left_view left ;
right_view right ;
stride_view left_stride ;
stride_view right_stride ;
long left_alloc ;
long right_alloc ;
TestViewOperator_LeftAndRight()
: left( "left" )
, right( "right" )
, left_stride( left )
, right_stride( right )
, left_alloc( allocation_count( left ) )
, right_alloc( allocation_count( right ) )
{}
static void testit()
{
TestViewOperator_LeftAndRight driver ;
int error_flag = 0 ;
Kokkos::parallel_reduce( 1 , driver , error_flag );
ASSERT_EQ( error_flag , 0 );
}
KOKKOS_INLINE_FUNCTION
void operator()( const size_type , value_type & update ) const
{
long offset ;
offset = -1 ;
for ( unsigned i7 = 0 ; i7 < unsigned(left.dimension_7()) ; ++i7 )
for ( unsigned i6 = 0 ; i6 < unsigned(left.dimension_6()) ; ++i6 )
for ( unsigned i5 = 0 ; i5 < unsigned(left.dimension_5()) ; ++i5 )
for ( unsigned i4 = 0 ; i4 < unsigned(left.dimension_4()) ; ++i4 )
for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
{
const long j = & left( i0, i1, i2, i3, i4, i5, i6, i7 ) -
& left( 0, 0, 0, 0, 0, 0, 0, 0 );
if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
offset = j ;
if ( & left(i0,i1,i2,i3,i4,i5,i6,i7) !=
& left_stride(i0,i1,i2,i3,i4,i5,i6,i7) ) {
update |= 4 ;
}
}
offset = -1 ;
for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
for ( unsigned i4 = 0 ; i4 < unsigned(right.dimension_4()) ; ++i4 )
for ( unsigned i5 = 0 ; i5 < unsigned(right.dimension_5()) ; ++i5 )
for ( unsigned i6 = 0 ; i6 < unsigned(right.dimension_6()) ; ++i6 )
for ( unsigned i7 = 0 ; i7 < unsigned(right.dimension_7()) ; ++i7 )
{
const long j = & right( i0, i1, i2, i3, i4, i5, i6, i7 ) -
& right( 0, 0, 0, 0, 0, 0, 0, 0 );
if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
offset = j ;
if ( & right(i0,i1,i2,i3,i4,i5,i6,i7) !=
& right_stride(i0,i1,i2,i3,i4,i5,i6,i7) ) {
update |= 8 ;
}
}
}
};
template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 7 >
{
typedef typename DeviceType::execution_space execution_space ;
typedef typename DeviceType::memory_space memory_space ;
typedef typename execution_space::size_type size_type ;
typedef int value_type ;
KOKKOS_INLINE_FUNCTION
static void join( volatile value_type & update ,
const volatile value_type & input )
{ update |= input ; }
KOKKOS_INLINE_FUNCTION
static void init( value_type & update )
{ update = 0 ; }
typedef Kokkos::
View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutRight, execution_space > right_view ;
left_view left ;
right_view right ;
long left_alloc ;
long right_alloc ;
TestViewOperator_LeftAndRight()
: left( "left" )
, right( "right" )
, left_alloc( allocation_count( left ) )
, right_alloc( allocation_count( right ) )
{}
static void testit()
{
TestViewOperator_LeftAndRight driver ;
int error_flag = 0 ;
Kokkos::parallel_reduce( 1 , driver , error_flag );
ASSERT_EQ( error_flag , 0 );
}
KOKKOS_INLINE_FUNCTION
void operator()( const size_type , value_type & update ) const
{
long offset ;
offset = -1 ;
for ( unsigned i6 = 0 ; i6 < unsigned(left.dimension_6()) ; ++i6 )
for ( unsigned i5 = 0 ; i5 < unsigned(left.dimension_5()) ; ++i5 )
for ( unsigned i4 = 0 ; i4 < unsigned(left.dimension_4()) ; ++i4 )
for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
{
const long j = & left( i0, i1, i2, i3, i4, i5, i6 ) -
& left( 0, 0, 0, 0, 0, 0, 0 );
if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
offset = j ;
}
offset = -1 ;
for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
for ( unsigned i4 = 0 ; i4 < unsigned(right.dimension_4()) ; ++i4 )
for ( unsigned i5 = 0 ; i5 < unsigned(right.dimension_5()) ; ++i5 )
for ( unsigned i6 = 0 ; i6 < unsigned(right.dimension_6()) ; ++i6 )
{
const long j = & right( i0, i1, i2, i3, i4, i5, i6 ) -
& right( 0, 0, 0, 0, 0, 0, 0 );
if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
offset = j ;
}
}
};
template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 6 >
{
typedef typename DeviceType::execution_space execution_space ;
typedef typename DeviceType::memory_space memory_space ;
typedef typename execution_space::size_type size_type ;
typedef int value_type ;
KOKKOS_INLINE_FUNCTION
static void join( volatile value_type & update ,
const volatile value_type & input )
{ update |= input ; }
KOKKOS_INLINE_FUNCTION
static void init( value_type & update )
{ update = 0 ; }
typedef Kokkos::
View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutRight, execution_space > right_view ;
left_view left ;
right_view right ;
long left_alloc ;
long right_alloc ;
TestViewOperator_LeftAndRight()
: left( "left" )
, right( "right" )
, left_alloc( allocation_count( left ) )
, right_alloc( allocation_count( right ) )
{}
static void testit()
{
TestViewOperator_LeftAndRight driver ;
int error_flag = 0 ;
Kokkos::parallel_reduce( 1 , driver , error_flag );
ASSERT_EQ( error_flag , 0 );
}
KOKKOS_INLINE_FUNCTION
void operator()( const size_type , value_type & update ) const
{
long offset ;
offset = -1 ;
for ( unsigned i5 = 0 ; i5 < unsigned(left.dimension_5()) ; ++i5 )
for ( unsigned i4 = 0 ; i4 < unsigned(left.dimension_4()) ; ++i4 )
for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
{
const long j = & left( i0, i1, i2, i3, i4, i5 ) -
& left( 0, 0, 0, 0, 0, 0 );
if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
offset = j ;
}
offset = -1 ;
for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
for ( unsigned i4 = 0 ; i4 < unsigned(right.dimension_4()) ; ++i4 )
for ( unsigned i5 = 0 ; i5 < unsigned(right.dimension_5()) ; ++i5 )
{
const long j = & right( i0, i1, i2, i3, i4, i5 ) -
& right( 0, 0, 0, 0, 0, 0 );
if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
offset = j ;
}
}
};
template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 5 >
{
typedef typename DeviceType::execution_space execution_space ;
typedef typename DeviceType::memory_space memory_space ;
typedef typename execution_space::size_type size_type ;
typedef int value_type ;
KOKKOS_INLINE_FUNCTION
static void join( volatile value_type & update ,
const volatile value_type & input )
{ update |= input ; }
KOKKOS_INLINE_FUNCTION
static void init( value_type & update )
{ update = 0 ; }
typedef Kokkos::
View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutRight, execution_space > right_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutStride, execution_space > stride_view ;
left_view left ;
right_view right ;
stride_view left_stride ;
stride_view right_stride ;
long left_alloc ;
long right_alloc ;
TestViewOperator_LeftAndRight()
: left( "left" )
, right( "right" )
, left_stride( left )
, right_stride( right )
, left_alloc( allocation_count( left ) )
, right_alloc( allocation_count( right ) )
{}
static void testit()
{
TestViewOperator_LeftAndRight driver ;
int error_flag = 0 ;
Kokkos::parallel_reduce( 1 , driver , error_flag );
ASSERT_EQ( error_flag , 0 );
}
KOKKOS_INLINE_FUNCTION
void operator()( const size_type , value_type & update ) const
{
long offset ;
offset = -1 ;
for ( unsigned i4 = 0 ; i4 < unsigned(left.dimension_4()) ; ++i4 )
for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
{
const long j = & left( i0, i1, i2, i3, i4 ) -
& left( 0, 0, 0, 0, 0 );
if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
offset = j ;
if ( & left( i0, i1, i2, i3, i4 ) !=
& left_stride( i0, i1, i2, i3, i4 ) ) { update |= 4 ; }
}
offset = -1 ;
for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
for ( unsigned i4 = 0 ; i4 < unsigned(right.dimension_4()) ; ++i4 )
{
const long j = & right( i0, i1, i2, i3, i4 ) -
& right( 0, 0, 0, 0, 0 );
if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
offset = j ;
if ( & right( i0, i1, i2, i3, i4 ) !=
& right_stride( i0, i1, i2, i3, i4 ) ) { update |= 8 ; }
}
}
};
template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 4 >
{
typedef typename DeviceType::execution_space execution_space ;
typedef typename DeviceType::memory_space memory_space ;
typedef typename execution_space::size_type size_type ;
typedef int value_type ;
KOKKOS_INLINE_FUNCTION
static void join( volatile value_type & update ,
const volatile value_type & input )
{ update |= input ; }
KOKKOS_INLINE_FUNCTION
static void init( value_type & update )
{ update = 0 ; }
typedef Kokkos::
View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutRight, execution_space > right_view ;
left_view left ;
right_view right ;
long left_alloc ;
long right_alloc ;
TestViewOperator_LeftAndRight()
: left( "left" )
, right( "right" )
, left_alloc( allocation_count( left ) )
, right_alloc( allocation_count( right ) )
{}
static void testit()
{
TestViewOperator_LeftAndRight driver ;
int error_flag = 0 ;
Kokkos::parallel_reduce( 1 , driver , error_flag );
ASSERT_EQ( error_flag , 0 );
}
KOKKOS_INLINE_FUNCTION
void operator()( const size_type , value_type & update ) const
{
long offset ;
offset = -1 ;
for ( unsigned i3 = 0 ; i3 < unsigned(left.dimension_3()) ; ++i3 )
for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
{
const long j = & left( i0, i1, i2, i3 ) -
& left( 0, 0, 0, 0 );
if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
offset = j ;
}
offset = -1 ;
for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
for ( unsigned i3 = 0 ; i3 < unsigned(right.dimension_3()) ; ++i3 )
{
const long j = & right( i0, i1, i2, i3 ) -
& right( 0, 0, 0, 0 );
if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
offset = j ;
}
}
};
template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 3 >
{
typedef typename DeviceType::execution_space execution_space ;
typedef typename DeviceType::memory_space memory_space ;
typedef typename execution_space::size_type size_type ;
typedef int value_type ;
KOKKOS_INLINE_FUNCTION
static void join( volatile value_type & update ,
const volatile value_type & input )
{ update |= input ; }
KOKKOS_INLINE_FUNCTION
static void init( value_type & update )
{ update = 0 ; }
typedef Kokkos::
View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutRight, execution_space > right_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutStride, execution_space > stride_view ;
left_view left ;
right_view right ;
stride_view left_stride ;
stride_view right_stride ;
long left_alloc ;
long right_alloc ;
TestViewOperator_LeftAndRight()
: left( std::string("left") )
, right( std::string("right") )
, left_stride( left )
, right_stride( right )
, left_alloc( allocation_count( left ) )
, right_alloc( allocation_count( right ) )
{}
static void testit()
{
TestViewOperator_LeftAndRight driver ;
int error_flag = 0 ;
Kokkos::parallel_reduce( 1 , driver , error_flag );
ASSERT_EQ( error_flag , 0 );
}
KOKKOS_INLINE_FUNCTION
void operator()( const size_type , value_type & update ) const
{
long offset ;
offset = -1 ;
for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
{
const long j = & left( i0, i1, i2 ) -
& left( 0, 0, 0 );
if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
offset = j ;
if ( & left(i0,i1,i2) != & left_stride(i0,i1,i2) ) { update |= 4 ; }
}
offset = -1 ;
for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
for ( unsigned i2 = 0 ; i2 < unsigned(right.dimension_2()) ; ++i2 )
{
const long j = & right( i0, i1, i2 ) -
& right( 0, 0, 0 );
if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
offset = j ;
if ( & right(i0,i1,i2) != & right_stride(i0,i1,i2) ) { update |= 8 ; }
}
#if KOKKOS_USING_EXP_VIEW
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
for ( unsigned i2 = 0 ; i2 < unsigned(left.dimension_2()) ; ++i2 )
{
if ( & left(i0,i1,i2) != & left(i0,i1,i2,0,0,0,0,0) ) { update |= 3 ; }
if ( & right(i0,i1,i2) != & right(i0,i1,i2,0,0,0,0,0) ) { update |= 3 ; }
}
#endif
}
};
template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 2 >
{
typedef typename DeviceType::execution_space execution_space ;
typedef typename DeviceType::memory_space memory_space ;
typedef typename execution_space::size_type size_type ;
typedef int value_type ;
KOKKOS_INLINE_FUNCTION
static void join( volatile value_type & update ,
const volatile value_type & input )
{ update |= input ; }
KOKKOS_INLINE_FUNCTION
static void init( value_type & update )
{ update = 0 ; }
typedef Kokkos::
View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutRight, execution_space > right_view ;
left_view left ;
right_view right ;
long left_alloc ;
long right_alloc ;
TestViewOperator_LeftAndRight()
: left( "left" )
, right( "right" )
, left_alloc( allocation_count( left ) )
, right_alloc( allocation_count( right ) )
{}
static void testit()
{
TestViewOperator_LeftAndRight driver ;
int error_flag = 0 ;
Kokkos::parallel_reduce( 1 , driver , error_flag );
ASSERT_EQ( error_flag , 0 );
}
KOKKOS_INLINE_FUNCTION
void operator()( const size_type , value_type & update ) const
{
long offset ;
offset = -1 ;
for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
{
const long j = & left( i0, i1 ) -
& left( 0, 0 );
if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
offset = j ;
}
offset = -1 ;
for ( unsigned i0 = 0 ; i0 < unsigned(right.dimension_0()) ; ++i0 )
for ( unsigned i1 = 0 ; i1 < unsigned(right.dimension_1()) ; ++i1 )
{
const long j = & right( i0, i1 ) -
& right( 0, 0 );
if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
offset = j ;
}
#if KOKKOS_USING_EXP_VIEW
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
for ( unsigned i1 = 0 ; i1 < unsigned(left.dimension_1()) ; ++i1 )
{
if ( & left(i0,i1) != & left(i0,i1,0,0,0,0,0,0) ) { update |= 3 ; }
if ( & right(i0,i1) != & right(i0,i1,0,0,0,0,0,0) ) { update |= 3 ; }
}
#endif
}
};
template< class DataType , class DeviceType >
struct TestViewOperator_LeftAndRight< DataType , DeviceType , 1 >
{
typedef typename DeviceType::execution_space execution_space ;
typedef typename DeviceType::memory_space memory_space ;
typedef typename execution_space::size_type size_type ;
typedef int value_type ;
KOKKOS_INLINE_FUNCTION
static void join( volatile value_type & update ,
const volatile value_type & input )
{ update |= input ; }
KOKKOS_INLINE_FUNCTION
static void init( value_type & update )
{ update = 0 ; }
typedef Kokkos::
View< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutRight, execution_space > right_view ;
typedef Kokkos::
View< DataType, Kokkos::LayoutStride, execution_space > stride_view ;
left_view left ;
right_view right ;
stride_view left_stride ;
stride_view right_stride ;
long left_alloc ;
long right_alloc ;
TestViewOperator_LeftAndRight()
: left( "left" )
, right( "right" )
, left_stride( left )
, right_stride( right )
, left_alloc( allocation_count( left ) )
, right_alloc( allocation_count( right ) )
{}
static void testit()
{
TestViewOperator_LeftAndRight driver ;
int error_flag = 0 ;
Kokkos::parallel_reduce( 1 , driver , error_flag );
ASSERT_EQ( error_flag , 0 );
}
KOKKOS_INLINE_FUNCTION
void operator()( const size_type , value_type & update ) const
{
for ( unsigned i0 = 0 ; i0 < unsigned(left.dimension_0()) ; ++i0 )
{
#if KOKKOS_USING_EXP_VIEW
if ( & left(i0) != & left(i0,0,0,0,0,0,0,0) ) { update |= 3 ; }
if ( & right(i0) != & right(i0,0,0,0,0,0,0,0) ) { update |= 3 ; }
#endif
if ( & left(i0) != & left_stride(i0) ) { update |= 4 ; }
if ( & right(i0) != & right_stride(i0) ) { update |= 8 ; }
}
}
};
template<class Layout, class DeviceType>
struct TestViewMirror {
template<class MemoryTraits>
void static test_mirror() {
Kokkos::View<double*, Layout, Kokkos::HostSpace> a_org("A",1000);
Kokkos::View<double*, Layout, Kokkos::HostSpace, MemoryTraits> a_h = a_org;
auto a_h2 = Kokkos::create_mirror(Kokkos::HostSpace(),a_h);
auto a_d = Kokkos::create_mirror(DeviceType(),a_h);
int equal_ptr_h_h2 = (a_h.data() ==a_h2.data())?1:0;
int equal_ptr_h_d = (a_h.data() ==a_d. data())?1:0;
int equal_ptr_h2_d = (a_h2.data()==a_d. data())?1:0;
ASSERT_EQ(equal_ptr_h_h2,0);
ASSERT_EQ(equal_ptr_h_d ,0);
ASSERT_EQ(equal_ptr_h2_d,0);
ASSERT_EQ(a_h.dimension_0(),a_h2.dimension_0());
ASSERT_EQ(a_h.dimension_0(),a_d .dimension_0());
}
template<class MemoryTraits>
void static test_mirror_view() {
Kokkos::View<double*, Layout, Kokkos::HostSpace> a_org("A",1000);
Kokkos::View<double*, Layout, Kokkos::HostSpace, MemoryTraits> a_h = a_org;
auto a_h2 = Kokkos::create_mirror_view(Kokkos::HostSpace(),a_h);
auto a_d = Kokkos::create_mirror_view(DeviceType(),a_h);
int equal_ptr_h_h2 = a_h.data() ==a_h2.data()?1:0;
int equal_ptr_h_d = a_h.data() ==a_d. data()?1:0;
int equal_ptr_h2_d = a_h2.data()==a_d. data()?1:0;
int is_same_memspace = std::is_same<Kokkos::HostSpace,typename DeviceType::memory_space>::value?1:0;
ASSERT_EQ(equal_ptr_h_h2,1);
ASSERT_EQ(equal_ptr_h_d ,is_same_memspace);
ASSERT_EQ(equal_ptr_h2_d ,is_same_memspace);
ASSERT_EQ(a_h.dimension_0(),a_h2.dimension_0());
ASSERT_EQ(a_h.dimension_0(),a_d .dimension_0());
}
void static testit() {
test_mirror<Kokkos::MemoryTraits<0>>();
test_mirror<Kokkos::MemoryTraits<Kokkos::Unmanaged>>();
test_mirror_view<Kokkos::MemoryTraits<0>>();
test_mirror_view<Kokkos::MemoryTraits<Kokkos::Unmanaged>>();
}
};
/*--------------------------------------------------------------------------*/
template< typename T, class DeviceType >
class TestViewAPI
{
public:
typedef DeviceType device ;
enum { N0 = 1000 ,
N1 = 3 ,
N2 = 5 ,
N3 = 7 };
typedef Kokkos::View< T , device > dView0 ;
typedef Kokkos::View< T* , device > dView1 ;
typedef Kokkos::View< T*[N1] , device > dView2 ;
typedef Kokkos::View< T*[N1][N2] , device > dView3 ;
typedef Kokkos::View< T*[N1][N2][N3] , device > dView4 ;
typedef Kokkos::View< const T*[N1][N2][N3] , device > const_dView4 ;
typedef Kokkos::View< T****, device, Kokkos::MemoryUnmanaged > dView4_unmanaged ;
typedef typename dView0::host_mirror_space host ;
TestViewAPI()
{
run_test_mirror();
run_test();
run_test_scalar();
run_test_const();
run_test_subview();
run_test_subview_strided();
run_test_vector();
TestViewOperator< T , device >::testit();
TestViewOperator_LeftAndRight< int[2][3][4][2][3][4][2][3] , device >::testit();
TestViewOperator_LeftAndRight< int[2][3][4][2][3][4][2] , device >::testit();
TestViewOperator_LeftAndRight< int[2][3][4][2][3][4] , device >::testit();
TestViewOperator_LeftAndRight< int[2][3][4][2][3] , device >::testit();
TestViewOperator_LeftAndRight< int[2][3][4][2] , device >::testit();
TestViewOperator_LeftAndRight< int[2][3][4] , device >::testit();
TestViewOperator_LeftAndRight< int[2][3] , device >::testit();
TestViewOperator_LeftAndRight< int[2] , device >::testit();
TestViewMirror<Kokkos::LayoutLeft, device >::testit();
TestViewMirror<Kokkos::LayoutRight, device >::testit();
}
static void run_test_mirror()
{
typedef Kokkos::View< int , host > view_type ;
typedef typename view_type::HostMirror mirror_type ;
static_assert( std::is_same< typename view_type::memory_space
, typename mirror_type::memory_space
>::value , "" );
view_type a("a");
mirror_type am = Kokkos::create_mirror_view(a);
mirror_type ax = Kokkos::create_mirror(a);
ASSERT_EQ( & a() , & am() );
}
static void run_test_scalar()
{
typedef typename dView0::HostMirror hView0 ;
dView0 dx , dy ;
hView0 hx , hy ;
dx = dView0( "dx" );
dy = dView0( "dy" );
hx = Kokkos::create_mirror( dx );
hy = Kokkos::create_mirror( dy );
hx() = 1 ;
Kokkos::deep_copy( dx , hx );
Kokkos::deep_copy( dy , dx );
Kokkos::deep_copy( hy , dy );
ASSERT_EQ( hx(), hy() );
}
static void run_test()
{
// mfh 14 Feb 2014: This test doesn't actually create instances of
// these types. In order to avoid "declared but unused typedef"
// warnings, we declare empty instances of these types, with the
// usual "(void)" marker to avoid compiler warnings for unused
// variables.
typedef typename dView0::HostMirror hView0 ;
typedef typename dView1::HostMirror hView1 ;
typedef typename dView2::HostMirror hView2 ;
typedef typename dView3::HostMirror hView3 ;
typedef typename dView4::HostMirror hView4 ;
{
hView0 thing;
(void) thing;
}
{
hView1 thing;
(void) thing;
}
{
hView2 thing;
(void) thing;
}
{
hView3 thing;
(void) thing;
}
{
hView4 thing;
(void) thing;
}
dView4 dx , dy , dz ;
hView4 hx , hy , hz ;
ASSERT_TRUE( dx.ptr_on_device() == 0 );
ASSERT_TRUE( dy.ptr_on_device() == 0 );
ASSERT_TRUE( dz.ptr_on_device() == 0 );
ASSERT_TRUE( hx.ptr_on_device() == 0 );
ASSERT_TRUE( hy.ptr_on_device() == 0 );
ASSERT_TRUE( hz.ptr_on_device() == 0 );
ASSERT_EQ( dx.dimension_0() , 0u );
ASSERT_EQ( dy.dimension_0() , 0u );
ASSERT_EQ( dz.dimension_0() , 0u );
ASSERT_EQ( hx.dimension_0() , 0u );
ASSERT_EQ( hy.dimension_0() , 0u );
ASSERT_EQ( hz.dimension_0() , 0u );
ASSERT_EQ( dx.dimension_1() , unsigned(N1) );
ASSERT_EQ( dy.dimension_1() , unsigned(N1) );
ASSERT_EQ( dz.dimension_1() , unsigned(N1) );
ASSERT_EQ( hx.dimension_1() , unsigned(N1) );
ASSERT_EQ( hy.dimension_1() , unsigned(N1) );
ASSERT_EQ( hz.dimension_1() , unsigned(N1) );
dx = dView4( "dx" , N0 );
dy = dView4( "dy" , N0 );
#if KOKKOS_USING_EXP_VIEW
ASSERT_EQ( dx.use_count() , size_t(1) );
#else
ASSERT_EQ( dx.tracker().ref_count() , size_t(1) );
#endif
dView4_unmanaged unmanaged_dx = dx;
#if KOKKOS_USING_EXP_VIEW
ASSERT_EQ( dx.use_count() , size_t(1) );
#else
ASSERT_EQ( dx.tracker().ref_count() , size_t(1) );
#endif
dView4_unmanaged unmanaged_from_ptr_dx = dView4_unmanaged(dx.ptr_on_device(),
dx.dimension_0(),
dx.dimension_1(),
dx.dimension_2(),
dx.dimension_3());
{
// Destruction of this view should be harmless
const_dView4 unmanaged_from_ptr_const_dx( dx.ptr_on_device() ,
dx.dimension_0() ,
dx.dimension_1() ,
dx.dimension_2() ,
dx.dimension_3() );
}
const_dView4 const_dx = dx ;
#if KOKKOS_USING_EXP_VIEW
ASSERT_EQ( dx.use_count() , size_t(2) );
#else
ASSERT_EQ( dx.tracker().ref_count() , size_t(2) );
#endif
{
const_dView4 const_dx2;
const_dx2 = const_dx;
#if KOKKOS_USING_EXP_VIEW
ASSERT_EQ( dx.use_count() , size_t(3) );
#else
ASSERT_EQ( dx.tracker().ref_count() , size_t(3) );
#endif
const_dx2 = dy;
#if KOKKOS_USING_EXP_VIEW
ASSERT_EQ( dx.use_count() , size_t(2) );
#else
ASSERT_EQ( dx.tracker().ref_count() , size_t(2) );
#endif
const_dView4 const_dx3(dx);
#if KOKKOS_USING_EXP_VIEW
ASSERT_EQ( dx.use_count() , size_t(3) );
#else
ASSERT_EQ( dx.tracker().ref_count() , size_t(3) );
#endif
dView4_unmanaged dx4_unmanaged(dx);
#if KOKKOS_USING_EXP_VIEW
ASSERT_EQ( dx.use_count() , size_t(3) );
#else
ASSERT_EQ( dx.tracker().ref_count() , size_t(3) );
#endif
}
#if KOKKOS_USING_EXP_VIEW
ASSERT_EQ( dx.use_count() , size_t(2) );
#else
ASSERT_EQ( dx.tracker().ref_count() , size_t(2) );
#endif
ASSERT_FALSE( dx.ptr_on_device() == 0 );
ASSERT_FALSE( const_dx.ptr_on_device() == 0 );
ASSERT_FALSE( unmanaged_dx.ptr_on_device() == 0 );
ASSERT_FALSE( unmanaged_from_ptr_dx.ptr_on_device() == 0 );
ASSERT_FALSE( dy.ptr_on_device() == 0 );
ASSERT_NE( dx , dy );
ASSERT_EQ( dx.dimension_0() , unsigned(N0) );
ASSERT_EQ( dx.dimension_1() , unsigned(N1) );
ASSERT_EQ( dx.dimension_2() , unsigned(N2) );
ASSERT_EQ( dx.dimension_3() , unsigned(N3) );
ASSERT_EQ( dy.dimension_0() , unsigned(N0) );
ASSERT_EQ( dy.dimension_1() , unsigned(N1) );
ASSERT_EQ( dy.dimension_2() , unsigned(N2) );
ASSERT_EQ( dy.dimension_3() , unsigned(N3) );
ASSERT_EQ( unmanaged_from_ptr_dx.capacity(),unsigned(N0)*unsigned(N1)*unsigned(N2)*unsigned(N3) );
hx = Kokkos::create_mirror( dx );
hy = Kokkos::create_mirror( dy );
// T v1 = hx() ; // Generates compile error as intended
// T v2 = hx(0,0) ; // Generates compile error as intended
// hx(0,0) = v2 ; // Generates compile error as intended
#if ! KOKKOS_USING_EXP_VIEW
// Testing with asynchronous deep copy with respect to device
{
size_t count = 0 ;
for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
for ( size_t i1 = 0 ; i1 < hx.dimension_1() ; ++i1 ) {
for ( size_t i2 = 0 ; i2 < hx.dimension_2() ; ++i2 ) {
for ( size_t i3 = 0 ; i3 < hx.dimension_3() ; ++i3 ) {
hx(ip,i1,i2,i3) = ++count ;
}}}}
Kokkos::deep_copy(typename hView4::execution_space(), dx , hx );
Kokkos::deep_copy(typename hView4::execution_space(), dy , dx );
Kokkos::deep_copy(typename hView4::execution_space(), hy , dy );
for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
{ ASSERT_EQ( hx(ip,i1,i2,i3) , hy(ip,i1,i2,i3) ); }
}}}}
Kokkos::deep_copy(typename hView4::execution_space(), dx , T(0) );
Kokkos::deep_copy(typename hView4::execution_space(), hx , dx );
for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
{ ASSERT_EQ( hx(ip,i1,i2,i3) , T(0) ); }
}}}}
}
// Testing with asynchronous deep copy with respect to host
{
size_t count = 0 ;
for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
for ( size_t i1 = 0 ; i1 < hx.dimension_1() ; ++i1 ) {
for ( size_t i2 = 0 ; i2 < hx.dimension_2() ; ++i2 ) {
for ( size_t i3 = 0 ; i3 < hx.dimension_3() ; ++i3 ) {
hx(ip,i1,i2,i3) = ++count ;
}}}}
Kokkos::deep_copy(typename dView4::execution_space(), dx , hx );
Kokkos::deep_copy(typename dView4::execution_space(), dy , dx );
Kokkos::deep_copy(typename dView4::execution_space(), hy , dy );
for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
{ ASSERT_EQ( hx(ip,i1,i2,i3) , hy(ip,i1,i2,i3) ); }
}}}}
Kokkos::deep_copy(typename dView4::execution_space(), dx , T(0) );
Kokkos::deep_copy(typename dView4::execution_space(), hx , dx );
for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
{ ASSERT_EQ( hx(ip,i1,i2,i3) , T(0) ); }
}}}}
}
#endif /* #if ! KOKKOS_USING_EXP_VIEW */
// Testing with synchronous deep copy
{
size_t count = 0 ;
for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
for ( size_t i1 = 0 ; i1 < hx.dimension_1() ; ++i1 ) {
for ( size_t i2 = 0 ; i2 < hx.dimension_2() ; ++i2 ) {
for ( size_t i3 = 0 ; i3 < hx.dimension_3() ; ++i3 ) {
hx(ip,i1,i2,i3) = ++count ;
}}}}
Kokkos::deep_copy( dx , hx );
Kokkos::deep_copy( dy , dx );
Kokkos::deep_copy( hy , dy );
for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
{ ASSERT_EQ( hx(ip,i1,i2,i3) , hy(ip,i1,i2,i3) ); }
}}}}
Kokkos::deep_copy( dx , T(0) );
Kokkos::deep_copy( hx , dx );
for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
{ ASSERT_EQ( hx(ip,i1,i2,i3) , T(0) ); }
}}}}
}
dz = dx ; ASSERT_EQ( dx, dz); ASSERT_NE( dy, dz);
dz = dy ; ASSERT_EQ( dy, dz); ASSERT_NE( dx, dz);
dx = dView4();
ASSERT_TRUE( dx.ptr_on_device() == 0 );
ASSERT_FALSE( dy.ptr_on_device() == 0 );
ASSERT_FALSE( dz.ptr_on_device() == 0 );
dy = dView4();
ASSERT_TRUE( dx.ptr_on_device() == 0 );
ASSERT_TRUE( dy.ptr_on_device() == 0 );
ASSERT_FALSE( dz.ptr_on_device() == 0 );
dz = dView4();
ASSERT_TRUE( dx.ptr_on_device() == 0 );
ASSERT_TRUE( dy.ptr_on_device() == 0 );
ASSERT_TRUE( dz.ptr_on_device() == 0 );
}
typedef T DataType[2] ;
static void
check_auto_conversion_to_const(
const Kokkos::View< const DataType , device > & arg_const ,
const Kokkos::View< DataType , device > & arg )
{
ASSERT_TRUE( arg_const == arg );
}
static void run_test_const()
{
typedef Kokkos::View< DataType , device > typeX ;
typedef Kokkos::View< const DataType , device > const_typeX ;
typedef Kokkos::View< const DataType , device , Kokkos::MemoryRandomAccess > const_typeR ;
typeX x( "X" );
const_typeX xc = x ;
const_typeR xr = x ;
ASSERT_TRUE( xc == x );
ASSERT_TRUE( x == xc );
// For CUDA the constant random access View does not return
// an lvalue reference due to retrieving through texture cache
// therefore not allowed to query the underlying pointer.
#if defined( KOKKOS_HAVE_CUDA )
if ( ! std::is_same< typename device::execution_space , Kokkos::Cuda >::value )
#endif
{
ASSERT_TRUE( x.ptr_on_device() == xr.ptr_on_device() );
}
// typeX xf = xc ; // setting non-const from const must not compile
check_auto_conversion_to_const( x , x );
}
static void run_test_subview()
{
typedef Kokkos::View< const T , device > sView ;
dView0 d0( "d0" );
dView1 d1( "d1" , N0 );
dView2 d2( "d2" , N0 );
dView3 d3( "d3" , N0 );
dView4 d4( "d4" , N0 );
sView s0 = d0 ;
sView s1 = Kokkos::subview( d1 , 1 );
sView s2 = Kokkos::subview( d2 , 1 , 1 );
sView s3 = Kokkos::subview( d3 , 1 , 1 , 1 );
sView s4 = Kokkos::subview( d4 , 1 , 1 , 1 , 1 );
}
static void run_test_subview_strided()
{
typedef Kokkos::View< int **** , Kokkos::LayoutLeft , host > view_left_4 ;
typedef Kokkos::View< int **** , Kokkos::LayoutRight , host > view_right_4 ;
typedef Kokkos::View< int ** , Kokkos::LayoutLeft , host > view_left_2 ;
typedef Kokkos::View< int ** , Kokkos::LayoutRight , host > view_right_2 ;
typedef Kokkos::View< int * , Kokkos::LayoutStride , host > view_stride_1 ;
typedef Kokkos::View< int ** , Kokkos::LayoutStride , host > view_stride_2 ;
view_left_2 xl2("xl2", 100 , 200 );
view_right_2 xr2("xr2", 100 , 200 );
view_stride_1 yl1 = Kokkos::subview( xl2 , 0 , Kokkos::ALL() );
view_stride_1 yl2 = Kokkos::subview( xl2 , 1 , Kokkos::ALL() );
view_stride_1 yr1 = Kokkos::subview( xr2 , 0 , Kokkos::ALL() );
view_stride_1 yr2 = Kokkos::subview( xr2 , 1 , Kokkos::ALL() );
ASSERT_EQ( yl1.dimension_0() , xl2.dimension_1() );
ASSERT_EQ( yl2.dimension_0() , xl2.dimension_1() );
ASSERT_EQ( yr1.dimension_0() , xr2.dimension_1() );
ASSERT_EQ( yr2.dimension_0() , xr2.dimension_1() );
ASSERT_EQ( & yl1(0) - & xl2(0,0) , 0 );
ASSERT_EQ( & yl2(0) - & xl2(1,0) , 0 );
ASSERT_EQ( & yr1(0) - & xr2(0,0) , 0 );
ASSERT_EQ( & yr2(0) - & xr2(1,0) , 0 );
view_left_4 xl4( "xl4" , 10 , 20 , 30 , 40 );
view_right_4 xr4( "xr4" , 10 , 20 , 30 , 40 );
view_stride_2 yl4 = Kokkos::subview( xl4 , 1 , Kokkos::ALL() , 2 , Kokkos::ALL() );
view_stride_2 yr4 = Kokkos::subview( xr4 , 1 , Kokkos::ALL() , 2 , Kokkos::ALL() );
ASSERT_EQ( yl4.dimension_0() , xl4.dimension_1() );
ASSERT_EQ( yl4.dimension_1() , xl4.dimension_3() );
ASSERT_EQ( yr4.dimension_0() , xr4.dimension_1() );
ASSERT_EQ( yr4.dimension_1() , xr4.dimension_3() );
ASSERT_EQ( & yl4(4,4) - & xl4(1,4,2,4) , 0 );
ASSERT_EQ( & yr4(4,4) - & xr4(1,4,2,4) , 0 );
}
static void run_test_vector()
{
static const unsigned Length = 1000 , Count = 8 ;
typedef Kokkos::View< T* , Kokkos::LayoutLeft , host > vector_type ;
typedef Kokkos::View< T** , Kokkos::LayoutLeft , host > multivector_type ;
typedef Kokkos::View< T* , Kokkos::LayoutRight , host > vector_right_type ;
typedef Kokkos::View< T** , Kokkos::LayoutRight , host > multivector_right_type ;
typedef Kokkos::View< const T* , Kokkos::LayoutRight, host > const_vector_right_type ;
typedef Kokkos::View< const T* , Kokkos::LayoutLeft , host > const_vector_type ;
typedef Kokkos::View< const T** , Kokkos::LayoutLeft , host > const_multivector_type ;
multivector_type mv = multivector_type( "mv" , Length , Count );
multivector_right_type mv_right = multivector_right_type( "mv" , Length , Count );
vector_type v1 = Kokkos::subview( mv , Kokkos::ALL() , 0 );
vector_type v2 = Kokkos::subview( mv , Kokkos::ALL() , 1 );
vector_type v3 = Kokkos::subview( mv , Kokkos::ALL() , 2 );
vector_type rv1 = Kokkos::subview( mv_right , 0 , Kokkos::ALL() );
vector_type rv2 = Kokkos::subview( mv_right , 1 , Kokkos::ALL() );
vector_type rv3 = Kokkos::subview( mv_right , 2 , Kokkos::ALL() );
multivector_type mv1 = Kokkos::subview( mv , std::make_pair( 1 , 998 ) ,
std::make_pair( 2 , 5 ) );
multivector_right_type mvr1 =
Kokkos::subview( mv_right ,
std::make_pair( 1 , 998 ) ,
std::make_pair( 2 , 5 ) );
const_vector_type cv1 = Kokkos::subview( mv , Kokkos::ALL(), 0 );
const_vector_type cv2 = Kokkos::subview( mv , Kokkos::ALL(), 1 );
const_vector_type cv3 = Kokkos::subview( mv , Kokkos::ALL(), 2 );
vector_right_type vr1 = Kokkos::subview( mv , Kokkos::ALL() , 0 );
vector_right_type vr2 = Kokkos::subview( mv , Kokkos::ALL() , 1 );
vector_right_type vr3 = Kokkos::subview( mv , Kokkos::ALL() , 2 );
const_vector_right_type cvr1 = Kokkos::subview( mv , Kokkos::ALL() , 0 );
const_vector_right_type cvr2 = Kokkos::subview( mv , Kokkos::ALL() , 1 );
const_vector_right_type cvr3 = Kokkos::subview( mv , Kokkos::ALL() , 2 );
ASSERT_TRUE( & v1[0] == & v1(0) );
ASSERT_TRUE( & v1[0] == & mv(0,0) );
ASSERT_TRUE( & v2[0] == & mv(0,1) );
ASSERT_TRUE( & v3[0] == & mv(0,2) );
ASSERT_TRUE( & cv1[0] == & mv(0,0) );
ASSERT_TRUE( & cv2[0] == & mv(0,1) );
ASSERT_TRUE( & cv3[0] == & mv(0,2) );
ASSERT_TRUE( & vr1[0] == & mv(0,0) );
ASSERT_TRUE( & vr2[0] == & mv(0,1) );
ASSERT_TRUE( & vr3[0] == & mv(0,2) );
ASSERT_TRUE( & cvr1[0] == & mv(0,0) );
ASSERT_TRUE( & cvr2[0] == & mv(0,1) );
ASSERT_TRUE( & cvr3[0] == & mv(0,2) );
ASSERT_TRUE( & mv1(0,0) == & mv( 1 , 2 ) );
ASSERT_TRUE( & mv1(1,1) == & mv( 2 , 3 ) );
ASSERT_TRUE( & mv1(3,2) == & mv( 4 , 4 ) );
ASSERT_TRUE( & mvr1(0,0) == & mv_right( 1 , 2 ) );
ASSERT_TRUE( & mvr1(1,1) == & mv_right( 2 , 3 ) );
ASSERT_TRUE( & mvr1(3,2) == & mv_right( 4 , 4 ) );
const_vector_type c_cv1( v1 );
typename vector_type::const_type c_cv2( v2 );
typename const_vector_type::const_type c_ccv2( v2 );
const_multivector_type cmv( mv );
typename multivector_type::const_type cmvX( cmv );
typename const_multivector_type::const_type ccmvX( cmv );
}
};
} // namespace Test
/*--------------------------------------------------------------------------*/
Event Timeline
Log In to Comment