Microbenchmark to test runtime of truncate or zero-extend vector operations in AArch64

[nilanjana_basu]

Summary

Add benchmarks to check runtime of truncate or zero-extend vector operations in AArch64.
This patch adds an initial set of benchmarks to check runtime of vectorized truncate or zero-extend operations in a loop for different vector types over different vector widths.
The goal of this initial benchmark is to check the impact of D133495, D135229 and D120571.

[nilanjana_basu]

Removed redundant code

[fhahn]

Thanks for the patch! I think it would be good to move the benchmark to a different file, as it is unrelated to measuring runtime check performance.

MicroBenchmarks/LoopVectorization/RuntimeChecks.cpp

7 ↗

(On Diff #468978)

It should be sufficient to use a much larger iteration count like 10000, the main benchmark loop will make sure the function is run long enough to collect stable data.

135 ↗

(On Diff #468978)

I don't think this is doing what you want at the moment. Instead of truncating to to i8 it is extending from i8. B and A should probably be flipped?

144 ↗

(On Diff #468978)

It looks like this is missing the main benchmark loop that google benchmark requires:

  for (auto _ : state) {
...
  }

[nilanjana_basu]

Made a separate file for testing vector operations for truncate or zero extend. Added tests for truncate of different types of data types, with different vectorization width settings.

[nilanjana_basu]

Fixed a mistake where the same test was being ran twice

[nilanjana_basu]

Extended it to be generic enough for both truncate & zero-extend vector operations

[nilanjana_basu]

Removed two test cases whose related patches are not yet available.

[nilanjana_basu]

All the comments have been addressed in the latest patch.

[nilanjana_basu]

Removed the addition operation to keep only the truncate or zero-extend operation for a more focused performance comparison

[t.p.northover]

I think this looks reasonable now.

[nilanjana_basu]

Minor fix to comments

MicroBenchmarks/LoopVectorization/CMakeLists.txt

 # Only enable verification of results if neither 'benchmarking only' has been
 # selected nor -ffast-math is passed.
 string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UPPER)
 set(COMBINED_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${CPPFLAGS}")
 if (NOT TEST_SUITE_BENCHMARKING_ONLY AND
     NOT ${COMBINED_CXX_FLAGS} MATCHES ".*-ffast-math.*")
   list(APPEND CPPFLAGS -DBENCH_AND_VERIFY)
 endif()
 
 llvm_test_run()
 
 llvm_test_executable(LoopVectorizationBenchmarks
   main.cpp
   MathFunctions.cpp
   RuntimeChecks.cpp
+  VectorOperations.cpp
 )
 
 target_link_libraries(LoopVectorizationBenchmarks benchmark)

MicroBenchmarks/LoopVectorization/VectorOperations.cpp

+#include <iostream>
+#include <memory>
+#include <random>
+
+#include "benchmark/benchmark.h"
+
+#define ITERATIONS 10000
+
+static std::mt19937 rng;
+
+// Initialize array A with random numbers.
+template <typename Ty>
+static void init_data(const std::unique_ptr<Ty[]> &A, unsigned N) {
+  std::uniform_int_distribution<uint64_t> distrib(
+      std::numeric_limits<Ty>::min(), std::numeric_limits<Ty>::max());
+  for (unsigned i = 0; i < N; i++)
+    A[i] = static_cast<Ty>(distrib(rng));
+}
+
+// Truncate & add each vector element from T to int8_t in a vectorized loop with vectorization width 8
+template <typename T> static void truncVecInLoopWithVW8(const T *A, uint8_t *B, int iterations) {
+#pragma clang loop vectorize_width(8) interleave_count(4)
+  for (unsigned i = 0; i < iterations; i++) {
+    B[i] += A[i];
+  }
+}
+
+template <typename Ty> static void __attribute__((always_inline))
+benchForTruncVecInLoopWithVW8(benchmark::State &state) {
+  std::unique_ptr<Ty[]> A(new Ty[ITERATIONS]);
+  std::unique_ptr<uint8_t[]> B(new uint8_t[ITERATIONS]);
+  init_data(A, ITERATIONS);
+  init_data(B, ITERATIONS);
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(B);
+    benchmark::ClobberMemory();
+    truncVecInLoopWithVW8(&A[0], &B[0], ITERATIONS);
+  }
+}
+
+// Truncate & add each vector element from T to int8_t in a vectorized loop with vectorization width 16
+template <typename T> static void truncVecInLoopWithVW16(const T *A, uint8_t *B, int iterations) {
+#pragma clang loop vectorize_width(16) interleave_count(4)
+  for (unsigned i = 0; i < iterations; i++) {
+    B[i] += A[i];
+  }
+}
+
+template <typename Ty> static void __attribute__((always_inline))
+benchForTruncVecInLoopWithVW16(benchmark::State &state) {
+  std::unique_ptr<Ty[]> A(new Ty[ITERATIONS]);
+  std::unique_ptr<uint8_t[]> B(new uint8_t[ITERATIONS]);
+  init_data(A, ITERATIONS);
+  init_data(B, ITERATIONS);
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(B);
+    benchmark::ClobberMemory();
+    truncVecInLoopWithVW16(&A[0], &B[0], ITERATIONS);
+  }
+}
+
+// Add vectorized truncate operation benchmarks for different types
+#define ADD_BENCHMARK(ty)                                                  \
+  void benchForTruncVecInLoopFor_##ty##_(benchmark::State &state) {             \
+    benchForTruncVecInLoopWithVW8<ty>(state);                   \
+  }                                                                            \
+  BENCHMARK(benchForTruncVecInLoopFor_##ty##_); \
+  void benchForTruncVecInLoopWithVW16For_##ty##_(benchmark::State &state) {             \
+    benchForTruncVecInLoopWithVW16<ty>(state);                   \
+  }                                                                            \
+  BENCHMARK(benchForTruncVecInLoopFor_##ty##_); \
+
+ADD_BENCHMARK(uint64_t)
+ADD_BENCHMARK(uint32_t)
+ADD_BENCHMARK(uint16_t)