PWR080: Add benchmark

Author: alvrogd

Benchmark/src/CMakeLists.txt

@@ -19,3 +19,4 @@ if (OCB_Fortran_COMPILER_ID STREQUAL "GNU")
   add_benchmark(PWR075)
 endif()
 add_benchmark(PWR079)
+add_benchmark(PWR080)

Benchmark/src/PWR080.cpp

@@ -0,0 +1,69 @@
+#include "Benchmark.h"
+
+// Forward-declare the functions to benchmark
+extern "C" {
+double transform_and_sum(const int n, const double *array, const int option);
+double transform_and_sum_improved(const int n, const double *array,
+                                  const int option);
+double transform_and_sum_f(const int n, const double *array, const int option);
+double transform_and_sum_improved_f(const int n, const double *array,
+                                    const int option);
+}
+
+// Size adjusted to fit execution on micro-seconds
+constexpr int N = 1024 * 1024;
+
+#if OCB_ENABLE_C
+
+static void CExampleBench(benchmark::State &state) {
+  auto array = OpenCatalog::CreateRandomVector<double>(N);
+
+  for (auto _ : state) {
+    double result = transform_and_sum(N, array.data(), /*option=*/-1);
+    benchmark::DoNotOptimize(result);
+  }
+}
+
+static void CImprovedBench(benchmark::State &state) {
+  auto array = OpenCatalog::CreateRandomVector<double>(N);
+
+  for (auto _ : state) {
+    double result = transform_and_sum_improved(N, array.data(), /*option=*/-1);
+    benchmark::DoNotOptimize(result);
+  }
+}
+
+// The goal of these benchmarks is to demonstrate that the suggested check does
+// not incur any performance penalty
+OC_BENCHMARK("PWR080 C Example", CExampleBench);
+OC_BENCHMARK("PWR080 C Improved", CImprovedBench);
+
+#endif
+
+#if OCB_ENABLE_Fortran
+
+static void FortranExampleBench(benchmark::State &state) {
+  auto array = OpenCatalog::CreateRandomVector<double>(N);
+
+  for (auto _ : state) {
+    double result = transform_and_sum_f(N, array.data(), /*option=*/-1);
+    benchmark::DoNotOptimize(result);
+  }
+}
+
+static void FortranImprovedBench(benchmark::State &state) {
+  auto array = OpenCatalog::CreateRandomVector<double>(N);
+
+  for (auto _ : state) {
+    double result =
+        transform_and_sum_improved_f(N, array.data(), /*option=*/-1);
+    benchmark::DoNotOptimize(result);
+  }
+}
+
+// The goal of these benchmarks is to demonstrate that the suggested check does
+// not incur any performance penalty
+OC_BENCHMARK("PWR080 Fortran Example", FortranExampleBench);
+OC_BENCHMARK("PWR080 Fortran Improved", FortranImprovedBench);
+
+#endif

Checks/PWR080/benchmark/example.c

@@ -0,0 +1,19 @@
+// PWR080: Conditionally initialized variables can lead to undefined behavior
+
+__attribute__((pure)) double transform_and_sum(const int n, const double *array,
+                                               const int option) {
+  double sum = 0.0;
+
+  double factor;
+  if (option == 1) {
+    factor = 0.5;
+  } else if (option == 2) {
+    factor = 2.0;
+  }
+
+  for (int i = 0; i < n; ++i) {
+    sum += array[i] * factor;
+  }
+
+  return sum;
+}

Checks/PWR080/benchmark/example.f90

@@ -0,0 +1,30 @@
+! PWR080: Conditionally initialized variables can lead to undefined behavior
+
+! NOT-PWR070: Explicit-shape arrays used for C-interoperability
+pure function transform_and_sum_f(n, array, option) bind(c)
+  use iso_c_binding, only: c_double, c_int
+  implicit none
+
+  integer(kind=c_int), intent(in), value :: n
+  real(kind=c_double), dimension(n), intent(in) :: array
+  integer(kind=c_int), intent(in), value :: option
+  real(kind=c_double) :: transform_and_sum_f
+
+  real(kind=c_double) :: sum
+  real(kind=c_double) :: factor
+  integer(kind=c_int) :: i
+
+  sum = 0.0
+
+  if (option == 1) then
+    factor = 0.5
+  else if (option == 2) then
+    factor = 2.0
+  end if
+
+  do i = 1, n
+    sum = sum + array(i) * factor
+  end do
+
+  transform_and_sum_f = sum
+end function transform_and_sum_f

Checks/PWR080/benchmark/solution.c

@@ -0,0 +1,20 @@
+// PWR080: Conditionally initialized variables can lead to undefined behavior
+
+__attribute__((pure)) double
+transform_and_sum_improved(const int n, const double *array, const int option) {
+  double sum = 0.0;
+
+  // Identity transformation by default
+  double factor = 1.0;
+  if (option == 1) {
+    factor = 0.5;
+  } else if (option == 2) {
+    factor = 2.0;
+  }
+
+  for (int i = 0; i < n; ++i) {
+    sum += array[i] * factor;
+  }
+
+  return sum;
+}

Checks/PWR080/benchmark/solution.f90

@@ -0,0 +1,32 @@
+! PWR080: Conditionally initialized variables can lead to undefined behavior
+
+! NOT-PWR070: Explicit-shape arrays used for C-interoperability
+pure function transform_and_sum_improved_f(n, array, option) bind(c)
+  use iso_c_binding, only: c_double, c_int
+  implicit none
+
+  integer(kind=c_int), intent(in), value :: n
+  real(kind=c_double), dimension(n), intent(in) :: array
+  integer(kind=c_int), intent(in), value :: option
+  real(kind=c_double) :: transform_and_sum_improved_f
+
+  real(kind=c_double) :: sum
+  real(kind=c_double) :: factor
+  integer(kind=c_int) :: i
+
+  sum = 0.0
+  ! Identity transformation
+  factor = 1.0
+
+  if (option == 1) then
+    factor = 0.5
+  else if (option == 2) then
+    factor = 2.0
+  end if
+
+  do i = 1, n
+    sum = sum + array(i) * factor
+  end do
+
+  transform_and_sum_improved_f = sum
+end function transform_and_sum_improved_f