[MicroBenchmark] Add initial LoopInterchange test/benchmark.

[fhahn]

Summary

This patch adds a first test case specifically for LoopInterchange. I am
not sure if MicroBenchmarks is the best place for this, but it seems
like a good way to benchmark/tests a set of loops targeted at loop
interchange.

[fhahn]

ping

[MatzeB]

Did you make sure this typically finished in 0.5-1s of time?

MicroBenchmarks/LoopInterchange/main.cpp

65

Does this need to be enclosed in #ifdef BENCHMARK_LIB as well? Or alternatively could you just drop all the #ifdefs to simplify the code?

[MatzeB]

MicroBenchmarks/LoopInterchange/main.cpp

26

I think y may overflow here and trigger UB, you should probably use an unsigned variable for it.

40

Does this need the ./ in front of the path? I would also recommend to abort if the output file cannot be written instead of continuing silently.

[MatzeB]

MicroBenchmarks/LoopInterchange/main.cpp

20

M and N are unused?

59–60

Is the printf here a good idea? You'll artificially make one iteration slower which could possibly make the benchmark library take longer to stabilize until the result is statistically significant.

[fhahn]

Thanks. I've dropped the range. On a cortex-a72, it takes around 1 second.

MicroBenchmarks/LoopInterchange/main.cpp

20

Fixed, looks like I uploaded an old version of the diff.

59–60

I've added a comment to the code. It's never called with state.range(0), so the printf should be never executed, but ensure the test1 calls cannot be optimized away.

65

I've removed them all.

[homerdin]

MicroBenchmarks/LoopInterchange/main.cpp

59–60

Can preventing the call being optimized away be accomplished using benchmark::DoNotOptimize() or benchmark::ClobberMemory()?

[MatzeB]

Please try whether using DoNotOptimize as suggested works. With that addressed LGTM.

[fhahn]

Thanks! I'll submit it in a few days, with DoNotOptimize.

MicroBenchmarks/LoopInterchange/main.cpp

59–60

Thanks for pointing me to that function, it looks like it does the same thing in a much clearer way!

[fhahn]

Use DoNotOptimize

MicroBenchmarks/CMakeLists.txt

 file(COPY lit.local.cfg DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 
 add_subdirectory(libs)
 add_subdirectory(XRay)
 add_subdirectory(LCALS)
 add_subdirectory(harris)
 add_subdirectory(ImageProcessing)
-
+add_subdirectory(LoopInterchange)

MicroBenchmarks/LoopInterchange/CMakeLists.txt

+llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
+
+llvm_test_verify(WORKDIR ${CMAKE_CURRENT_BINARY_DIR}
+    ${FPCMP} LoopInterchange.reference_output LoopInterchange.txt
+)
+llvm_test_executable(LoopInterchange main.cpp)
+llvm_test_data(LoopInterchange LoopInterchange.reference_output)
+
+target_link_libraries(LoopInterchange benchmark)

MicroBenchmarks/LoopInterchange/LoopInterchange.reference_output

+test1: 392960

MicroBenchmarks/LoopInterchange/main.cpp

+#include <iostream>
+#include <cstdlib>
+#include <fstream>
+
+#include "benchmark/benchmark.h"
+
+
+#define N 1024
+unsigned A[N][N];
+
+void init() {
+  for (unsigned i = 0; i < N; i++)
+    for (unsigned j = 0; j < N; j++)
+      A[i][j] = i + j;
+}
+
+unsigned y = 0;
+
+static unsigned test1() {
+  for (unsigned i = 0; i < N; i++) {
+    y = 0;
+    for (unsigned j = 0; j < N; j++) {
+      A[i][j] += 1;
+      y += A[i][j];
+    }
+  }
+  return y;
+}
+
+int main(int argc, char *argv[]) {
+  ::benchmark::Initialize(&argc, argv);
+
+  init();
+
+  // Run kernels once, to test functionality.
+  std::ofstream myfile ("LoopInterchange.txt");
+  if (myfile.is_open())   {
+    unsigned y = test1();
+    myfile << "test1: " << y << "\n";
+    myfile.close();
+  } else
+    return EXIT_FAILURE;
+
+  ::benchmark::RunSpecifiedBenchmarks();
+  return EXIT_SUCCESS;
+}
+
+void BENCHMARK_LI1(benchmark::State &state) {
+  for (auto _ : state) {
+    unsigned y = test1();
+    // We do not run the benchmark with state.range(0) == 20, but this should
+    // ensure we do not optimize the call to test1 away.
+    if (state.range(0) == 20)
+      printf("%d\n", y);
+  }
+}
+
+BENCHMARK(BENCHMARK_LI1)->Arg(0)->Unit(benchmark::kMicrosecond);