add gbench bandwidth stats (#298)

rscohn2 · web-flow · commit dd5438e72261 · 2023-05-31T14:06:31.000Z
diff --git a/benchmarks/README.rst b/benchmarks/README.rst
@@ -23,3 +23,11 @@ When running::
 
 To verify that you are using 48 cores, run ``top`` in another
 window. The stream process should show 4800 in the ``%CPU`` column.
+
+Google Benchmarks
+=================
+
+Micro-benchmark framework for measuring primitive operations. See
+`gbench README`_.
+
+.. _`gbench README`: gbench/README.rst
diff --git a/benchmarks/gbench/README.rst b/benchmarks/gbench/README.rst
@@ -0,0 +1,36 @@
+.. SPDX-FileCopyrightText: Intel Corporation
+..
+.. SPDX-License-Identifier: BSD-3-Clause
+
+==============
+ Google Bench
+==============
+
+We use google bench for micro-benchmarks.
+
+Sample Commands
+===============
+
+Run with all benchmarks with 2 ranks::
+
+  mpirun -n 2 ./mhp-bench --benchmark_time_unit=ms --benchmark_counters_tabular=true
+
+Run 2D stencil algorithms::
+
+  mpirun -n 2 ./mhp-bench --benchmark_time_unit=ms --benchmark_counters_tabular=true --benchmark_filter=Stencil2D
+
+Run distributed ranges algorithms::
+
+  mpirun -n 2 ./mhp-bench --benchmark_time_unit=ms --benchmark_counters_tabular=true --benchmark_filter=.*DR
+
+Show google bench options::
+
+  ./mhp-bench --help
+
+Show our custom options::
+
+  ./mhp-bench --drhelp
+
+See `user guide`_ for more information on google benchmark.
+
+.. _`user guide`: https://github.com/google/benchmark/blob/main/docs/user_guide.md#custom-counters
diff --git a/benchmarks/gbench/common/common-bench.hpp b/benchmarks/gbench/common/common-bench.hpp
@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: Intel Corporation
+//
+// SPDX-License-Identifier: BSD-3-Clause
+#pragma once
+
+#include "cxxopts.hpp"
+#include <benchmark/benchmark.h>
+#include <fmt/core.h>
+#include <fmt/ranges.h>
+#include <vendor/source_location/source_location.hpp>
+
+extern std::size_t comm_rank;
+extern std::size_t comm_size;
+
+extern std::size_t default_vector_size;
+extern std::size_t default_repetitions;
+
+inline void memory_bandwidth(benchmark::State &state, std::size_t bytes) {
+  state.counters["Memory"] =
+      benchmark::Counter(bytes, benchmark::Counter::kIsIterationInvariantRate,
+                         benchmark::Counter::kIs1024);
+}
diff --git a/benchmarks/gbench/common/distributed_vector.cpp b/benchmarks/gbench/common/distributed_vector.cpp
@@ -20,6 +20,8 @@ static void Fill_DR(benchmark::State &state) {
       xhp::fill(vec, 0);
     }
   }
+  memory_bandwidth(state,
+                   default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Fill_DR);
@@ -31,6 +33,8 @@ static void Fill_Local(benchmark::State &state) {
       rng::fill(vec, 0);
     }
   }
+  memory_bandwidth(state,
+                   default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Fill_Local);
@@ -46,6 +50,8 @@ static void Copy_DR(benchmark::State &state) {
       xhp::copy(src, dst.begin());
     }
   }
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Copy_DR);
@@ -59,6 +65,8 @@ static void Copy_Local(benchmark::State &state) {
       rng::copy(src, dst.begin());
     }
   }
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Copy_Local);
@@ -71,6 +79,8 @@ static void Reduce_DR(benchmark::State &state) {
       benchmark::DoNotOptimize(res);
     }
   }
+  memory_bandwidth(state,
+                   default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Reduce_DR);
@@ -83,6 +93,8 @@ static void Reduce_Local(benchmark::State &state) {
       benchmark::DoNotOptimize(res);
     }
   }
+  memory_bandwidth(state,
+                   default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Reduce_Local);
@@ -98,6 +110,8 @@ static void Reduce_DPL(benchmark::State &state) {
       benchmark::DoNotOptimize(res);
     }
   }
+  memory_bandwidth(state,
+                   default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Reduce_DPL);
@@ -111,6 +125,8 @@ static void TransformIdentity_DR(benchmark::State &state) {
       xhp::transform(src, dst.begin(), std::identity());
     }
   }
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(TransformIdentity_DR);
@@ -123,6 +139,8 @@ static void TransformIdentity_Local(benchmark::State &state) {
       rng::transform(src, dst.begin(), std::identity());
     }
   }
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(TransformIdentity_Local);
@@ -143,6 +161,8 @@ static void Mul_DR(benchmark::State &state) {
       xhp::transform(xhp::views::zip(a, b), c.begin(), mul);
     }
   }
+  memory_bandwidth(state,
+                   3 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Mul_DR);
@@ -159,6 +179,8 @@ static void Mul_Local(benchmark::State &state) {
                      c.begin(), mul);
     }
   }
+  memory_bandwidth(state,
+                   3 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Mul_Local);
diff --git a/benchmarks/gbench/common/dot_product.cpp b/benchmarks/gbench/common/dot_product.cpp
@@ -44,6 +44,8 @@ static void DotProduct_ZipReduce_DR(benchmark::State &state) {
     }
   }
   check_dp(res);
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(DotProduct_ZipReduce_DR);
@@ -65,6 +67,8 @@ static void DotProduct_ZipReduce_Std(benchmark::State &state) {
     }
   }
   check_dp(res);
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(DotProduct_ZipReduce_Std);
@@ -83,6 +87,8 @@ static void DotProduct_TransformReduce_Std(benchmark::State &state) {
     }
   }
   check_dp(res);
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(DotProduct_TransformReduce_Std);
@@ -93,13 +99,17 @@ static void DotProduct_Loop_Std(benchmark::State &state) {
   T res = 0;
 
   for (auto _ : state) {
-    res = 0;
-    for (std::size_t i = 0; i < default_vector_size; i++) {
-      res += a[i] * b[i];
+    for (std::size_t rep = 0; rep < default_repetitions; rep++) {
+      res = 0;
+      for (std::size_t i = 0; i < default_vector_size; i++) {
+        res += a[i] * b[i];
+      }
+      benchmark::DoNotOptimize(res);
     }
-    benchmark::DoNotOptimize(res);
   }
   check_dp(res);
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(DotProduct_Loop_Std);
@@ -126,6 +136,8 @@ static void DotProduct_TransformReduce_DPL(benchmark::State &state) {
     }
   }
   check_dp(res);
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(DotProduct_TransformReduce_DPL);
diff --git a/benchmarks/gbench/mhp/rooted.cpp b/benchmarks/gbench/mhp/rooted.cpp
@@ -14,6 +14,8 @@ static void CopyDist2Local_DR(benchmark::State &state) {
       xhp::copy(0, src, dst.begin());
     }
   }
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(CopyDist2Local_DR);
@@ -26,6 +28,8 @@ static void CopyLocal2Dist_DR(benchmark::State &state) {
       xhp::copy(0, src, dst.begin());
     }
   }
+  memory_bandwidth(state,
+                   2 * default_repetitions * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(CopyLocal2Dist_DR);
diff --git a/benchmarks/gbench/mhp/stencil_1d.cpp b/benchmarks/gbench/mhp/stencil_1d.cpp
@@ -36,6 +36,7 @@ static void Stencil1D_Slide_Std(benchmark::State &state) {
       std::swap(out_curr, out_prev);
     }
   }
+  memory_bandwidth(state, 2 * stencil_steps * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Stencil1D_Slide_Std);
@@ -58,6 +59,7 @@ static void Stencil1D_Subrange_Std(benchmark::State &state) {
       std::swap(in, out);
     }
   }
+  memory_bandwidth(state, 2 * stencil_steps * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Stencil1D_Subrange_Std);
@@ -77,6 +79,7 @@ static void Stencil1D_Subrange_DR(benchmark::State &state) {
       std::swap(in, out);
     }
   }
+  memory_bandwidth(state, 2 * stencil_steps * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Stencil1D_Subrange_DR);
@@ -99,6 +102,7 @@ static void Stencil1D_Subrange_DPL(benchmark::State &state) {
       std::swap(in, out);
     }
   }
+  memory_bandwidth(state, 2 * stencil_steps * default_vector_size * sizeof(T));
 }
 
 BENCHMARK(Stencil1D_Subrange_DPL);
diff --git a/benchmarks/gbench/mhp/stencil_2d.cpp b/benchmarks/gbench/mhp/stencil_2d.cpp
@@ -143,6 +143,7 @@ static void Stencil2D_Loop_Serial(benchmark::State &state) {
 
     checker.check(rng::span(in, rows * cols));
   }
+  memory_bandwidth(state, 2 * stencil_steps * rows * cols * sizeof(T));
 }
 
 BENCHMARK(Stencil2D_Loop_Serial);
@@ -190,6 +191,7 @@ static void Stencil2D_ForeachStdArray_DR(benchmark::State &state) {
     }
     checker.check_array(stencil_steps % 2 ? b : a);
   }
+  memory_bandwidth(state, 2 * stencil_steps * rows * cols * sizeof(T));
 }
 
 BENCHMARK(Stencil2D_ForeachStdArray_DR);
@@ -228,6 +230,7 @@ static void Stencil2D_NocollectiveCPU_DR(benchmark::State &state) {
     }
     checker.check(stencil_steps % 2 ? b : a);
   }
+  memory_bandwidth(state, 2 * stencil_steps * rows * cols * sizeof(T));
 }
 
 BENCHMARK(Stencil2D_NocollectiveCPU_DR);
@@ -315,6 +318,7 @@ static void Stencil2D_Basic_SYCL(benchmark::State &state) {
     }
     checker.check_device(q, in);
   }
+  memory_bandwidth(state, 2 * stencil_steps * rows * cols * sizeof(T));
 }
 
 BENCHMARK(Stencil2D_Basic_SYCL);
diff --git a/benchmarks/gbench/mhp/xhp-bench.hpp b/benchmarks/gbench/mhp/xhp-bench.hpp
@@ -3,21 +3,15 @@
 // SPDX-License-Identifier: BSD-3-Clause
 #pragma once
 
-#include "cxxopts.hpp"
-#include <benchmark/benchmark.h>
-#include <fmt/core.h>
-#include <fmt/ranges.h>
-#include <vendor/source_location/source_location.hpp>
+#include "../common/common-bench.hpp"
 
 #include "dr/mhp.hpp"
 
 namespace xhp = dr::mhp;
 
-extern std::size_t default_vector_size;
-extern std::size_t default_repetitions;
+#define BENCH_MHP
+
 extern std::size_t stencil_steps;
 extern std::size_t num_rows;
 extern std::size_t num_columns;
 extern bool check_results;
-
-#define BENCH_MHP
diff --git a/benchmarks/gbench/shp/shp-bench.cpp b/benchmarks/gbench/shp/shp-bench.cpp
@@ -7,6 +7,9 @@
 std::size_t default_vector_size;
 std::size_t default_repetitions;
 
+std::size_t comm_rank = 0;
+std::size_t comm_size = 1;
+
 cxxopts::ParseResult options;
 
 int main(int argc, char *argv[]) {
diff --git a/benchmarks/gbench/shp/xhp-bench.hpp b/benchmarks/gbench/shp/xhp-bench.hpp
@@ -3,20 +3,10 @@
 // SPDX-License-Identifier: BSD-3-Clause
 #pragma once
 
-#include "cxxopts.hpp"
-#include <benchmark/benchmark.h>
-#include <fmt/core.h>
-#include <fmt/ranges.h>
-#include <vendor/source_location/source_location.hpp>
+#include "../common/common-bench.hpp"
 
 #include "dr/shp.hpp"
 
 namespace xhp = dr::shp;
 
-extern std::size_t default_vector_size;
-extern std::size_t default_repetitions;
-
-inline std::size_t comm_rank = 0;
-inline std::size_t comm_size = 1;
-
 #define BENCH_SHP
diff --git a/examples/mhp/dot_product_benchmark.cpp b/examples/mhp/dot_product_benchmark.cpp
@@ -91,7 +91,7 @@ void time_summary(auto &durations, auto &sum) {
 
   fmt::print("Median duration: {} ms\n", median_duration * 1000);
   fmt::print("Memory bandwidth: {:.6} MB/s\n",
-             n * 3 * sizeof(T) / (median_duration * 1000 * 1000));
+             n * 2 * sizeof(T) / (median_duration * 1000 * 1000));
 }
 
 void stats(auto &durations, auto &sum, auto v_serial, auto &x_local,

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,8 @@ static void Fill_DR(benchmark::State &state) {`
`20`	`20`	`xhp::fill(vec, 0);`
`21`	`21`	`}`
`22`	`22`	`}`
	`23`	`+ memory_bandwidth(state,`
	`24`	`+ default_repetitions * default_vector_size * sizeof(T));`
`23`	`25`	`}`
`24`	`26`
`25`	`27`	`BENCHMARK(Fill_DR);`
`@@ -31,6 +33,8 @@ static void Fill_Local(benchmark::State &state) {`
`31`	`33`	`rng::fill(vec, 0);`
`32`	`34`	`}`
`33`	`35`	`}`
	`36`	`+ memory_bandwidth(state,`
	`37`	`+ default_repetitions * default_vector_size * sizeof(T));`
`34`	`38`	`}`
`35`	`39`
`36`	`40`	`BENCHMARK(Fill_Local);`
`@@ -46,6 +50,8 @@ static void Copy_DR(benchmark::State &state) {`
`46`	`50`	`xhp::copy(src, dst.begin());`
`47`	`51`	`}`
`48`	`52`	`}`
	`53`	`+ memory_bandwidth(state,`
	`54`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`49`	`55`	`}`
`50`	`56`
`51`	`57`	`BENCHMARK(Copy_DR);`
`@@ -59,6 +65,8 @@ static void Copy_Local(benchmark::State &state) {`
`59`	`65`	`rng::copy(src, dst.begin());`
`60`	`66`	`}`
`61`	`67`	`}`
	`68`	`+ memory_bandwidth(state,`
	`69`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`62`	`70`	`}`
`63`	`71`
`64`	`72`	`BENCHMARK(Copy_Local);`
`@@ -71,6 +79,8 @@ static void Reduce_DR(benchmark::State &state) {`
`71`	`79`	`benchmark::DoNotOptimize(res);`
`72`	`80`	`}`
`73`	`81`	`}`
	`82`	`+ memory_bandwidth(state,`
	`83`	`+ default_repetitions * default_vector_size * sizeof(T));`
`74`	`84`	`}`
`75`	`85`
`76`	`86`	`BENCHMARK(Reduce_DR);`
`@@ -83,6 +93,8 @@ static void Reduce_Local(benchmark::State &state) {`
`83`	`93`	`benchmark::DoNotOptimize(res);`
`84`	`94`	`}`
`85`	`95`	`}`
	`96`	`+ memory_bandwidth(state,`
	`97`	`+ default_repetitions * default_vector_size * sizeof(T));`
`86`	`98`	`}`
`87`	`99`
`88`	`100`	`BENCHMARK(Reduce_Local);`
`@@ -98,6 +110,8 @@ static void Reduce_DPL(benchmark::State &state) {`
`98`	`110`	`benchmark::DoNotOptimize(res);`
`99`	`111`	`}`
`100`	`112`	`}`
	`113`	`+ memory_bandwidth(state,`
	`114`	`+ default_repetitions * default_vector_size * sizeof(T));`
`101`	`115`	`}`
`102`	`116`
`103`	`117`	`BENCHMARK(Reduce_DPL);`
`@@ -111,6 +125,8 @@ static void TransformIdentity_DR(benchmark::State &state) {`
`111`	`125`	`xhp::transform(src, dst.begin(), std::identity());`
`112`	`126`	`}`
`113`	`127`	`}`
	`128`	`+ memory_bandwidth(state,`
	`129`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`114`	`130`	`}`
`115`	`131`
`116`	`132`	`BENCHMARK(TransformIdentity_DR);`
`@@ -123,6 +139,8 @@ static void TransformIdentity_Local(benchmark::State &state) {`
`123`	`139`	`rng::transform(src, dst.begin(), std::identity());`
`124`	`140`	`}`
`125`	`141`	`}`
	`142`	`+ memory_bandwidth(state,`
	`143`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`126`	`144`	`}`
`127`	`145`
`128`	`146`	`BENCHMARK(TransformIdentity_Local);`
`@@ -143,6 +161,8 @@ static void Mul_DR(benchmark::State &state) {`
`143`	`161`	`xhp::transform(xhp::views::zip(a, b), c.begin(), mul);`
`144`	`162`	`}`
`145`	`163`	`}`
	`164`	`+ memory_bandwidth(state,`
	`165`	`+ 3 * default_repetitions * default_vector_size * sizeof(T));`
`146`	`166`	`}`
`147`	`167`
`148`	`168`	`BENCHMARK(Mul_DR);`
`@@ -159,6 +179,8 @@ static void Mul_Local(benchmark::State &state) {`
`159`	`179`	`c.begin(), mul);`
`160`	`180`	`}`
`161`	`181`	`}`
	`182`	`+ memory_bandwidth(state,`
	`183`	`+ 3 * default_repetitions * default_vector_size * sizeof(T));`
`162`	`184`	`}`
`163`	`185`
`164`	`186`	`BENCHMARK(Mul_Local);`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,8 @@ static void DotProduct_ZipReduce_DR(benchmark::State &state) {`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`	`check_dp(res);`
	`47`	`+ memory_bandwidth(state,`
	`48`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`47`	`49`	`}`
`48`	`50`
`49`	`51`	`BENCHMARK(DotProduct_ZipReduce_DR);`
`@@ -65,6 +67,8 @@ static void DotProduct_ZipReduce_Std(benchmark::State &state) {`
`65`	`67`	`}`
`66`	`68`	`}`
`67`	`69`	`check_dp(res);`
	`70`	`+ memory_bandwidth(state,`
	`71`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`68`	`72`	`}`
`69`	`73`
`70`	`74`	`BENCHMARK(DotProduct_ZipReduce_Std);`
`@@ -83,6 +87,8 @@ static void DotProduct_TransformReduce_Std(benchmark::State &state) {`
`83`	`87`	`}`
`84`	`88`	`}`
`85`	`89`	`check_dp(res);`
	`90`	`+ memory_bandwidth(state,`
	`91`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`86`	`92`	`}`
`87`	`93`
`88`	`94`	`BENCHMARK(DotProduct_TransformReduce_Std);`
`@@ -93,13 +99,17 @@ static void DotProduct_Loop_Std(benchmark::State &state) {`
`93`	`99`	`T res = 0;`
`94`	`100`
`95`	`101`	`for (auto _ : state) {`
`96`		`- res = 0;`
`97`		`- for (std::size_t i = 0; i < default_vector_size; i++) {`
`98`		`- res += a[i] * b[i];`
	`102`	`+ for (std::size_t rep = 0; rep < default_repetitions; rep++) {`
	`103`	`+ res = 0;`
	`104`	`+ for (std::size_t i = 0; i < default_vector_size; i++) {`
	`105`	`+ res += a[i] * b[i];`
	`106`	`+ }`
	`107`	`+ benchmark::DoNotOptimize(res);`
`99`	`108`	`}`
`100`		`- benchmark::DoNotOptimize(res);`
`101`	`109`	`}`
`102`	`110`	`check_dp(res);`
	`111`	`+ memory_bandwidth(state,`
	`112`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`103`	`113`	`}`
`104`	`114`
`105`	`115`	`BENCHMARK(DotProduct_Loop_Std);`
`@@ -126,6 +136,8 @@ static void DotProduct_TransformReduce_DPL(benchmark::State &state) {`
`126`	`136`	`}`
`127`	`137`	`}`
`128`	`138`	`check_dp(res);`
	`139`	`+ memory_bandwidth(state,`
	`140`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`129`	`141`	`}`
`130`	`142`
`131`	`143`	`BENCHMARK(DotProduct_TransformReduce_DPL);`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,8 @@ static void CopyDist2Local_DR(benchmark::State &state) {`
`14`	`14`	`xhp::copy(0, src, dst.begin());`
`15`	`15`	`}`
`16`	`16`	`}`
	`17`	`+ memory_bandwidth(state,`
	`18`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`17`	`19`	`}`
`18`	`20`
`19`	`21`	`BENCHMARK(CopyDist2Local_DR);`
`@@ -26,6 +28,8 @@ static void CopyLocal2Dist_DR(benchmark::State &state) {`
`26`	`28`	`xhp::copy(0, src, dst.begin());`
`27`	`29`	`}`
`28`	`30`	`}`
	`31`	`+ memory_bandwidth(state,`
	`32`	`+ 2 * default_repetitions * default_vector_size * sizeof(T));`
`29`	`33`	`}`
`30`	`34`
`31`	`35`	`BENCHMARK(CopyLocal2Dist_DR);`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ static void Stencil1D_Slide_Std(benchmark::State &state) {`
`36`	`36`	`std::swap(out_curr, out_prev);`
`37`	`37`	`}`
`38`	`38`	`}`
	`39`	`+ memory_bandwidth(state, 2 * stencil_steps * default_vector_size * sizeof(T));`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`BENCHMARK(Stencil1D_Slide_Std);`
`@@ -58,6 +59,7 @@ static void Stencil1D_Subrange_Std(benchmark::State &state) {`
`58`	`59`	`std::swap(in, out);`
`59`	`60`	`}`
`60`	`61`	`}`
	`62`	`+ memory_bandwidth(state, 2 * stencil_steps * default_vector_size * sizeof(T));`
`61`	`63`	`}`
`62`	`64`
`63`	`65`	`BENCHMARK(Stencil1D_Subrange_Std);`
`@@ -77,6 +79,7 @@ static void Stencil1D_Subrange_DR(benchmark::State &state) {`
`77`	`79`	`std::swap(in, out);`
`78`	`80`	`}`
`79`	`81`	`}`
	`82`	`+ memory_bandwidth(state, 2 * stencil_steps * default_vector_size * sizeof(T));`
`80`	`83`	`}`
`81`	`84`
`82`	`85`	`BENCHMARK(Stencil1D_Subrange_DR);`
`@@ -99,6 +102,7 @@ static void Stencil1D_Subrange_DPL(benchmark::State &state) {`
`99`	`102`	`std::swap(in, out);`
`100`	`103`	`}`
`101`	`104`	`}`
	`105`	`+ memory_bandwidth(state, 2 * stencil_steps * default_vector_size * sizeof(T));`
`102`	`106`	`}`
`103`	`107`
`104`	`108`	`BENCHMARK(Stencil1D_Subrange_DPL);`
Original file line number	Diff line number	Diff line change
`@@ -143,6 +143,7 @@ static void Stencil2D_Loop_Serial(benchmark::State &state) {`
`143`	`143`
`144`	`144`	`checker.check(rng::span(in, rows * cols));`
`145`	`145`	`}`
	`146`	`+ memory_bandwidth(state, 2 * stencil_steps * rows * cols * sizeof(T));`
`146`	`147`	`}`
`147`	`148`
`148`	`149`	`BENCHMARK(Stencil2D_Loop_Serial);`
`@@ -190,6 +191,7 @@ static void Stencil2D_ForeachStdArray_DR(benchmark::State &state) {`
`190`	`191`	`}`
`191`	`192`	`checker.check_array(stencil_steps % 2 ? b : a);`
`192`	`193`	`}`
	`194`	`+ memory_bandwidth(state, 2 * stencil_steps * rows * cols * sizeof(T));`
`193`	`195`	`}`
`194`	`196`
`195`	`197`	`BENCHMARK(Stencil2D_ForeachStdArray_DR);`
`@@ -228,6 +230,7 @@ static void Stencil2D_NocollectiveCPU_DR(benchmark::State &state) {`
`228`	`230`	`}`
`229`	`231`	`checker.check(stencil_steps % 2 ? b : a);`
`230`	`232`	`}`
	`233`	`+ memory_bandwidth(state, 2 * stencil_steps * rows * cols * sizeof(T));`
`231`	`234`	`}`
`232`	`235`
`233`	`236`	`BENCHMARK(Stencil2D_NocollectiveCPU_DR);`
`@@ -315,6 +318,7 @@ static void Stencil2D_Basic_SYCL(benchmark::State &state) {`
`315`	`318`	`}`
`316`	`319`	`checker.check_device(q, in);`
`317`	`320`	`}`
	`321`	`+ memory_bandwidth(state, 2 * stencil_steps * rows * cols * sizeof(T));`
`318`	`322`	`}`
`319`	`323`
`320`	`324`	`BENCHMARK(Stencil2D_Basic_SYCL);`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ void time_summary(auto &durations, auto &sum) {`
`91`	`91`
`92`	`92`	`fmt::print("Median duration: {} ms\n", median_duration * 1000);`
`93`	`93`	`fmt::print("Memory bandwidth: {:.6} MB/s\n",`
`94`		`- n * 3 * sizeof(T) / (median_duration * 1000 * 1000));`
	`94`	`+ n * 2 * sizeof(T) / (median_duration * 1000 * 1000));`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`void stats(auto &durations, auto &sum, auto v_serial, auto &x_local,`