[SingleSource/Vectorizer] Add unit tests for conditional scalar assignment pattern.

[michaelmaitland]

Summary

Dedicated unit tests for loops which contain a conditional assignment inside
the loop body.

[fhahn]

I think this is missing a cas.reference_output file? It might also be good to use a more descriptive file name.

SingleSource/UnitTests/Vectorizer/csa.cpp

13 ↗

(On Diff #500883)

I just landed D143377 which moves some of the helpers to a header. It would be good to use those instead of duplicating them here.

[michaelmaitland]

• Add reference output file.
• Use more descriptive file name.
• Move helperes into common header file.

[michaelmaitland]

Remove swp files.

[Mel-Chen]

SingleSource/UnitTests/Vectorizer/conditional_scalar_assignment.cpp

43

Why Post? How about put the return statement behind the main loop?

DEFINE_SCALAR_AND_VECTOR_FN4(
      int t = -1;,
      for (int i = 0; i < N; i++) {
        if (i < data0[i])
          t = data0[i];
      }
      return t;,
      );

[michaelmaitland]

Remove Post from Macro

[michaelmaitland]

kindly pinging.

SingleSource/UnitTests/Vectorizer/common.h

 #include <memory>
 #include <random>
+#include <type_traits>
 
 #define DEFINE_SCALAR_AND_VECTOR_FN2(Init, Loop)                               \
   auto ScalarFn = [](auto *A, auto *B, unsigned TC) {                          \
     Init _Pragma("clang loop vectorize(disable) interleave_count(1)") Loop     \
   };                                                                           \
   auto VectorFn = [](auto *A, auto *B, unsigned TC) {                          \
     Init _Pragma("clang loop vectorize(enable)") Loop                          \
   };
 
 #define DEFINE_SCALAR_AND_VECTOR_FN3(Loop)                                     \
   auto ScalarFn = [](auto *A, auto *B, auto *C, unsigned TC) {                 \
     _Pragma("clang loop vectorize(disable) interleave_count(1)") Loop          \
   };                                                                           \
   auto VectorFn = [](auto *A, auto *B, auto *C, unsigned TC) {                 \
     _Pragma("clang loop vectorize(enable)") Loop                               \
   };
 
+#define DEFINE_SCALAR_AND_VECTOR_FN4(Init, Loop)                               \
+  auto ScalarFn = [](auto *cond0, auto *cond1, auto *data0, auto *data1,       \
+                     unsigned N) {                                             \
+    Init _Pragma("clang loop vectorize(disable)") Loop                         \
+  };                                                                           \
+  auto VectorFn = [](auto *cond0, auto *cond1, auto *data0, auto *data1,       \
+                     unsigned N) {                                             \
+    Init _Pragma("clang loop vectorize(enable)") Loop                          \
+  };
+
+
 static std::mt19937 rng;
 
-// Initialize arrays A with random numbers.
-template <typename Ty>
-static void init_data(const std::unique_ptr<Ty[]> &A, unsigned N) {
+// Initialize arrays A with random integers.
+template <typename Int,
+          std::enable_if_t<std::is_integral<Int>::value, bool> = true>
+static void init_data(const std::unique_ptr<Int[]> &A, unsigned N) {
   std::uniform_int_distribution<uint64_t> distrib(
-      std::numeric_limits<Ty>::min(), std::numeric_limits<Ty>::max());
+      std::numeric_limits<Int>::min(), std::numeric_limits<Int>::max());
+  for (unsigned i = 0; i < N; i++)
+    A[i] = distrib(rng);
+}
+
+// Initialize arrays A with random floating points.
+template <typename Float,
+          std::enable_if_t<std::is_floating_point<Float>::value, bool> = true>
+static void init_data(const std::unique_ptr<Float[]> &A, unsigned N) {
+  std::uniform_real_distribution<float> distrib(
+      std::numeric_limits<Float>::min(), std::numeric_limits<Float>::max());
   for (unsigned i = 0; i < N; i++)
     A[i] = distrib(rng);
 }
 
+// Initialize arrays A with random booleans.
+static void init_cond(const std::unique_ptr<bool[]> &A, unsigned N) {
+  std::uniform_int_distribution<uint64_t> distrib(0, 1);
+  for (unsigned i = 0; i < N; i++)
+    A[i] = !!distrib(rng);
+}
+
 template <typename Ty>
 static void check(const std::unique_ptr<Ty[]> &Reference,
                   const std::unique_ptr<Ty[]> &Tmp, unsigned NumElements) {
   if (!std::equal(&Reference[0], &Reference[0] + NumElements, &Tmp[0])) {
     std::cerr << "Miscompare\n";
     exit(1);
   }
 }
+
+template <typename Ty>
+static void check(const Ty Reference, const Ty ToCheck, unsigned NumElements) {
+  if (Reference != ToCheck) {
+    std::cerr << "Miscompare\n";
+    exit(1);
+  }
+}

SingleSource/UnitTests/Vectorizer/conditional_scalar_assignment.cpp

+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <functional>
+#include <iostream>
+
+#include "common.h"
+
+template <typename Ty>
+using Fn4Ty = std::function<Ty(bool *, bool *, Ty *, Ty *, unsigned)>;
+
+template <typename Ty>
+static void checkVectorFunction(Fn4Ty<Ty> ScalarFn, Fn4Ty<Ty> VectorFn,
+                                const char *Name) {
+  std::cout << "Checking " << Name << "\n";
+
+  unsigned N = 1000;
+  std::unique_ptr<bool[]> Cond0(new bool[N]);
+  std::unique_ptr<bool[]> Cond1(new bool[N]);
+  std::unique_ptr<Ty[]> Data0(new Ty[N]);
+  std::unique_ptr<Ty[]> Data1(new Ty[N]);
+  init_cond(Cond0, N);
+  init_cond(Cond1, N);
+  init_data(Data0, N);
+  init_data(Data1, N);
+  
+  Ty Reference = ScalarFn(&Cond0[0], &Cond1[0], &Data0[0], &Data1[0], N);
+  Ty ToCheck = VectorFn(&Cond0[0], &Cond1[0], &Data0[0], &Data1[0], N);
+  check(Reference, ToCheck, N);
+}
+
+int main(void) {
+  rng = std::mt19937(15);
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      int t = -1;,
+      for (int i = 0; i < N; i++) {
+        if (i < data0[i])
+          t = data0[i];
+      }
+      return t;);
+    checkVectorFunction<uint32_t>(ScalarFn, VectorFn, "simple_csa_int_select");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      float t = 1.0f;,
+      for (int i = 0; i < N; i++) {
+        if (0.0f < data0[i])
+          t = data0[i];
+      }
+      return t; // use t
+    );
+    checkVectorFunction<float>(ScalarFn, VectorFn, "simple_csa_float_select");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      int t = -1;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i])
+          t = data0[i];
+      }
+      return t; // use t
+    );
+    checkVectorFunction<uint32_t>(ScalarFn, VectorFn, "simple_csa_int");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      float t = 1.0f;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i])
+          t = data0[i];
+      }
+      return t; // use t
+    );
+    checkVectorFunction<float>(ScalarFn, VectorFn, "simple_csa_float");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      int t = -1; int s = -1;,
+      for (int i = 0; i < N; i++) {
+        if (i < data0[i])
+          t = data0[i];
+        if (i < data1[i])
+          s = data1[i];
+      }
+      return t | s; // use t and s
+    );
+    checkVectorFunction<uint32_t>(ScalarFn, VectorFn,
+                                  "csa_in_series_int_select");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      float t = 1.0f; float s = 1.0f;,
+      for (int i = 0; i < N; i++) {
+        if (0.0f < data0[i])
+          t = data0[i];
+        if (0.0f < data1[i])
+          s = data1[i];
+      }
+      return t + s; // use t and s
+    );
+    checkVectorFunction<float>(ScalarFn, VectorFn,
+                               "csa_in_series_float_select");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      int t = -1; int s = -1;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i])
+          t = data0[i];
+        if (cond1[i])
+          s = data1[i];
+      }
+      return t | s; // use t and s
+    );
+    checkVectorFunction<uint32_t>(ScalarFn, VectorFn, "csa_in_series_int");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      float t = 1.0f; float s = 1.0f;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i])
+          t = data0[i];
+        if (cond1[i])
+          s = data1[i];
+      }
+      return t + s; // use t and s
+    );
+    checkVectorFunction<float>(ScalarFn, VectorFn, "csa_in_series_float");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      int t = -1;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i])
+          t = data0[i];
+        if (cond1[i])
+          t = data1[i];
+      }
+      return t; // use t
+    );
+    checkVectorFunction<uint32_t>(ScalarFn, VectorFn,
+                                  "csa_in_series_same_scalar_int");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      float t = 1.0f;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i])
+          t = data0[i];
+        if (cond1[i])
+          t = data1[i];
+      }
+      return t; // use t
+    );
+    checkVectorFunction<uint32_t>(ScalarFn, VectorFn,
+                                  "csa_in_series_same_scalar_float");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      int t = -1; int s = -1;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i]) {
+          t = data0[i];
+          s = data1[i];
+        }
+      }
+      return t | s; // use t and s
+    );
+    checkVectorFunction<uint32_t>(ScalarFn, VectorFn, "csa_same_cond_int");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      float t = 1.0f; float s = 1.0f;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i]) {
+          t = data0[i];
+          s = data1[i];
+        }
+      }
+      return t + s; // use t and s
+    );
+    checkVectorFunction<float>(ScalarFn, VectorFn, "csa_same_cond_float");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      int t = -1;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i])
+          t = data0[i];
+        else if (cond1[i])
+          t = data1[i];
+      }
+      return t; // use t
+    );
+    checkVectorFunction<uint32_t>(ScalarFn, VectorFn,
+                                  "csa_else_if_same_scalar_int");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      float t = 1.0f;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i])
+          t = data0[i];
+        else if (cond1[i])
+          t = data1[i];
+      }
+      return t; // use t
+    );
+    checkVectorFunction<float>(ScalarFn, VectorFn,
+                               "csa_else_if_same_scalar_float");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+       int t = -1; int s = -1;,
+       for (int i = 0; i < N; i++) {
+         if (cond0[i])
+           t = data0[i];
+         else if (cond1[i])
+           s = data1[i];
+       }
+       return t | s; // use t and s
+    );
+    checkVectorFunction<uint32_t>(ScalarFn, VectorFn, "csa_else_if_int");
+  }
+
+  {
+    DEFINE_SCALAR_AND_VECTOR_FN4(
+      float t = 1.0f; float s = 1.0f;,
+      for (int i = 0; i < N; i++) {
+        if (cond0[i])
+          t = data0[i];
+        else if (cond1[i])
+          s = data1[i];
+      }
+      return t + s; // use t and s
+    );
+    checkVectorFunction<float>(ScalarFn, VectorFn, "csa_else_if_float");
+  }
+  return 0;
+}

SingleSource/UnitTests/Vectorizer/conditional_scalar_assignment.reference_output

+Checking simple_csa_int_select
+Checking simple_csa_float_select
+Checking simple_csa_int
+Checking simple_csa_float
+Checking csa_in_series_int_select
+Checking csa_in_series_float_select
+Checking csa_in_series_int
+Checking csa_in_series_float
+Checking csa_in_series_same_scalar_int
+Checking csa_in_series_same_scalar_float
+Checking csa_same_cond_int
+Checking csa_same_cond_float
+Checking csa_else_if_same_scalar_int
+Checking csa_else_if_same_scalar_float
+Checking csa_else_if_int
+Checking csa_else_if_float
+exit 0