Skip to content

Commit 5e71eaf

Browse files
masterleinadmasterleinad
committed
Apply clang-format 16
1 parent 3639703 commit 5e71eaf

156 files changed

Lines changed: 12821 additions & 9266 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎benchmarks/copy/copy_layout_stride.cpp‎

Lines changed: 117 additions & 137 deletions
Original file line numberDiff line numberDiff line change
@@ -26,19 +26,17 @@ MDSPAN_IMPL_INLINE_VARIABLE constexpr auto dyn = Kokkos::dynamic_extent;
2626
template <class MDSpan, class... DynSizes>
2727
void BM_MDSpan_Copy_2D_right(benchmark::State& state, MDSpan, DynSizes... dyn) {
2828
using value_type = typename MDSpan::value_type;
29-
auto buffer = std::make_unique<value_type[]>(
30-
MDSpan{nullptr, dyn...}.mapping().required_span_size()
31-
);
29+
auto buffer = std::make_unique<value_type[]>(
30+
MDSpan{nullptr, dyn...}.mapping().required_span_size());
3231
auto buffer2 = std::make_unique<value_type[]>(
33-
MDSpan{nullptr, dyn...}.mapping().required_span_size()
34-
);
32+
MDSpan{nullptr, dyn...}.mapping().required_span_size());
3533
auto s = MDSpan{buffer.get(), dyn...};
3634
mdspan_benchmark::fill_random(s);
3735
auto dest = MDSpan{buffer2.get(), dyn...};
3836
for (auto _ : state) {
39-
for(index_type i = 0; i < s.extent(0); ++i) {
37+
for (index_type i = 0; i < s.extent(0); ++i) {
4038
for (index_type j = 0; j < s.extent(1); ++j) {
41-
dest(i, j) = s(i, j);
39+
dest(i, j) = s(i, j);
4240
}
4341
}
4442
auto sdata = s.data_handle();
@@ -50,32 +48,29 @@ void BM_MDSpan_Copy_2D_right(benchmark::State& state, MDSpan, DynSizes... dyn) {
5048
}
5149

5250
BENCHMARK_CAPTURE(
53-
BM_MDSpan_Copy_2D_right, size_100_100, Kokkos::mdspan<int, Kokkos::extents<index_type, 100, 100>>(nullptr)
54-
);
55-
BENCHMARK_CAPTURE(
56-
BM_MDSpan_Copy_2D_right, size_100_dyn, Kokkos::mdspan<int, Kokkos::extents<index_type, 100, dyn>>(), 100
57-
);
58-
BENCHMARK_CAPTURE(
59-
BM_MDSpan_Copy_2D_right, size_dyn_dyn, Kokkos::mdspan<int, Kokkos::dextents<index_type, 2>>(), 100, 100
60-
);
51+
BM_MDSpan_Copy_2D_right, size_100_100,
52+
Kokkos::mdspan<int, Kokkos::extents<index_type, 100, 100>>(nullptr));
53+
BENCHMARK_CAPTURE(BM_MDSpan_Copy_2D_right, size_100_dyn,
54+
Kokkos::mdspan<int, Kokkos::extents<index_type, 100, dyn>>(),
55+
100);
56+
BENCHMARK_CAPTURE(BM_MDSpan_Copy_2D_right, size_dyn_dyn,
57+
Kokkos::mdspan<int, Kokkos::dextents<index_type, 2>>(), 100,
58+
100);
6159

6260
//================================================================================
6361

6462
template <class MDSpan, class LayoutMapping>
65-
void BM_MDSpan_Copy_2D_stride(benchmark::State& state, MDSpan, LayoutMapping map) {
63+
void BM_MDSpan_Copy_2D_stride(benchmark::State& state, MDSpan,
64+
LayoutMapping map) {
6665
benchmark::DoNotOptimize(map);
6766
using value_type = typename MDSpan::value_type;
68-
auto buffer = std::make_unique<value_type[]>(
69-
map.required_span_size()
70-
);
71-
auto buffer2 = std::make_unique<value_type[]>(
72-
map.required_span_size()
73-
);
74-
auto s = MDSpan{buffer.get(), map};
67+
auto buffer = std::make_unique<value_type[]>(map.required_span_size());
68+
auto buffer2 = std::make_unique<value_type[]>(map.required_span_size());
69+
auto s = MDSpan{buffer.get(), map};
7570
mdspan_benchmark::fill_random(s);
7671
auto dest = MDSpan{buffer2.get(), map};
7772
for (auto _ : state) {
78-
for(index_type i = 0; i < s.extent(0); ++i) {
73+
for (index_type i = 0; i < s.extent(0); ++i) {
7974
for (index_type j = 0; j < s.extent(1); ++j) {
8075
dest(i, j) = s(i, j);
8176
}
@@ -88,64 +83,57 @@ void BM_MDSpan_Copy_2D_stride(benchmark::State& state, MDSpan, LayoutMapping map
8883
state.SetBytesProcessed(s.size() * sizeof(value_type) * state.iterations());
8984
}
9085

91-
BENCHMARK_CAPTURE(
92-
BM_MDSpan_Copy_2D_stride, size_100_100,
93-
Kokkos::mdspan<int, Kokkos::extents<index_type, 100, 100>, Kokkos::layout_stride>(nullptr,
94-
Kokkos::layout_stride::mapping<Kokkos::extents<index_type, 100, 100>>()),
95-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, 100, 100>>(
96-
Kokkos::extents<index_type, 100, 100>{},
97-
// layout right
98-
std::array<size_t, 2>{100, 1}
99-
)
100-
);
101-
BENCHMARK_CAPTURE(
102-
BM_MDSpan_Copy_2D_stride, size_100_100d,
103-
Kokkos::mdspan<int, Kokkos::extents<index_type, 100, dyn>, Kokkos::layout_stride>(),
104-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, 100, dyn>>(
105-
Kokkos::extents<index_type, 100, dyn>{100},
106-
// layout right
107-
std::array<size_t, 2>{100, 1}
108-
)
109-
);
110-
BENCHMARK_CAPTURE(
111-
BM_MDSpan_Copy_2D_stride, size_100d_100,
112-
Kokkos::mdspan<int, Kokkos::extents<index_type, dyn, 100>, Kokkos::layout_stride>(),
113-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, dyn, 100>>(
114-
Kokkos::extents<index_type, dyn, 100>{100},
115-
// layout right
116-
std::array<size_t, 2>{100, 1}
117-
)
118-
);
119-
BENCHMARK_CAPTURE(
120-
BM_MDSpan_Copy_2D_stride, size_100d_100d,
121-
Kokkos::mdspan<int, Kokkos::extents<index_type, dyn, dyn>, Kokkos::layout_stride>(),
122-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, dyn, dyn>>(
123-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
124-
// layout right
125-
std::array<size_t, 2>{100, 1}
126-
)
127-
);
86+
BENCHMARK_CAPTURE(BM_MDSpan_Copy_2D_stride, size_100_100,
87+
Kokkos::mdspan<int, Kokkos::extents<index_type, 100, 100>,
88+
Kokkos::layout_stride>(
89+
nullptr, Kokkos::layout_stride::mapping<
90+
Kokkos::extents<index_type, 100, 100>>()),
91+
Kokkos::layout_stride::template mapping<
92+
Kokkos::extents<index_type, 100, 100>>(
93+
Kokkos::extents<index_type, 100, 100>{},
94+
// layout right
95+
std::array<size_t, 2>{100, 1}));
96+
BENCHMARK_CAPTURE(BM_MDSpan_Copy_2D_stride, size_100_100d,
97+
Kokkos::mdspan<int, Kokkos::extents<index_type, 100, dyn>,
98+
Kokkos::layout_stride>(),
99+
Kokkos::layout_stride::template mapping<
100+
Kokkos::extents<index_type, 100, dyn>>(
101+
Kokkos::extents<index_type, 100, dyn>{100},
102+
// layout right
103+
std::array<size_t, 2>{100, 1}));
104+
BENCHMARK_CAPTURE(BM_MDSpan_Copy_2D_stride, size_100d_100,
105+
Kokkos::mdspan<int, Kokkos::extents<index_type, dyn, 100>,
106+
Kokkos::layout_stride>(),
107+
Kokkos::layout_stride::template mapping<
108+
Kokkos::extents<index_type, dyn, 100>>(
109+
Kokkos::extents<index_type, dyn, 100>{100},
110+
// layout right
111+
std::array<size_t, 2>{100, 1}));
112+
BENCHMARK_CAPTURE(BM_MDSpan_Copy_2D_stride, size_100d_100d,
113+
Kokkos::mdspan<int, Kokkos::extents<index_type, dyn, dyn>,
114+
Kokkos::layout_stride>(),
115+
Kokkos::layout_stride::template mapping<
116+
Kokkos::extents<index_type, dyn, dyn>>(
117+
Kokkos::extents<index_type, dyn, dyn>{100, 100},
118+
// layout right
119+
std::array<size_t, 2>{100, 1}));
128120

129121
//================================================================================
130122

131123
template <class T, class Extents, class MapSrc, class MapDst>
132-
void BM_MDSpan_Copy_2D_stride_diff_map(benchmark::State& state,
133-
T, Extents, MapSrc map_src, MapDst map_dest
134-
) {
124+
void BM_MDSpan_Copy_2D_stride_diff_map(benchmark::State& state, T, Extents,
125+
MapSrc map_src, MapDst map_dest) {
135126
using value_type = T;
136-
auto buff_src = std::make_unique<value_type[]>(
137-
map_src.required_span_size()
138-
);
139-
auto buff_dest = std::make_unique<value_type[]>(
140-
map_dest.required_span_size()
141-
);
127+
auto buff_src = std::make_unique<value_type[]>(map_src.required_span_size());
128+
auto buff_dest =
129+
std::make_unique<value_type[]>(map_dest.required_span_size());
142130
using map_stride_dyn = Kokkos::layout_stride;
143-
using mdspan_type = Kokkos::mdspan<T, Extents, map_stride_dyn>;
144-
auto src = mdspan_type{buff_src.get(), map_src};
131+
using mdspan_type = Kokkos::mdspan<T, Extents, map_stride_dyn>;
132+
auto src = mdspan_type{buff_src.get(), map_src};
145133
mdspan_benchmark::fill_random(src);
146134
auto dest = mdspan_type{buff_dest.get(), map_dest};
147135
for (auto _ : state) {
148-
for(index_type i = 0; i < src.extent(0); ++i) {
136+
for (index_type i = 0; i < src.extent(0); ++i) {
149137
for (index_type j = 0; j < src.extent(1); ++j) {
150138
dest(i, j) = src(i, j);
151139
}
@@ -155,72 +143,67 @@ void BM_MDSpan_Copy_2D_stride_diff_map(benchmark::State& state,
155143
benchmark::DoNotOptimize(sdata);
156144
benchmark::DoNotOptimize(ddata);
157145
}
158-
state.SetBytesProcessed(src.extent(0) * src.extent(1) * sizeof(value_type) * state.iterations());
146+
state.SetBytesProcessed(src.extent(0) * src.extent(1) * sizeof(value_type) *
147+
state.iterations());
159148
}
160149

161-
BENCHMARK_CAPTURE(
162-
BM_MDSpan_Copy_2D_stride_diff_map, size_100d_100d_bcast_0, int(),
163-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
164-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, dyn, dyn>>(
165-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
166-
// layout right
167-
std::array<size_t, 2>{0, 1}
168-
),
169-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, dyn, dyn>>(
170-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
171-
// layout right
172-
std::array<size_t, 2>{100, 1}
173-
)
174-
);
175-
176-
BENCHMARK_CAPTURE(
177-
BM_MDSpan_Copy_2D_stride_diff_map, size_100d_100d_bcast_1, int(),
178-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
179-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, dyn, dyn>>(
180-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
181-
// layout right
182-
std::array<size_t, 2>{1, 0}
183-
),
184-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, dyn, dyn>>(
185-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
186-
// layout right
187-
std::array<size_t, 2>{100, 1}
188-
)
189-
);
190-
191-
BENCHMARK_CAPTURE(
192-
BM_MDSpan_Copy_2D_stride_diff_map, size_100d_100d_bcast_both, int(),
193-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
194-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, dyn, dyn>>(
195-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
196-
// layout right
197-
std::array<size_t, 2>{0, 0}
198-
),
199-
Kokkos::layout_stride::template mapping<Kokkos::extents<index_type, dyn, dyn>>(
200-
Kokkos::extents<index_type, dyn, dyn>{100, 100},
201-
// layout right
202-
std::array<size_t, 2>{100, 1}
203-
)
204-
);
205-
150+
BENCHMARK_CAPTURE(BM_MDSpan_Copy_2D_stride_diff_map, size_100d_100d_bcast_0,
151+
int(), Kokkos::extents<index_type, dyn, dyn>{100, 100},
152+
Kokkos::layout_stride::template mapping<
153+
Kokkos::extents<index_type, dyn, dyn>>(
154+
Kokkos::extents<index_type, dyn, dyn>{100, 100},
155+
// layout right
156+
std::array<size_t, 2>{0, 1}),
157+
Kokkos::layout_stride::template mapping<
158+
Kokkos::extents<index_type, dyn, dyn>>(
159+
Kokkos::extents<index_type, dyn, dyn>{100, 100},
160+
// layout right
161+
std::array<size_t, 2>{100, 1}));
162+
163+
BENCHMARK_CAPTURE(BM_MDSpan_Copy_2D_stride_diff_map, size_100d_100d_bcast_1,
164+
int(), Kokkos::extents<index_type, dyn, dyn>{100, 100},
165+
Kokkos::layout_stride::template mapping<
166+
Kokkos::extents<index_type, dyn, dyn>>(
167+
Kokkos::extents<index_type, dyn, dyn>{100, 100},
168+
// layout right
169+
std::array<size_t, 2>{1, 0}),
170+
Kokkos::layout_stride::template mapping<
171+
Kokkos::extents<index_type, dyn, dyn>>(
172+
Kokkos::extents<index_type, dyn, dyn>{100, 100},
173+
// layout right
174+
std::array<size_t, 2>{100, 1}));
175+
176+
BENCHMARK_CAPTURE(BM_MDSpan_Copy_2D_stride_diff_map, size_100d_100d_bcast_both,
177+
int(), Kokkos::extents<index_type, dyn, dyn>{100, 100},
178+
Kokkos::layout_stride::template mapping<
179+
Kokkos::extents<index_type, dyn, dyn>>(
180+
Kokkos::extents<index_type, dyn, dyn>{100, 100},
181+
// layout right
182+
std::array<size_t, 2>{0, 0}),
183+
Kokkos::layout_stride::template mapping<
184+
Kokkos::extents<index_type, dyn, dyn>>(
185+
Kokkos::extents<index_type, dyn, dyn>{100, 100},
186+
// layout right
187+
std::array<size_t, 2>{100, 1}));
206188

207189
//================================================================================
208190

209191
template <class T>
210192
void BM_Raw_Copy_1D(benchmark::State& state, T, size_t size) {
211193
benchmark::DoNotOptimize(size);
212194
using value_type = T;
213-
auto buffer = std::make_unique<value_type[]>(size);
195+
auto buffer = std::make_unique<value_type[]>(size);
214196
{
215197
// just for setup...
216-
auto wrapped = Kokkos::mdspan<T, Kokkos::dextents<index_type, 1>>{buffer.get(), size};
198+
auto wrapped =
199+
Kokkos::mdspan<T, Kokkos::dextents<index_type, 1>>{buffer.get(), size};
217200
mdspan_benchmark::fill_random(wrapped);
218201
}
219-
value_type* src = buffer.get();
220-
auto buffer2 = std::make_unique<value_type[]>(size);
202+
value_type* src = buffer.get();
203+
auto buffer2 = std::make_unique<value_type[]>(size);
221204
value_type* dest = buffer2.get();
222205
for (auto _ : state) {
223-
for(size_t i = 0; i < size; ++i) {
206+
for (size_t i = 0; i < size; ++i) {
224207
dest[i] = src[i];
225208
}
226209
benchmark::DoNotOptimize(src);
@@ -229,28 +212,27 @@ void BM_Raw_Copy_1D(benchmark::State& state, T, size_t size) {
229212
state.SetBytesProcessed(size * sizeof(value_type) * state.iterations());
230213
}
231214

232-
BENCHMARK_CAPTURE(
233-
BM_Raw_Copy_1D, size_10000, int(), 10000
234-
);
215+
BENCHMARK_CAPTURE(BM_Raw_Copy_1D, size_10000, int(), 10000);
235216

236217
//================================================================================
237218

238219
template <class T>
239220
void BM_Raw_Copy_2D(benchmark::State& state, T, size_t x, size_t y) {
240221
using value_type = T;
241-
auto buffer = std::make_unique<value_type[]>(x * y);
222+
auto buffer = std::make_unique<value_type[]>(x * y);
242223
{
243224
// just for setup...
244-
auto wrapped = Kokkos::mdspan<T, Kokkos::dextents<index_type, 1>>{buffer.get(), x * y};
225+
auto wrapped =
226+
Kokkos::mdspan<T, Kokkos::dextents<index_type, 1>>{buffer.get(), x * y};
245227
mdspan_benchmark::fill_random(wrapped);
246228
}
247-
value_type* src = buffer.get();
248-
auto buffer2 = std::make_unique<value_type[]>(x * y);
229+
value_type* src = buffer.get();
230+
auto buffer2 = std::make_unique<value_type[]>(x * y);
249231
value_type* dest = buffer2.get();
250232
for (auto _ : state) {
251-
for(size_t i = 0; i < x; ++i) {
252-
for(size_t j = 0; j < y; ++j) {
253-
dest[i*y + j] = src[i*y + j];
233+
for (size_t i = 0; i < x; ++i) {
234+
for (size_t j = 0; j < y; ++j) {
235+
dest[i * y + j] = src[i * y + j];
254236
}
255237
}
256238
benchmark::DoNotOptimize(src);
@@ -259,9 +241,7 @@ void BM_Raw_Copy_2D(benchmark::State& state, T, size_t x, size_t y) {
259241
state.SetBytesProcessed(x * y * sizeof(value_type) * state.iterations());
260242
}
261243

262-
BENCHMARK_CAPTURE(
263-
BM_Raw_Copy_2D, size_100_100, int(), 100, 100
264-
);
244+
BENCHMARK_CAPTURE(BM_Raw_Copy_2D, size_100_100, int(), 100, 100);
265245

266246
//================================================================================
267247

0 commit comments

Comments
 (0)