1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// SPDX-FileCopyrightText: Copyright Contributors to the Kokkos project
#include <TestStdAlgorithmsCommon.hpp>
namespace Test {
namespace stdalgos {
namespace TeamForEachN {
namespace KE = Kokkos::Experimental;
template <class ValueType>
struct PrefixIncrementFunctor {
KOKKOS_INLINE_FUNCTION
void operator()(ValueType& val) const { ++val; }
};
template <class DataViewType, class NViewType, class UnaryPredType>
struct TestFunctorA {
DataViewType m_dataView;
NViewType m_nView;
int m_apiPick;
UnaryPredType m_unaryPred;
TestFunctorA(const DataViewType dataView, const NViewType nView, int apiPick,
UnaryPredType unaryPred)
: m_dataView(dataView),
m_nView(nView),
m_apiPick(apiPick),
m_unaryPred(unaryPred) {}
template <class MemberType>
KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
const auto myRowIndex = member.league_rank();
const auto n = m_nView(myRowIndex);
auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
switch (m_apiPick) {
case 0: {
KE::for_each_n(member, KE::begin(myRowViewFrom), n, m_unaryPred);
break;
}
case 1: {
KE::for_each_n(member, myRowViewFrom, n, m_unaryPred);
break;
}
}
}
};
template <class LayoutTag, class ValueType>
void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
/* description:
use a rank-2 view randomly filled with values,
and run a team-level for_each_n
*/
// -----------------------------------------------
// prepare data
// -----------------------------------------------
// create a view in the memory space associated with default exespace
// with as many rows as the number of teams and fill it with random
// values from an arbitrary range.
constexpr ValueType lowerBound = 5;
constexpr ValueType upperBound = 523;
const auto bounds = make_bounds(lowerBound, upperBound);
auto [dataView, _] = create_random_view_and_host_clone(
LayoutTag{}, numTeams, numCols, bounds, "dataView");
// for_each modifies dataView, so make a separated host copy of if
auto dataViewBeforeOp_h = create_host_space_copy(dataView);
Kokkos::View<std::size_t*> nView("nView", numTeams);
auto nView_h = create_host_space_copy(nView);
using rand_pool =
Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
rand_pool pool(lowerBound * upperBound);
Kokkos::fill_random(nView_h, pool, 0, numCols);
Kokkos::deep_copy(nView, nView_h);
// -----------------------------------------------
// launch kokkos kernel
// -----------------------------------------------
using space_t = Kokkos::DefaultExecutionSpace;
Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
PrefixIncrementFunctor<ValueType> unaryPred;
// use CTAD for functor
TestFunctorA fnc(dataView, nView, apiId, unaryPred);
Kokkos::parallel_for(policy, fnc);
// -----------------------------------------------
// run cpp-std kernel and check
// -----------------------------------------------
auto dataViewAfterOp_h = create_host_space_copy(dataView);
for (std::size_t i = 0; i < dataViewAfterOp_h.extent(0); ++i) {
for (std::size_t j = 0, n = 0; j < dataViewAfterOp_h.extent(1); ++j, ++n) {
if (n < nView_h(i)) {
ASSERT_DOUBLE_EQ(dataViewBeforeOp_h(i, j) + 1, dataViewAfterOp_h(i, j));
} else {
ASSERT_DOUBLE_EQ(dataViewBeforeOp_h(i, j), dataViewAfterOp_h(i, j));
}
}
}
}
template <class LayoutTag, class ValueType>
void run_all_scenarios() {
for (int numTeams : teamSizesToTest) {
for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
for (int apiId : {0, 1}) {
test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
}
}
}
}
TEST(std_algorithms_for_each_n_team_test, test) {
run_all_scenarios<DynamicTag, double>();
run_all_scenarios<StridedTwoRowsTag, int>();
run_all_scenarios<StridedThreeRowsTag, unsigned>();
}
} // namespace TeamForEachN
} // namespace stdalgos
} // namespace Test
|
