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

Update Kokkos library in LAMMPS to v3.0

Browse Source
This commit is contained in:
Stan Moore
2020-03-25 14:08:39 -06:00
parent 0252d8c210
commit 60864e38d1
2169 changed files with 121406 additions and 126492 deletions
Download Patch File Download Diff File Expand all files Collapse all files

247
lib/kokkos/containers/unit_tests/TestDynamicView.hpp
View File

@ -1,13 +1,14 @@
/*
//@HEADER
// ************************************************************************
//
// Kokkos v. 2.0
// Copyright (2014) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
//
// Kokkos v. 3.0
// Copyright (2020) National Technology & Engineering
// Solutions of Sandia, LLC (NTESS).
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// 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:
@ -23,10 +24,10 @@
// 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
// THIS SOFTWARE IS PROVIDED BY NTESS "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
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS 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
@ -36,7 +37,7 @@
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
//
//
// ************************************************************************
//@HEADER
*/
@ -55,45 +56,43 @@
namespace Test {
template< typename Scalar , class Space >
struct TestDynamicView
{
typedef typename Space::execution_space execution_space ;
typedef typename Space::memory_space memory_space ;
template <typename Scalar, class Space>
struct TestDynamicView {
typedef typename Space::execution_space execution_space;
typedef typename Space::memory_space memory_space;
typedef Kokkos::Experimental::DynamicView<Scalar*,Space> view_type;
typedef Kokkos::Experimental::DynamicView<Scalar*, Space> view_type;
typedef double value_type;
static void run( unsigned arg_total_size )
{
// Test: Create DynamicView, initialize size (via resize), run through parallel_for to set values, check values (via parallel_reduce); resize values and repeat
static void run(unsigned arg_total_size) {
// Test: Create DynamicView, initialize size (via resize), run through
// parallel_for to set values, check values (via parallel_reduce); resize
// values and repeat
// Case 1: min_chunk_size is a power of 2
{
view_type da("da", 1024, arg_total_size );
ASSERT_EQ( da.size(), 0 );
view_type da("da", 1024, arg_total_size);
ASSERT_EQ(da.size(), 0);
// Init
unsigned da_size = arg_total_size / 8;
da.resize_serial(da_size);
ASSERT_EQ( da.size(), da_size );
ASSERT_EQ(da.size(), da_size);
#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i )
{
da(i) = Scalar(i);
}
);
#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
Kokkos::parallel_for(
Kokkos::RangePolicy<execution_space>(0, da_size),
KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
value_type result_sum = 0.0;
Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
{
partial_sum += (value_type)da(i);
}
, result_sum
);
Kokkos::parallel_reduce(
Kokkos::RangePolicy<execution_space>(0, da_size),
KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
partial_sum += (value_type)da(i);
},
result_sum);
ASSERT_EQ(result_sum, (value_type)( da_size * (da_size - 1) / 2 ) );
ASSERT_EQ(result_sum, (value_type)(da_size * (da_size - 1) / 2));
#endif
#endif
@ -101,56 +100,55 @@ struct TestDynamicView
// the first 1/4 should remain the same
unsigned da_resize = arg_total_size / 2;
da.resize_serial(da_resize);
ASSERT_EQ( da.size(), da_resize );
ASSERT_EQ(da.size(), da_resize);
#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(da_size, da_resize), KOKKOS_LAMBDA ( const int i )
{
da(i) = Scalar(i);
}
);
#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
Kokkos::parallel_for(
Kokkos::RangePolicy<execution_space>(da_size, da_resize),
KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
value_type new_result_sum = 0.0;
Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(da_size, da_resize), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
{
partial_sum += (value_type)da(i);
}
, new_result_sum
);
Kokkos::parallel_reduce(
Kokkos::RangePolicy<execution_space>(da_size, da_resize),
KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
partial_sum += (value_type)da(i);
},
new_result_sum);
ASSERT_EQ(new_result_sum+result_sum, (value_type)( da_resize * (da_resize - 1) / 2 ) );
ASSERT_EQ(new_result_sum + result_sum,
(value_type)(da_resize * (da_resize - 1) / 2));
#endif
#endif
} // end scope
} // end scope
// Test: Create DynamicView, initialize size (via resize), run through parallel_for to set values, check values (via parallel_reduce); resize values and repeat
// Test: Create DynamicView, initialize size (via resize), run through
// parallel_for to set values, check values (via parallel_reduce); resize
// values and repeat
// Case 2: min_chunk_size is NOT a power of 2
{
view_type da("da", 1023, arg_total_size );
ASSERT_EQ( da.size(), 0 );
view_type da("da", 1023, arg_total_size);
ASSERT_EQ(da.size(), 0);
// Init
unsigned da_size = arg_total_size / 8;
da.resize_serial(da_size);
ASSERT_EQ( da.size(), da_size );
ASSERT_EQ(da.size(), da_size);
#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i )
{
da(i) = Scalar(i);
}
);
#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
Kokkos::parallel_for(
Kokkos::RangePolicy<execution_space>(0, da_size),
KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
value_type result_sum = 0.0;
Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
{
partial_sum += (value_type)da(i);
}
, result_sum
);
Kokkos::parallel_reduce(
Kokkos::RangePolicy<execution_space>(0, da_size),
KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
partial_sum += (value_type)da(i);
},
result_sum);
ASSERT_EQ(result_sum, (value_type)( da_size * (da_size - 1) / 2 ) );
ASSERT_EQ(result_sum, (value_type)(da_size * (da_size - 1) / 2));
#endif
#endif
@ -158,99 +156,92 @@ struct TestDynamicView
// the first 1/4 should remain the same
unsigned da_resize = arg_total_size / 2;
da.resize_serial(da_resize);
ASSERT_EQ( da.size(), da_resize );
ASSERT_EQ(da.size(), da_resize);
#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(da_size, da_resize), KOKKOS_LAMBDA ( const int i )
{
da(i) = Scalar(i);
}
);
#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
Kokkos::parallel_for(
Kokkos::RangePolicy<execution_space>(da_size, da_resize),
KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
value_type new_result_sum = 0.0;
Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(da_size, da_resize), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
{
partial_sum += (value_type)da(i);
}
, new_result_sum
);
Kokkos::parallel_reduce(
Kokkos::RangePolicy<execution_space>(da_size, da_resize),
KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
partial_sum += (value_type)da(i);
},
new_result_sum);
ASSERT_EQ(new_result_sum+result_sum, (value_type)( da_resize * (da_resize - 1) / 2 ) );
ASSERT_EQ(new_result_sum + result_sum,
(value_type)(da_resize * (da_resize - 1) / 2));
#endif
#endif
} // end scope
} // end scope
// Test: Create DynamicView, initialize size (via resize), run through parallel_for to set values, check values (via parallel_reduce); resize values and repeat
// Test: Create DynamicView, initialize size (via resize), run through
// parallel_for to set values, check values (via parallel_reduce); resize
// values and repeat
// Case 3: resize reduces the size
{
view_type da("da", 1023, arg_total_size );
ASSERT_EQ( da.size(), 0 );
view_type da("da", 1023, arg_total_size);
ASSERT_EQ(da.size(), 0);
// Init
unsigned da_size = arg_total_size / 2;
da.resize_serial(da_size);
ASSERT_EQ( da.size(), da_size );
ASSERT_EQ(da.size(), da_size);
#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i )
{
da(i) = Scalar(i);
}
);
#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
Kokkos::parallel_for(
Kokkos::RangePolicy<execution_space>(0, da_size),
KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
value_type result_sum = 0.0;
Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
{
partial_sum += (value_type)da(i);
}
, result_sum
);
Kokkos::parallel_reduce(
Kokkos::RangePolicy<execution_space>(0, da_size),
KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
partial_sum += (value_type)da(i);
},
result_sum);
ASSERT_EQ(result_sum, (value_type)( da_size * (da_size - 1) / 2 ) );
ASSERT_EQ(result_sum, (value_type)(da_size * (da_size - 1) / 2));
#endif
#endif
// remove the final 3/4 entries i.e. first 1/4 remain
unsigned da_resize = arg_total_size / 8;
da.resize_serial(da_resize);
ASSERT_EQ( da.size(), da_resize );
ASSERT_EQ(da.size(), da_resize);
#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(0, da_resize), KOKKOS_LAMBDA ( const int i )
{
da(i) = Scalar(i);
}
);
#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
Kokkos::parallel_for(
Kokkos::RangePolicy<execution_space>(0, da_resize),
KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
value_type new_result_sum = 0.0;
Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(0, da_resize), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
{
partial_sum += (value_type)da(i);
}
, new_result_sum
);
Kokkos::parallel_reduce(
Kokkos::RangePolicy<execution_space>(0, da_resize),
KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
partial_sum += (value_type)da(i);
},
new_result_sum);
ASSERT_EQ(new_result_sum, (value_type)( da_resize * (da_resize - 1) / 2 ) );
ASSERT_EQ(new_result_sum, (value_type)(da_resize * (da_resize - 1) / 2));
#endif
#endif
} // end scope
} // end scope
}
};
TEST_F( TEST_CATEGORY , dynamic_view )
{
typedef TestDynamicView< double , TEST_EXECSPACE >
TestDynView ;
TEST(TEST_CATEGORY, dynamic_view) {
typedef TestDynamicView<double, TEST_EXECSPACE> TestDynView;
for ( int i = 0 ; i < 10 ; ++i ) {
TestDynView::run( 100000 + 100 * i );
for (int i = 0; i < 10; ++i) {
TestDynView::run(100000 + 100 * i);
}
}
} // namespace Test
} // namespace Test
#endif /* #ifndef KOKKOS_TEST_DYNAMICVIEW_HPP */