[MicroBenchmarks] Add initial SLP vectorization benchmarks.

[fhahn]

Summary

This patch adds a first set of micro benchmarks for SLP vectorization.
The initial benchmarks are focused on cases that require memory
versioning (worked on in D102834).

D101844 added similar benchmarks for the loop vectorizer.

[Meinersbur]

Does this expect on loop unrolling to happened? Did you consider adding #pragma clang loop unroll(full) to make sure of it?

MicroBenchmarks/SLPVectorization/Versioning.cpp

18

Where does the "reduction" in the name come from?

[fhahn]

In D104126#2813621, @Meinersbur wrote:

Does this expect on loop unrolling to happened? Did you consider adding #pragma clang loop unroll(full) to make sure of it?

Thanks for taking a look! Yes those expect loop-unrolling to happen. I added the pragma, even though it is clang specific it should be ignored by other compilers and not break builds with other compilers.

[fhahn]

MicroBenchmarks/SLPVectorization/Versioning.cpp

18

There's no reduction, I adjusted the name, thanks!

[Meinersbur]

LGTM

[Meinersbur]

reverse ping?

MicroBenchmarks/CMakeLists.txt

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

MicroBenchmarks/SLPVectorization/CMakeLists.txt

+llvm_test_run(WORKDIR ${CMAKE_CURRENT_BINARY_DIR})
+
+# Try and enable C++11. Don't use C++14 because it doesn't work in some
+# configurations.
+add_cxx_compiler_flag(-std=c++11)
+if (NOT HAVE_CXX_FLAG_STD_CXX11)
+  add_cxx_compiler_flag(-std=c++0x)
+endif ()
+
+llvm_test_executable(SLPVectorizationBenchmarks
+  main.cpp
+  Versioning.cpp)
+
+target_link_libraries(SLPVectorizationBenchmarks benchmark)

MicroBenchmarks/SLPVectorization/Versioning.cpp

+#include <iostream>
+#include <math.h>
+#include <memory>
+#include <random>
+
+#include "benchmark/benchmark.h"
+
+// Initialize arrays A, B and T with random numbers.
+template <typename T> static void init_data(T *A, unsigned N) {
+  std::uniform_real_distribution<T> dist(-100, 100);
+  std::mt19937 rng(12345);
+  for (unsigned i = 0; i < N; i++)
+    A[i] = dist(rng);
+}
+
+template <unsigned N, typename T>
+__attribute__((noinline)) void do_xor(T *A, T *B) {
+#pragma clang loop unroll(full)
+  for (int i = 0; i < N; i++) {
+    A[i] ^= B[i];
+  }
+}
+
+template <unsigned N, typename T>
+void benchmark_xor_runtime_checks_pass(benchmark::State &state) {
+  T A[N];
+  T B[N];
+  init_data(&A[0], N);
+  init_data(&B[0], N);
+
+  for (auto _ : state) {
+    do_xor<N>(&A[0], &B[0]);
+    benchmark::DoNotOptimize(A);
+    benchmark::DoNotOptimize(B);
+    benchmark::ClobberMemory();
+  }
+}
+
+template <unsigned N, typename T>
+void benchmark_xor_runtime_checks_fail(benchmark::State &state) {
+  T A[2 * N];
+  init_data(&A[0], 2 * N);
+
+  for (auto _ : state) {
+    do_xor<N>(&A[0], &A[3]);
+    benchmark::DoNotOptimize(A);
+    benchmark::ClobberMemory();
+  }
+}
+
+template <unsigned N, typename T>
+void benchmark_xor_no_runtime_checks_needed(benchmark::State &state) {
+  T A[N];
+  T B[N];
+  init_data(&A[0], N);
+  init_data(&B[0], N);
+
+  for (auto _ : state) {
+#pragma clang loop unroll(full)
+    for (int i = 0; i < N; i++) {
+      A[i] ^= B[i];
+    }
+
+    benchmark::DoNotOptimize(A);
+    benchmark::DoNotOptimize(B);
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK_TEMPLATE(benchmark_xor_runtime_checks_pass, 4, int);
+BENCHMARK_TEMPLATE(benchmark_xor_runtime_checks_fail, 4, int);
+BENCHMARK_TEMPLATE(benchmark_xor_no_runtime_checks_needed, 4, int);
+
+BENCHMARK_TEMPLATE(benchmark_xor_runtime_checks_pass, 16, int);
+BENCHMARK_TEMPLATE(benchmark_xor_runtime_checks_fail, 16, int);
+BENCHMARK_TEMPLATE(benchmark_xor_no_runtime_checks_needed, 16, int);
+
+template <unsigned N, typename T>
+__attribute__((noinline)) void do_add_xor(T *A, T *B, T *C) {
+#pragma clang loop unroll(full)
+  for (int i = 0; i < N; i++) {
+    A[i] ^= B[i] + C[i];
+  }
+}
+
+template <unsigned N, typename T>
+void benchmark_add_xor_runtime_checks_pass(benchmark::State &state) {
+  T A[N];
+  T B[N];
+  T C[N];
+  init_data(&A[0], N);
+  init_data(&B[0], N);
+  init_data(&C[0], N);
+
+  for (auto _ : state) {
+    do_add_xor<N>(&A[0], &B[0], &C[0]);
+    benchmark::DoNotOptimize(A);
+    benchmark::DoNotOptimize(B);
+    benchmark::DoNotOptimize(C);
+    benchmark::ClobberMemory();
+  }
+}
+
+template <unsigned N, typename T>
+void benchmark_add_xor_runtime_checks_fail(benchmark::State &state) {
+  T A[2 * N];
+  T B[N];
+  init_data(&A[0], 2 * N);
+  init_data(&B[0], N);
+
+  for (auto _ : state) {
+    do_add_xor<N>(&A[0], &A[3], &B[0]);
+    benchmark::DoNotOptimize(A);
+    benchmark::DoNotOptimize(B);
+    benchmark::ClobberMemory();
+  }
+}
+
+template <unsigned N, typename T>
+void benchmark_add_xor_no_runtime_checks_needed(benchmark::State &state) {
+  T A[N];
+  T B[N];
+  T C[N];
+  init_data(&A[0], N);
+  init_data(&B[0], N);
+  init_data(&C[0], N);
+
+  for (auto _ : state) {
+#pragma clang loop unroll(full)
+    for (int i = 0; i < N; i++) {
+      A[i] ^= B[i] + C[i];
+    }
+
+    benchmark::DoNotOptimize(A);
+    benchmark::DoNotOptimize(B);
+    benchmark::DoNotOptimize(C);
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK_TEMPLATE(benchmark_add_xor_runtime_checks_pass, 4, int);
+BENCHMARK_TEMPLATE(benchmark_add_xor_runtime_checks_fail, 4, int);
+BENCHMARK_TEMPLATE(benchmark_add_xor_no_runtime_checks_needed, 4, int);
+BENCHMARK_TEMPLATE(benchmark_add_xor_runtime_checks_pass, 16, int);
+BENCHMARK_TEMPLATE(benchmark_add_xor_runtime_checks_fail, 16, int);
+BENCHMARK_TEMPLATE(benchmark_add_xor_no_runtime_checks_needed, 16, int);
+
+template <unsigned N, typename T>
+__attribute__((noinline)) void do_multiply_accumulate(T *A, T *B, T c) {
+#pragma clang loop unroll(full)
+  for (unsigned int i = 0; i < N; ++i) {
+    A[i] += c * B[i];
+  }
+}
+
+template <unsigned N, typename T>
+void benchmark_multiply_accumulate_runtime_checks_pass(
+    benchmark::State &state) {
+  T A[N];
+  T B[N];
+  init_data(&A[0], N);
+  init_data(&B[0], N);
+
+  for (auto _ : state) {
+    do_multiply_accumulate<N>(&A[0], &B[0], B[0]);
+    benchmark::DoNotOptimize(A);
+    benchmark::DoNotOptimize(B);
+    benchmark::ClobberMemory();
+  }
+}
+
+template <unsigned N, typename T>
+void benchmark_multiply_accumulate_runtime_checks_fail(
+    benchmark::State &state) {
+  T A[N];
+  init_data(&A[0], N);
+
+  for (auto _ : state) {
+    do_multiply_accumulate<N>(&A[0], &A[1], A[0]);
+    benchmark::DoNotOptimize(A);
+    benchmark::ClobberMemory();
+  }
+}
+
+template <unsigned N, typename T>
+void benchmark_multiply_accumulate_no_runtime_checks_needed(
+    benchmark::State &state) {
+  T A[N];
+  T B[N];
+  init_data(&A[0], N);
+  init_data(&B[0], N);
+
+  for (auto _ : state) {
+    T c = A[0];
+#pragma clang loop unroll(full)
+    for (unsigned int i = 0; i < N; ++i) {
+      A[i] += c * B[i];
+    }
+    benchmark::DoNotOptimize(A);
+    benchmark::DoNotOptimize(B);
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK_TEMPLATE(benchmark_multiply_accumulate_runtime_checks_pass, 2,
+                   double);
+BENCHMARK_TEMPLATE(benchmark_multiply_accumulate_runtime_checks_fail, 2,
+                   double);
+BENCHMARK_TEMPLATE(benchmark_multiply_accumulate_no_runtime_checks_needed, 2,
+                   double);
+BENCHMARK_TEMPLATE(benchmark_multiply_accumulate_runtime_checks_pass, 3,
+                   double);
+BENCHMARK_TEMPLATE(benchmark_multiply_accumulate_runtime_checks_fail, 3,
+                   double);
+BENCHMARK_TEMPLATE(benchmark_multiply_accumulate_no_runtime_checks_needed, 3,
+                   double);
+BENCHMARK_TEMPLATE(benchmark_multiply_accumulate_runtime_checks_pass, 4,
+                   double);
+BENCHMARK_TEMPLATE(benchmark_multiply_accumulate_runtime_checks_fail, 4,
+                   double);
+BENCHMARK_TEMPLATE(benchmark_multiply_accumulate_no_runtime_checks_needed, 4,
+                   double);

MicroBenchmarks/SLPVectorization/main.cpp

+#include "benchmark/benchmark.h"
+
+int main(int argc, char *argv[]) {
+  benchmark::Initialize(&argc, argv);
+
+  benchmark::RunSpecifiedBenchmarks();
+  return EXIT_SUCCESS;
+}