[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

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

42 ↗

(On Diff #501274)

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

+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <functional>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <random>
+#include <type_traits>
+
+static std::mt19937 rng;
+
+// 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<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 Ty Reference, const Ty ToCheck, unsigned NumElements) {
+  if (Reference != ToCheck) {
+    std::cerr << "Miscompare\n";
+    exit(1);
+  }
+}
+
+#define DEFINE_SCALAR_AND_VECTOR_FN2(Init, Loop, Post)                         \
+  auto ScalarFn = [](auto *cond0, auto *cond1, auto *data0, auto *data1,       \
+                     unsigned N) {                                             \
+    Init _Pragma("clang loop vectorize(disable)") Loop Post                    \
+  };                                                                           \
+  auto VectorFn = [](auto *cond0, auto *cond1, auto *data0, auto *data1,       \
+                     unsigned N) {                                             \
+    Init _Pragma("clang loop vectorize(enable)") Loop Post                     \
+  };
+
+template <typename Ty>
+using Fn2Ty = std::function<Ty(bool *, bool *, Ty *, Ty *, unsigned)>;
+
+template <typename Ty>
+static void checkVectorFunction(Fn2Ty<Ty> ScalarFn, Fn2Ty<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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+      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_FN2(
+       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_FN2(
+      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;
+}