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

Update Kokkos library in LAMMPS to v3.7.0

Browse Source
This commit is contained in:
Stan Gerald Moore
2022-10-04 14:04:40 -06:00
parent dd072f7e08
commit f9f9e44f2d
653 changed files with 41432 additions and 33597 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
lib/kokkos/benchmarks/bytes_and_flops/bench.hpp
View File

@ -47,20 +47,21 @@
template <class Scalar, int Unroll, int Stride>
struct Run {
static void run(int N, int K, int R, int F, int T, int S);
static void run(int N, int K, int R, int F, int T, int S, int B, int I);
};
template <class Scalar, int Stride>
struct RunStride {
static void run_1(int N, int K, int R, int F, int T, int S);
static void run_2(int N, int K, int R, int F, int T, int S);
static void run_3(int N, int K, int R, int F, int T, int S);
static void run_4(int N, int K, int R, int F, int T, int S);
static void run_5(int N, int K, int R, int F, int T, int S);
static void run_6(int N, int K, int R, int F, int T, int S);
static void run_7(int N, int K, int R, int F, int T, int S);
static void run_8(int N, int K, int R, int F, int T, int S);
static void run(int N, int K, int R, int U, int F, int T, int S);
static void run_1(int N, int K, int R, int F, int T, int S, int B, int I);
static void run_2(int N, int K, int R, int F, int T, int S, int B, int I);
static void run_3(int N, int K, int R, int F, int T, int S, int B, int I);
static void run_4(int N, int K, int R, int F, int T, int S, int B, int I);
static void run_5(int N, int K, int R, int F, int T, int S, int B, int I);
static void run_6(int N, int K, int R, int F, int T, int S, int B, int I);
static void run_7(int N, int K, int R, int F, int T, int S, int B, int I);
static void run_8(int N, int K, int R, int F, int T, int S, int B, int I);
static void run(int N, int K, int R, int U, int F, int T, int S, int B,
int I);
};
#define STRIDE 1
@ -83,11 +84,12 @@ struct RunStride {
#undef STRIDE
template <class Scalar>
void run_stride_unroll(int N, int K, int R, int D, int U, int F, int T, int S) {
if (D == 1) RunStride<Scalar, 1>::run(N, K, R, U, F, T, S);
if (D == 2) RunStride<Scalar, 2>::run(N, K, R, U, F, T, S);
if (D == 4) RunStride<Scalar, 4>::run(N, K, R, U, F, T, S);
if (D == 8) RunStride<Scalar, 8>::run(N, K, R, U, F, T, S);
if (D == 16) RunStride<Scalar, 16>::run(N, K, R, U, F, T, S);
if (D == 32) RunStride<Scalar, 32>::run(N, K, R, U, F, T, S);
void run_stride_unroll(int N, int K, int R, int D, int U, int F, int T, int S,
int B, int I) {
if (D == 1) RunStride<Scalar, 1>::run(N, K, R, U, F, T, S, B, I);
if (D == 2) RunStride<Scalar, 2>::run(N, K, R, U, F, T, S, B, I);
if (D == 4) RunStride<Scalar, 4>::run(N, K, R, U, F, T, S, B, I);
if (D == 8) RunStride<Scalar, 8>::run(N, K, R, U, F, T, S, B, I);
if (D == 16) RunStride<Scalar, 16>::run(N, K, R, U, F, T, S, B, I);
if (D == 32) RunStride<Scalar, 32>::run(N, K, R, U, F, T, S, B, I);
}

2
lib/kokkos/benchmarks/bytes_and_flops/bench_double.cpp
View File

@ -45,4 +45,4 @@
#include <bench.hpp>
template void run_stride_unroll<double>(int N, int K, int R, int D, int U,
int F, int T, int S);
int F, int T, int S, int B, int I);

2
lib/kokkos/benchmarks/bytes_and_flops/bench_float.cpp
View File

@ -45,4 +45,4 @@
#include <bench.hpp>
template void run_stride_unroll<float>(int N, int K, int R, int D, int U, int F,
int T, int S);
int T, int S, int B, int I);

2
lib/kokkos/benchmarks/bytes_and_flops/bench_int32_t.cpp
View File

@ -45,4 +45,4 @@
#include <bench.hpp>
template void run_stride_unroll<int32_t>(int N, int K, int R, int D, int U,
int F, int T, int S);
int F, int T, int S, int B, int I);

2
lib/kokkos/benchmarks/bytes_and_flops/bench_int64_t.cpp
View File

@ -45,4 +45,4 @@
#include <bench.hpp>
template void run_stride_unroll<int64_t>(int N, int K, int R, int D, int U,
int F, int T, int S);
int F, int T, int S, int B, int I);

51
lib/kokkos/benchmarks/bytes_and_flops/bench_stride.hpp
View File

@ -69,55 +69,56 @@
template <class Scalar>
struct RunStride<Scalar, STRIDE> {
static void run_1(int N, int K, int R, int F, int T, int S) {
Run<Scalar, 1, STRIDE>::run(N, K, R, F, T, S);
static void run_1(int N, int K, int R, int F, int T, int S, int B, int I) {
Run<Scalar, 1, STRIDE>::run(N, K, R, F, T, S, B, I);
}
static void run_2(int N, int K, int R, int F, int T, int S) {
Run<Scalar, 2, STRIDE>::run(N, K, R, F, T, S);
static void run_2(int N, int K, int R, int F, int T, int S, int B, int I) {
Run<Scalar, 2, STRIDE>::run(N, K, R, F, T, S, B, I);
}
static void run_3(int N, int K, int R, int F, int T, int S) {
Run<Scalar, 3, STRIDE>::run(N, K, R, F, T, S);
static void run_3(int N, int K, int R, int F, int T, int S, int B, int I) {
Run<Scalar, 3, STRIDE>::run(N, K, R, F, T, S, B, I);
}
static void run_4(int N, int K, int R, int F, int T, int S) {
Run<Scalar, 4, STRIDE>::run(N, K, R, F, T, S);
static void run_4(int N, int K, int R, int F, int T, int S, int B, int I) {
Run<Scalar, 4, STRIDE>::run(N, K, R, F, T, S, B, I);
}
static void run_5(int N, int K, int R, int F, int T, int S) {
Run<Scalar, 5, STRIDE>::run(N, K, R, F, T, S);
static void run_5(int N, int K, int R, int F, int T, int S, int B, int I) {
Run<Scalar, 5, STRIDE>::run(N, K, R, F, T, S, B, I);
}
static void run_6(int N, int K, int R, int F, int T, int S) {
Run<Scalar, 6, STRIDE>::run(N, K, R, F, T, S);
static void run_6(int N, int K, int R, int F, int T, int S, int B, int I) {
Run<Scalar, 6, STRIDE>::run(N, K, R, F, T, S, B, I);
}
static void run_7(int N, int K, int R, int F, int T, int S) {
Run<Scalar, 7, STRIDE>::run(N, K, R, F, T, S);
static void run_7(int N, int K, int R, int F, int T, int S, int B, int I) {
Run<Scalar, 7, STRIDE>::run(N, K, R, F, T, S, B, I);
}
static void run_8(int N, int K, int R, int F, int T, int S) {
Run<Scalar, 8, STRIDE>::run(N, K, R, F, T, S);
static void run_8(int N, int K, int R, int F, int T, int S, int B, int I) {
Run<Scalar, 8, STRIDE>::run(N, K, R, F, T, S, B, I);
}
static void run(int N, int K, int R, int U, int F, int T, int S) {
static void run(int N, int K, int R, int U, int F, int T, int S, int B,
int I) {
if (U == 1) {
run_1(N, K, R, F, T, S);
run_1(N, K, R, F, T, S, B, I);
}
if (U == 2) {
run_2(N, K, R, F, T, S);
run_2(N, K, R, F, T, S, B, I);
}
if (U == 3) {
run_3(N, K, R, F, T, S);
run_3(N, K, R, F, T, S, B, I);
}
if (U == 4) {
run_4(N, K, R, F, T, S);
run_4(N, K, R, F, T, S, B, I);
}
if (U == 5) {
run_5(N, K, R, F, T, S);
run_5(N, K, R, F, T, S, B, I);
}
if (U == 6) {
run_6(N, K, R, F, T, S);
run_6(N, K, R, F, T, S, B, I);
}
if (U == 7) {
run_7(N, K, R, F, T, S);
run_7(N, K, R, F, T, S, B, I);
}
if (U == 8) {
run_8(N, K, R, F, T, S);
run_8(N, K, R, F, T, S, B, I);
}
}
};

90
lib/kokkos/benchmarks/bytes_and_flops/bench_unroll_stride.hpp
View File

@ -44,7 +44,7 @@
template <class Scalar>
struct Run<Scalar, UNROLL, STRIDE> {
static void run(int N, int K, int R, int F, int T, int S) {
static void run(int N, int K, int R, int F, int T, int S, int Ba, int I) {
Kokkos::View<Scalar* * [STRIDE], Kokkos::LayoutRight> A("A", N, K);
Kokkos::View<Scalar* * [STRIDE], Kokkos::LayoutRight> B("B", N, K);
Kokkos::View<Scalar* * [STRIDE], Kokkos::LayoutRight> C("C", N, K);
@ -54,98 +54,102 @@ struct Run<Scalar, UNROLL, STRIDE> {
Kokkos::deep_copy(C, Scalar(3.5));
Kokkos::Timer timer;
Kokkos::parallel_for(
"BenchmarkKernel",
Kokkos::TeamPolicy<>(N, T).set_scratch_size(0, Kokkos::PerTeam(S)),
KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team) {
const int n = team.league_rank();
for (int r = 0; r < R; r++) {
Kokkos::parallel_for(
Kokkos::TeamThreadRange(team, 0, K), [&](const int& i) {
Scalar a1 = A(n, i, 0);
const Scalar b = B(n, i, 0);
for (int i = 0; i < I; ++i) {
Kokkos::parallel_for(
"BenchmarkKernel",
Kokkos::TeamPolicy<>(N, T).set_scratch_size(0, Kokkos::PerTeam(S)),
KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team) {
const int n = team.league_rank();
for (int r = 0; r < R; r++) {
Kokkos::parallel_for(
Kokkos::TeamThreadRange(team, 0, K), [&](const int& i) {
Scalar a1 = A(n, i, 0);
const Scalar b = B(n, i, 0);
#if (UNROLL > 1)
Scalar a2 = a1 * 1.3;
Scalar a2 = a1 * 1.3;
#endif
#if (UNROLL > 2)
Scalar a3 = a2 * 1.1;
Scalar a3 = a2 * 1.1;
#endif
#if (UNROLL > 3)
Scalar a4 = a3 * 1.1;
Scalar a4 = a3 * 1.1;
#endif
#if (UNROLL > 4)
Scalar a5 = a4 * 1.3;
Scalar a5 = a4 * 1.3;
#endif
#if (UNROLL > 5)
Scalar a6 = a5 * 1.1;
Scalar a6 = a5 * 1.1;
#endif
#if (UNROLL > 6)
Scalar a7 = a6 * 1.1;
Scalar a7 = a6 * 1.1;
#endif
#if (UNROLL > 7)
Scalar a8 = a7 * 1.1;
Scalar a8 = a7 * 1.1;
#endif
for (int f = 0; f < F; f++) {
a1 += b * a1;
for (int f = 0; f < F; f++) {
a1 += b * a1;
#if (UNROLL > 1)
a2 += b * a2;
a2 += b * a2;
#endif
#if (UNROLL > 2)
a3 += b * a3;
a3 += b * a3;
#endif
#if (UNROLL > 3)
a4 += b * a4;
a4 += b * a4;
#endif
#if (UNROLL > 4)
a5 += b * a5;
a5 += b * a5;
#endif
#if (UNROLL > 5)
a6 += b * a6;
a6 += b * a6;
#endif
#if (UNROLL > 6)
a7 += b * a7;
a7 += b * a7;
#endif
#if (UNROLL > 7)
a8 += b * a8;
a8 += b * a8;
#endif
}
}
#if (UNROLL == 1)
C(n, i, 0) = a1;
C(n, i, 0) = a1;
#endif
#if (UNROLL == 2)
C(n, i, 0) = a1 + a2;
C(n, i, 0) = a1 + a2;
#endif
#if (UNROLL == 3)
C(n, i, 0) = a1 + a2 + a3;
C(n, i, 0) = a1 + a2 + a3;
#endif
#if (UNROLL == 4)
C(n, i, 0) = a1 + a2 + a3 + a4;
C(n, i, 0) = a1 + a2 + a3 + a4;
#endif
#if (UNROLL == 5)
C(n, i, 0) = a1 + a2 + a3 + a4 + a5;
C(n, i, 0) = a1 + a2 + a3 + a4 + a5;
#endif
#if (UNROLL == 6)
C(n, i, 0) = a1 + a2 + a3 + a4 + a5 + a6;
C(n, i, 0) = a1 + a2 + a3 + a4 + a5 + a6;
#endif
#if (UNROLL == 7)
C(n, i, 0) = a1 + a2 + a3 + a4 + a5 + a6 + a7;
C(n, i, 0) = a1 + a2 + a3 + a4 + a5 + a6 + a7;
#endif
#if (UNROLL == 8)
C(n, i, 0) = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8;
C(n, i, 0) = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8;
#endif
});
}
});
});
}
});
}
Kokkos::fence();
double seconds = timer.seconds();
double seconds = timer.seconds() / static_cast<double>(I);
double bytes = 1.0 * N * K * R * 3 * sizeof(Scalar);
bytes /= ((Ba == 2) ? (1024 * 1024 * 1024) : (1000 * 1000 * 1000));
double flops = 1.0 * N * K * R * (F * 2 * UNROLL + 2 * (UNROLL - 1));
printf(
"NKRUFTS: %i %i %i %i %i %i %i Time: %lfs Bandwidth: %lfGiB/s GFlop/s: "
"NKRUFTSBI: %i %i %i %i %i %i %i %i %i Time: %lfs Bandwidth: %lf%s "
"GFlop/s: "
"%lf\n",
N, K, R, UNROLL, F, T, S, seconds,
1.0 * bytes / seconds / 1024 / 1024 / 1024, 1.e-9 * flops / seconds);
N, K, R, UNROLL, F, T, S, Ba, I, seconds, 1.0 * bytes / seconds,
Ba == 2 ? "GiB/s" : "GB/s", 1.e-9 * flops / seconds);
}
};

42
lib/kokkos/benchmarks/bytes_and_flops/main.cpp
View File

@ -48,19 +48,19 @@
#include <cstdlib>
extern template void run_stride_unroll<float>(int, int, int, int, int, int, int,
int);
int, int, int);
extern template void run_stride_unroll<double>(int, int, int, int, int, int,
int, int);
int, int, int, int);
extern template void run_stride_unroll<int32_t>(int, int, int, int, int, int,
int, int);
int, int, int, int);
extern template void run_stride_unroll<int64_t>(int, int, int, int, int, int,
int, int);
int, int, int, int);
int main(int argc, char* argv[]) {
Kokkos::initialize();
if (argc < 10) {
printf("Arguments: N K R D U F T S\n");
printf("Arguments: N K R D U F T S B I\n");
printf(" P: Precision (1==float, 2==double, 3==int32_t, 4==int64_t)\n");
printf(" N,K: dimensions of the 2D array to allocate\n");
printf(" R: how often to loop through the K dimension with each team\n");
@ -72,6 +72,10 @@ int main(int argc, char* argv[]) {
printf(" T: team size\n");
printf(
" S: shared memory per team (used to control occupancy on GPUs)\n");
printf(
" B: units for reported memory bandwidths (2=GiB, 10=GB, "
"default=2)\n");
printf(" I: iterations of the kernel to time over (default=10)\n");
printf("Example Input GPU:\n");
printf(" Bandwidth Bound : 2 100000 1024 1 1 1 1 256 6000\n");
printf(" Cache Bound : 2 100000 1024 64 1 1 1 512 20000\n");
@ -92,6 +96,16 @@ int main(int argc, char* argv[]) {
int T = std::stoi(argv[8]);
int S = std::stoi(argv[9]);
int B = 2;
if (argc >= 11) {
B = std::atoi(argv[10]);
}
int I = 10;
if (argc >= 12) {
I = std::atoi(argv[11]);
}
if (U > 8) {
printf("U must be 1-8\n");
return 0;
@ -105,17 +119,27 @@ int main(int argc, char* argv[]) {
return 0;
}
if ((B != 2) && (B != 10)) {
printf("B must be one of 2,10\n");
return 0;
}
if (I < 1) {
printf("I must be >= 1\n");
return 0;
}
if (P == 1) {
run_stride_unroll<float>(N, K, R, D, U, F, T, S);
run_stride_unroll<float>(N, K, R, D, U, F, T, S, B, I);
}
if (P == 2) {
run_stride_unroll<double>(N, K, R, D, U, F, T, S);
run_stride_unroll<double>(N, K, R, D, U, F, T, S, B, I);
}
if (P == 3) {
run_stride_unroll<int32_t>(N, K, R, D, U, F, T, S);
run_stride_unroll<int32_t>(N, K, R, D, U, F, T, S, B, I);
}
if (P == 4) {
run_stride_unroll<int64_t>(N, K, R, D, U, F, T, S);
run_stride_unroll<int64_t>(N, K, R, D, U, F, T, S, B, I);
}
Kokkos::finalize();