ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update Kokkos library to v2.7.00

Browse Source
This commit is contained in:
Stan Moore
2018-05-25 15:00:53 -06:00
parent ce4a446cea
commit 1422b0413b
1248 changed files with 64103 additions and 5133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

879
lib/kokkos/core/unit_test/TestReduce.hpp
View File

@ -233,7 +233,6 @@ public:
}
};
} // namespace Test
namespace {
@ -471,875 +470,6 @@ public:
} // namespace
//--------------------------------------------------------------------------
namespace Test {
struct ReducerTag {};
template< class Scalar, class ExecSpace = Kokkos::DefaultExecutionSpace >
struct TestReducers {
struct SumFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, Scalar & value ) const {
value += values( i );
}
};
struct ProdFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, Scalar & value ) const {
value *= values( i );
}
};
struct MinFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, Scalar & value ) const {
if ( values( i ) < value ) value = values( i );
}
};
struct MaxFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, Scalar & value ) const {
if ( values( i ) > value ) value = values( i );
}
};
struct MinLocFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, typename Kokkos::Experimental::MinLoc< Scalar, int >::value_type & value ) const {
if ( values( i ) < value.val ) {
value.val = values( i );
value.loc = i;
}
}
};
struct MaxLocFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, typename Kokkos::Experimental::MaxLoc< Scalar, int >::value_type & value ) const {
if ( values( i ) > value.val ) {
value.val = values( i );
value.loc = i;
}
}
};
struct MinMaxLocFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, typename Kokkos::Experimental::MinMaxLoc< Scalar, int >::value_type & value ) const {
if ( values( i ) > value.max_val ) {
value.max_val = values( i );
value.max_loc = i;
}
if ( values( i ) < value.min_val ) {
value.min_val = values( i );
value.min_loc = i;
}
}
};
struct BAndFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, Scalar & value ) const {
value = value & values( i );
}
};
struct BOrFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, Scalar & value ) const {
value = value | values( i );
}
};
struct LAndFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, Scalar & value ) const {
value = value && values( i );
}
};
struct LOrFunctor {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const int & i, Scalar & value ) const {
value = value || values( i );
}
};
struct SumFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, Scalar & value ) const {
value += values( i );
}
};
struct ProdFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, Scalar & value ) const {
value *= values( i );
}
};
struct MinFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, Scalar & value ) const {
if ( values( i ) < value ) value = values( i );
}
};
struct MaxFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, Scalar & value ) const {
if ( values( i ) > value ) value = values( i );
}
};
struct MinLocFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, typename Kokkos::Experimental::MinLoc< Scalar, int >::value_type & value ) const {
if ( values( i ) < value.val ) {
value.val = values( i );
value.loc = i;
}
}
};
struct MaxLocFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, typename Kokkos::Experimental::MaxLoc< Scalar, int >::value_type & value ) const {
if ( values( i ) > value.val ) {
value.val = values( i );
value.loc = i;
}
}
};
struct MinMaxLocFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, typename Kokkos::Experimental::MinMaxLoc< Scalar, int >::value_type & value ) const {
if ( values( i ) > value.max_val ) {
value.max_val = values( i );
value.max_loc = i;
}
if ( values( i ) < value.min_val ) {
value.min_val = values( i );
value.min_loc = i;
}
}
};
struct BAndFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, Scalar & value ) const {
value = value & values( i );
}
};
struct BOrFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, Scalar & value ) const {
value = value | values( i );
}
};
struct LAndFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, Scalar & value ) const {
value = value && values( i );
}
};
struct LOrFunctorTag {
Kokkos::View< const Scalar*, ExecSpace > values;
KOKKOS_INLINE_FUNCTION
void operator()( const ReducerTag, const int & i, Scalar & value ) const {
value = value || values( i );
}
};
static void test_sum( int N ) {
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_sum = 0;
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 100 );
reference_sum += h_values( i );
}
Kokkos::deep_copy( values, h_values );
SumFunctor f;
f.values = values;
SumFunctorTag f_tag;
f_tag.values = values;
Scalar init = 0;
{
Scalar sum_scalar = init;
Kokkos::Experimental::Sum< Scalar > reducer_scalar( sum_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( sum_scalar, reference_sum );
sum_scalar = init;
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( sum_scalar, reference_sum );
Scalar sum_scalar_view = reducer_scalar.reference();
ASSERT_EQ( sum_scalar_view, reference_sum );
}
{
Kokkos::View< Scalar, Kokkos::HostSpace> sum_view( "View" );
sum_view() = init;
Kokkos::Experimental::Sum< Scalar > reducer_view( sum_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
Scalar sum_view_scalar = sum_view();
ASSERT_EQ( sum_view_scalar, reference_sum );
Scalar sum_view_view = reducer_view.reference();
ASSERT_EQ( sum_view_view, reference_sum );
}
}
static void test_prod( int N ) {
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_prod = 1;
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 4 + 1 );
reference_prod *= h_values( i );
}
Kokkos::deep_copy( values, h_values );
ProdFunctor f;
f.values = values;
ProdFunctorTag f_tag;
f_tag.values = values;
Scalar init = 1;
{
Scalar prod_scalar = init;
Kokkos::Experimental::Prod< Scalar > reducer_scalar( prod_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( prod_scalar, reference_prod );
prod_scalar = init;
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( prod_scalar, reference_prod );
Scalar prod_scalar_view = reducer_scalar.reference();
ASSERT_EQ( prod_scalar_view, reference_prod );
}
{
Kokkos::View< Scalar, Kokkos::HostSpace > prod_view( "View" );
prod_view() = init;
Kokkos::Experimental::Prod< Scalar > reducer_view( prod_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
Scalar prod_view_scalar = prod_view();
ASSERT_EQ( prod_view_scalar, reference_prod );
Scalar prod_view_view = reducer_view.reference();
ASSERT_EQ( prod_view_view, reference_prod );
}
}
static void test_min( int N ) {
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_min = std::numeric_limits< Scalar >::max();
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 100000 );
if ( h_values( i ) < reference_min ) reference_min = h_values( i );
}
Kokkos::deep_copy( values, h_values );
MinFunctor f;
f.values = values;
MinFunctorTag f_tag;
f_tag.values = values;
Scalar init = std::numeric_limits< Scalar >::max();
{
Scalar min_scalar = init;
Kokkos::Experimental::Min< Scalar > reducer_scalar( min_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( min_scalar, reference_min );
min_scalar = init;
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( min_scalar, reference_min );
Scalar min_scalar_view = reducer_scalar.reference();
ASSERT_EQ( min_scalar_view, reference_min );
}
{
Kokkos::View< Scalar, Kokkos::HostSpace > min_view( "View" );
min_view() = init;
Kokkos::Experimental::Min< Scalar > reducer_view( min_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
Scalar min_view_scalar = min_view();
ASSERT_EQ( min_view_scalar, reference_min );
Scalar min_view_view = reducer_view.reference();
ASSERT_EQ( min_view_view, reference_min );
}
}
static void test_max( int N ) {
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_max = std::numeric_limits< Scalar >::min();
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 100000 + 1 );
if ( h_values( i ) > reference_max ) reference_max = h_values( i );
}
Kokkos::deep_copy( values, h_values );
MaxFunctor f;
f.values = values;
MaxFunctorTag f_tag;
f_tag.values = values;
Scalar init = std::numeric_limits< Scalar >::min();
{
Scalar max_scalar = init;
Kokkos::Experimental::Max< Scalar > reducer_scalar( max_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( max_scalar, reference_max );
max_scalar = init;
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( max_scalar, reference_max );
Scalar max_scalar_view = reducer_scalar.reference();
ASSERT_EQ( max_scalar_view, reference_max );
}
{
Kokkos::View< Scalar, Kokkos::HostSpace > max_view( "View" );
max_view() = init;
Kokkos::Experimental::Max< Scalar > reducer_view( max_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
Scalar max_view_scalar = max_view();
ASSERT_EQ( max_view_scalar, reference_max );
Scalar max_view_view = reducer_view.reference();
ASSERT_EQ( max_view_view, reference_max );
}
}
static void test_minloc( int N ) {
typedef typename Kokkos::Experimental::MinLoc< Scalar, int >::value_type value_type;
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_min = std::numeric_limits< Scalar >::max();
int reference_loc = -1;
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 100000 );
if ( h_values( i ) < reference_min ) {
reference_min = h_values( i );
reference_loc = i;
}
else if ( h_values( i ) == reference_min ) {
// Make min unique.
h_values( i ) += std::numeric_limits< Scalar >::epsilon();
}
}
Kokkos::deep_copy( values, h_values );
MinLocFunctor f;
f.values = values;
MinLocFunctorTag f_tag;
f_tag.values = values;
{
value_type min_scalar;
Kokkos::Experimental::MinLoc< Scalar, int > reducer_scalar( min_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( min_scalar.val, reference_min );
ASSERT_EQ( min_scalar.loc, reference_loc );
min_scalar = value_type();
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( min_scalar.val, reference_min );
ASSERT_EQ( min_scalar.loc, reference_loc );
value_type min_scalar_view = reducer_scalar.reference();
ASSERT_EQ( min_scalar_view.val, reference_min );
ASSERT_EQ( min_scalar_view.loc, reference_loc );
}
{
Kokkos::View< value_type, Kokkos::HostSpace > min_view( "View" );
Kokkos::Experimental::MinLoc< Scalar, int > reducer_view( min_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
value_type min_view_scalar = min_view();
ASSERT_EQ( min_view_scalar.val, reference_min );
ASSERT_EQ( min_view_scalar.loc, reference_loc );
value_type min_view_view = reducer_view.reference();
ASSERT_EQ( min_view_view.val, reference_min );
ASSERT_EQ( min_view_view.loc, reference_loc );
}
}
static void test_maxloc( int N ) {
typedef typename Kokkos::Experimental::MaxLoc< Scalar, int >::value_type value_type;
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_max = std::numeric_limits< Scalar >::min();
int reference_loc = -1;
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 100000 );
if ( h_values( i ) > reference_max ) {
reference_max = h_values( i );
reference_loc = i;
}
else if ( h_values( i ) == reference_max ) {
// Make max unique.
h_values( i ) -= std::numeric_limits< Scalar >::epsilon();
}
}
Kokkos::deep_copy( values, h_values );
MaxLocFunctor f;
f.values = values;
MaxLocFunctorTag f_tag;
f_tag.values = values;
{
value_type max_scalar;
Kokkos::Experimental::MaxLoc< Scalar, int > reducer_scalar( max_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( max_scalar.val, reference_max );
ASSERT_EQ( max_scalar.loc, reference_loc );
max_scalar = value_type();
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( max_scalar.val, reference_max );
ASSERT_EQ( max_scalar.loc, reference_loc );
value_type max_scalar_view = reducer_scalar.reference();
ASSERT_EQ( max_scalar_view.val, reference_max );
ASSERT_EQ( max_scalar_view.loc, reference_loc );
}
{
Kokkos::View< value_type, Kokkos::HostSpace > max_view( "View" );
Kokkos::Experimental::MaxLoc< Scalar, int > reducer_view( max_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
value_type max_view_scalar = max_view();
ASSERT_EQ( max_view_scalar.val, reference_max );
ASSERT_EQ( max_view_scalar.loc, reference_loc );
value_type max_view_view = reducer_view.reference();
ASSERT_EQ( max_view_view.val, reference_max );
ASSERT_EQ( max_view_view.loc, reference_loc );
}
}
static void test_minmaxloc( int N ) {
typedef typename Kokkos::Experimental::MinMaxLoc< Scalar, int >::value_type value_type;
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_max = std::numeric_limits< Scalar >::min();
Scalar reference_min = std::numeric_limits< Scalar >::max();
int reference_minloc = -1;
int reference_maxloc = -1;
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 100000 );
}
for ( int i = 0; i < N; i++ ) {
if ( h_values( i ) > reference_max ) {
reference_max = h_values( i );
reference_maxloc = i;
}
else if ( h_values( i ) == reference_max ) {
// Make max unique.
h_values( i ) -= std::numeric_limits< Scalar >::epsilon();
}
}
for ( int i = 0; i < N; i++ ) {
if ( h_values( i ) < reference_min ) {
reference_min = h_values( i );
reference_minloc = i;
}
else if ( h_values( i ) == reference_min ) {
// Make min unique.
h_values( i ) += std::numeric_limits< Scalar >::epsilon();
}
}
Kokkos::deep_copy( values, h_values );
MinMaxLocFunctor f;
f.values = values;
MinMaxLocFunctorTag f_tag;
f_tag.values = values;
{
value_type minmax_scalar;
Kokkos::Experimental::MinMaxLoc< Scalar, int > reducer_scalar( minmax_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( minmax_scalar.min_val, reference_min );
for ( int i = 0; i < N; i++ ) {
if ( ( i == minmax_scalar.min_loc ) && ( h_values( i ) == reference_min ) ) {
reference_minloc = i;
}
}
ASSERT_EQ( minmax_scalar.min_loc, reference_minloc );
ASSERT_EQ( minmax_scalar.max_val, reference_max );
for ( int i = 0; i < N; i++ ) {
if ( ( i == minmax_scalar.max_loc ) && ( h_values( i ) == reference_max ) ) {
reference_maxloc = i;
}
}
ASSERT_EQ( minmax_scalar.max_loc, reference_maxloc );
minmax_scalar = value_type();
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( minmax_scalar.min_val, reference_min );
for ( int i = 0; i < N; i++ ) {
if ( ( i == minmax_scalar.min_loc ) && ( h_values( i ) == reference_min ) ) {
reference_minloc = i;
}
}
ASSERT_EQ( minmax_scalar.min_loc, reference_minloc );
ASSERT_EQ( minmax_scalar.max_val, reference_max );
for ( int i = 0; i < N; i++ ) {
if ( ( i == minmax_scalar.max_loc ) && ( h_values( i ) == reference_max ) ) {
reference_maxloc = i;
}
}
ASSERT_EQ( minmax_scalar.max_loc, reference_maxloc );
value_type minmax_scalar_view = reducer_scalar.reference();
ASSERT_EQ( minmax_scalar_view.min_val, reference_min );
ASSERT_EQ( minmax_scalar_view.min_loc, reference_minloc );
ASSERT_EQ( minmax_scalar_view.max_val, reference_max );
ASSERT_EQ( minmax_scalar_view.max_loc, reference_maxloc );
}
{
Kokkos::View< value_type, Kokkos::HostSpace > minmax_view( "View" );
Kokkos::Experimental::MinMaxLoc< Scalar, int > reducer_view( minmax_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
value_type minmax_view_scalar = minmax_view();
ASSERT_EQ( minmax_view_scalar.min_val, reference_min );
ASSERT_EQ( minmax_view_scalar.min_loc, reference_minloc );
ASSERT_EQ( minmax_view_scalar.max_val, reference_max );
ASSERT_EQ( minmax_view_scalar.max_loc, reference_maxloc );
value_type minmax_view_view = reducer_view.reference();
ASSERT_EQ( minmax_view_view.min_val, reference_min );
ASSERT_EQ( minmax_view_view.min_loc, reference_minloc );
ASSERT_EQ( minmax_view_view.max_val, reference_max );
ASSERT_EQ( minmax_view_view.max_loc, reference_maxloc );
}
}
static void test_BAnd( int N ) {
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_band = Scalar() | ( ~Scalar() );
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 100000 + 1 );
reference_band = reference_band & h_values( i );
}
Kokkos::deep_copy( values, h_values );
BAndFunctor f;
f.values = values;
BAndFunctorTag f_tag;
f_tag.values = values;
Scalar init = Scalar() | ( ~Scalar() );
{
Scalar band_scalar = init;
Kokkos::Experimental::BAnd< Scalar > reducer_scalar( band_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( band_scalar, reference_band );
band_scalar = init;
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( band_scalar, reference_band );
Scalar band_scalar_view = reducer_scalar.reference();
ASSERT_EQ( band_scalar_view, reference_band );
}
{
Kokkos::View< Scalar, Kokkos::HostSpace > band_view( "View" );
band_view() = init;
Kokkos::Experimental::BAnd< Scalar > reducer_view( band_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
Scalar band_view_scalar = band_view();
ASSERT_EQ( band_view_scalar, reference_band );
Scalar band_view_view = reducer_view.reference();
ASSERT_EQ( band_view_view, reference_band );
}
}
static void test_BOr( int N ) {
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_bor = Scalar() & ( ~Scalar() );
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( ( rand() % 100000 + 1 ) * 2 );
reference_bor = reference_bor | h_values( i );
}
Kokkos::deep_copy( values, h_values );
BOrFunctor f;
f.values = values;
BOrFunctorTag f_tag;
f_tag.values = values;
Scalar init = Scalar() & ( ~Scalar() );
{
Scalar bor_scalar = init;
Kokkos::Experimental::BOr< Scalar > reducer_scalar( bor_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( bor_scalar, reference_bor );
bor_scalar = init;
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( bor_scalar, reference_bor );
Scalar bor_scalar_view = reducer_scalar.reference();
ASSERT_EQ( bor_scalar_view, reference_bor );
}
{
Kokkos::View< Scalar, Kokkos::HostSpace > bor_view( "View" );
bor_view() = init;
Kokkos::Experimental::BOr< Scalar > reducer_view( bor_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
Scalar bor_view_scalar = bor_view();
ASSERT_EQ( bor_view_scalar, reference_bor );
Scalar bor_view_view = reducer_view.reference();
ASSERT_EQ( bor_view_view, reference_bor );
}
}
static void test_LAnd( int N ) {
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_land = 1;
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 2 );
reference_land = reference_land && h_values( i );
}
Kokkos::deep_copy( values, h_values );
LAndFunctor f;
f.values = values;
LAndFunctorTag f_tag;
f_tag.values = values;
Scalar init = 1;
{
Scalar land_scalar = init;
Kokkos::Experimental::LAnd< Scalar > reducer_scalar( land_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( land_scalar, reference_land );
land_scalar = init;
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( land_scalar, reference_land );
Scalar land_scalar_view = reducer_scalar.reference();
ASSERT_EQ( land_scalar_view, reference_land );
}
{
Kokkos::View< Scalar, Kokkos::HostSpace > land_view( "View" );
land_view() = init;
Kokkos::Experimental::LAnd< Scalar > reducer_view( land_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
Scalar land_view_scalar = land_view();
ASSERT_EQ( land_view_scalar, reference_land );
Scalar land_view_view = reducer_view.reference();
ASSERT_EQ( land_view_view, reference_land );
}
}
static void test_LOr( int N ) {
Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
auto h_values = Kokkos::create_mirror_view( values );
Scalar reference_lor = 0;
for ( int i = 0; i < N; i++ ) {
h_values( i ) = (Scalar) ( rand() % 2 );
reference_lor = reference_lor || h_values( i );
}
Kokkos::deep_copy( values, h_values );
LOrFunctor f;
f.values = values;
LOrFunctorTag f_tag;
f_tag.values = values;
Scalar init = 0;
{
Scalar lor_scalar = init;
Kokkos::Experimental::LOr< Scalar > reducer_scalar( lor_scalar );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
ASSERT_EQ( lor_scalar, reference_lor );
lor_scalar = init;
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
ASSERT_EQ( lor_scalar, reference_lor );
Scalar lor_scalar_view = reducer_scalar.reference();
ASSERT_EQ( lor_scalar_view, reference_lor );
}
{
Kokkos::View< Scalar, Kokkos::HostSpace > lor_view( "View" );
lor_view() = init;
Kokkos::Experimental::LOr< Scalar > reducer_view( lor_view );
Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
Scalar lor_view_scalar = lor_view();
ASSERT_EQ( lor_view_scalar, reference_lor );
Scalar lor_view_view = reducer_view.reference();
ASSERT_EQ( lor_view_view, reference_lor );
}
}
static void execute_float() {
test_sum( 10001 );
test_prod( 35 );
test_min( 10003 );
test_minloc( 10003 );
test_max( 10007 );
test_maxloc( 10007 );
test_minmaxloc( 10007 );
}
static void execute_integer() {
test_sum( 10001 );
test_prod( 35 );
test_min( 10003 );
test_minloc( 10003 );
test_max( 10007 );
test_maxloc( 10007 );
test_minmaxloc( 10007 );
test_BAnd( 35 );
test_BOr( 35 );
test_LAnd( 35 );
test_LOr( 35 );
}
static void execute_basic() {
test_sum( 10001 );
test_prod( 35 );
}
};
TEST_F( TEST_CATEGORY, long_reduce )
{
TestReduce< long, TEST_EXECSPACE >( 0 );
@ -1352,14 +482,6 @@ TEST_F( TEST_CATEGORY, double_reduce )
TestReduce< double, TEST_EXECSPACE >( 1000000 );
}
TEST_F( TEST_CATEGORY, reducers )
{
TestReducers< int, TEST_EXECSPACE >::execute_integer();
TestReducers< size_t, TEST_EXECSPACE >::execute_integer();
TestReducers< double, TEST_EXECSPACE >::execute_float();
TestReducers< Kokkos::complex<double>, TEST_EXECSPACE >::execute_basic();
}
TEST_F( TEST_CATEGORY, long_reduce_dynamic )
{
TestReduceDynamic< long, TEST_EXECSPACE >( 0 );
@ -1377,4 +499,5 @@ TEST_F( TEST_CATEGORY, long_reduce_dynamic_view )
TestReduceDynamicView< long, TEST_EXECSPACE >( 0 );
TestReduceDynamicView< long, TEST_EXECSPACE >( 1000000 );
}
} // namespace Test