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

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

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

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/RuntimeChecks.cpp

 #include <memory>
 #include <random>
 #include <stdint.h>
 
 #include "benchmark/benchmark.h"
 
+#define ITERATIONS 1000000000
+
 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++)
void benchVecWithRuntimeChecks4PointersDAfterA(benchmark::State &state) {
   for (auto _ : state) {
     callThroughOptnone(vecWithRuntimeChecks4Pointers, &A[0], &A[2 * TC],
                        &A[3 * TC], &A[2], TC, 1);
     benchmark::DoNotOptimize(A);
     benchmark::ClobberMemory();
   }
 }
 BENCHMARK(benchVecWithRuntimeChecks4PointersDAfterA)->Arg(32)->Arg(1000);
+
+// Convert each vector element from T to int8_t in a vectorized loop
+template <typename T> static void vecWithRuntimeChecksofTruncVecInLoop(T *A, const uint8_t *B, int iterations) {
+  for (unsigned i = 0; i < iterations; i++) {
+    A[i] += B[i];
+  }
+}
+
+void benchVecWithRuntimeChecksofTruncVeci64InLoop(benchmark::State &state) {
+  std::unique_ptr<uint64_t[]> A(new uint64_t[ITERATIONS]);
+  std::unique_ptr<uint8_t[]> B(new uint8_t[ITERATIONS]);
+  init_data(A, ITERATIONS);
+  init_data(B, ITERATIONS);
+  vecWithRuntimeChecksofTruncVecInLoop(&A[0], &B[0], ITERATIONS);
+  benchmark::DoNotOptimize(A);
+  benchmark::DoNotOptimize(B);
+  benchmark::ClobberMemory();
+}
+BENCHMARK(benchVecWithRuntimeChecksofTruncVeci64InLoop);