[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

17

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

17

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})
+
+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_reduction(T *A, T *B) {
+  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_reduction<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_reduction<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) {
+    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_reduction(T *A, T *B, T *C) {
+  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_reduction<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_reduction<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) {
+    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) {
+  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];
+    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;
+}