Merge pull request #4 from ti-uni-bielefeld/fix_vec_to_emulated_mask_conversion

jonicho · web-flow · commit 53584633b8c8 · 2025-07-12T19:42:01.000+02:00
Fix conversion from Vec to emulated Mask
diff --git a/src/lib/tsimd/mask_impl_emu.H b/src/lib/tsimd/mask_impl_emu.H
@@ -121,7 +121,13 @@ class Mask
 
 public:
   Mask() = default;
-  explicit SIMD_INLINE Mask(const Vec<T, SIMD_WIDTH> &x) : mask(x) {}
+  explicit SIMD_INLINE Mask(const Vec<T, SIMD_WIDTH> &x)
+  {
+    // shift the most significant bit into all bits
+    const auto &xInt    = reinterpret<typename TypeInfo<T>::IntegerType>(x);
+    const auto &shifted = srai<sizeof(T) * 8 - 1>(xInt);
+    mask                = reinterpret<T>(shifted);
+  }
   SIMD_INLINE Mask(const uint64_t x) : mask(int2bits<T, SIMD_WIDTH>(x)) {}
   explicit SIMD_INLINE operator Vec<T, SIMD_WIDTH>() const { return mask; }
   SIMD_INLINE operator uint64_t() const { return msb2int<T, SIMD_WIDTH>(mask); }
diff --git a/src/lib/tsimd/types.H b/src/lib/tsimd/types.H
@@ -152,6 +152,7 @@ struct TypeInfo<Byte>
   using NextLargerType = Word;
   using UnsignedType   = Byte;
   using SignedType     = SignedByte;
+  using IntegerType    = SignedByte;
 };
 
 template <>
@@ -168,6 +169,7 @@ struct TypeInfo<SignedByte>
   using NextLargerType = Short;
   using UnsignedType   = Byte;
   using SignedType     = SignedByte;
+  using IntegerType    = SignedByte;
 };
 
 template <>
@@ -181,6 +183,7 @@ struct TypeInfo<Word>
   using NextLargerType = Int; // no larger unsigned type, use Int
   using UnsignedType   = Word;
   using SignedType     = Short;
+  using IntegerType    = Short;
 };
 
 template <>
@@ -194,6 +197,7 @@ struct TypeInfo<Short>
   using NextLargerType = Int;
   using UnsignedType   = Word;
   using SignedType     = Short;
+  using IntegerType    = Short;
 };
 
 template <>
@@ -207,6 +211,7 @@ struct TypeInfo<Int>
   using NextLargerType = Long;
   using UnsignedType   = uint32_t; // not a SIMD type
   using SignedType     = Int;
+  using IntegerType    = Int;
 };
 
 template <>
@@ -220,6 +225,7 @@ struct TypeInfo<Long>
   using NextLargerType = Long;     // no larger integer type than Long
   using UnsignedType   = uint64_t; // not a SIMD type
   using SignedType     = Long;
+  using IntegerType    = Long;
 };
 
 template <>
@@ -232,6 +238,7 @@ struct TypeInfo<Float>
   using NextLargerType = Double;
   using UnsignedType   = Float; // no unsigned float type
   using SignedType     = Float;
+  using IntegerType    = Int;
 };
 
 template <>
@@ -244,6 +251,7 @@ struct TypeInfo<Double>
   using NextLargerType = Double; // no larger double type than Double
   using UnsignedType   = Double; // no unsigned double type
   using SignedType     = Double;
+  using IntegerType    = Long;
 };
 
 } // namespace types
@@ -321,6 +329,9 @@ struct TypeInfo
   /// @brief The signed type (e.g. SignedByte for Byte), or the same
   /// type if there is no signed type
   using SignedType = typename internal::types::TypeInfo<T>::SignedType;
+  /// @brief The signed integer type of the same size (e.g. SignedByte for Byte,
+  /// Int for Float)
+  using IntegerType = typename internal::types::TypeInfo<T>::IntegerType;
 };
 
 // ===========================================================================
diff --git a/src/test/autotest/core.H b/src/test/autotest/core.H
@@ -248,10 +248,15 @@ struct CmpEqual
 
   template <typename T, size_t SIMD_WIDTH>
   static bool cmpVec(SerialVec<T, SIMD_WIDTH> &expected,
-                     SerialVec<T, SIMD_WIDTH> &actual)
+                     SerialVec<T, SIMD_WIDTH> &actual,
+                     bool strictBitsCmp = false)
   {
     if (memcmp(&expected, &actual, sizeof(SerialVec<T, SIMD_WIDTH>)) == 0) {
       return true;
+    } else if (strictBitsCmp) {
+      // if strictBitsCmp is true, we only want to compare the bit patterns of
+      // the SerialVecs, so we return false here
+      return false;
     }
     for (size_t i = 0; i < SerialVec<T, SIMD_WIDTH>::elems; ++i) {
       if (!cmpScalar(expected[i], actual[i])) { return false; }
@@ -261,11 +266,11 @@ struct CmpEqual
 
   template <typename T, size_t SIMD_WIDTH>
   static bool cmpVec(SerialVec<T, SIMD_WIDTH> &expected,
-                     Vec<T, SIMD_WIDTH> &actual)
+                     Vec<T, SIMD_WIDTH> &actual, bool strictBitsCmp = false)
   {
     SerialVec<T, SIMD_WIDTH> actualSerial =
       SerialVec<T, SIMD_WIDTH>::fromVec(actual);
-    return cmpVec(expected, actualSerial);
+    return cmpVec(expected, actualSerial, strictBitsCmp);
   }
 };
 
diff --git a/src/test/autotest/mask.H b/src/test/autotest/mask.H
@@ -838,6 +838,117 @@ struct TesterMaskUnaryBool
   }
 };
 
+// =============================================================================
+// test for binary vector functions that also need a mask template parameter
+// =============================================================================
+
+template <typename T, size_t SIMD_WIDTH, template <typename, size_t> class FCT,
+          class CMP = CmpEqual>
+struct TesterBinaryWithMask
+{
+  static void test(size_t repeats, const std::string &pattern)
+  {
+    std::string name = FCT<T, SIMD_WIDTH>::name();
+    if (name.find(pattern) == std::string::npos) { return; }
+    std::string args = "v,v";
+    printInfo(name, args);
+#if !ONLY_TIME_MEASUREMENT
+    size_t errors = 0, trials = 0;
+    for (size_t i = 0; i < repeats; i++, trials++) {
+      SerialVec<T, SIMD_WIDTH> cond;
+      SerialVec<T, SIMD_WIDTH> a;
+      FCT<T, SIMD_WIDTH>::randomizeInput(cond);
+      FCT<T, SIMD_WIDTH>::randomizeInput(a);
+      SerialVec<T, SIMD_WIDTH> cs =
+        FCT<T, SIMD_WIDTH>::template apply<SerialVec, SerialMask>(cond, a);
+      SerialVec<T, SIMD_WIDTH> cp = SerialVec<T, SIMD_WIDTH>::fromVec(
+        FCT<T, SIMD_WIDTH>::template apply<Vec, Mask>(cond.getVec(),
+                                                      a.getVec()));
+      if (!CMP::cmpVec(cs, cp)) {
+        errors++;
+        if (errors <= PRINT_ERRORS) {
+          printError(name, args);
+          PRINT_VEC(T, cond);
+          PRINT_VEC(T, a);
+          PRINT_VEC(T, cs);
+          PRINT_VEC(T, cp);
+        }
+        EXIT;
+      }
+    }
+    printErrorStats(errors, trials);
+#endif
+
+    Vec<T, SIMD_WIDTH> input1, input2;
+    struct timespec start = getTimeSpecMonotonic();
+    for (size_t i = 0; i < repeats / SIMD_TIME_MEASUREMENT_UNROLL; i++) {
+      for (size_t j = 0; j < SIMD_TIME_MEASUREMENT_UNROLL; j++) {
+        doNotOptimize(input1);
+        doNotOptimize(input2);
+        Vec<T, SIMD_WIDTH> result =
+          FCT<T, SIMD_WIDTH>::template apply<Vec, Mask>(input1, input2);
+        doNotOptimize(result);
+      }
+    }
+    struct timespec end = getTimeSpecMonotonic();
+    long int time       = timeSpecDiffNsec(end, start);
+    printTimeStats(time, repeats);
+  }
+};
+
+// =============================================================================
+// test for unary mask functions that return a vector
+// =============================================================================
+
+template <typename T, size_t SIMD_WIDTH, template <typename, size_t> class FCT,
+          class CMP = CmpEqual>
+struct TesterUnaryMaskToVec
+{
+  static void test(size_t repeats, const std::string &pattern)
+  {
+    std::string name = FCT<T, SIMD_WIDTH>::name();
+    if (name.find(pattern) == std::string::npos) { return; }
+    std::string args = "m";
+    printInfo(name, args);
+#if !ONLY_TIME_MEASUREMENT
+    size_t errors = 0, trials = 0;
+    for (size_t i = 0; i < repeats; i++, trials++) {
+      SerialMask<T, SIMD_WIDTH> k;
+      FCT<T, SIMD_WIDTH>::randomizeInput(k);
+      SerialVec<T, SIMD_WIDTH> cs =
+        FCT<T, SIMD_WIDTH>::template apply<SerialVec, SerialMask>(k);
+      SerialVec<T, SIMD_WIDTH> cp = SerialVec<T, SIMD_WIDTH>::fromVec(
+        FCT<T, SIMD_WIDTH>::template apply<Vec, Mask>(k.getMask()));
+      if (!CMP::cmpVec(cs, cp, true)) {
+        errors++;
+        if (errors <= PRINT_ERRORS) {
+          printError(name, args);
+          PRINT_SERIAL_MASK(T, SIMD_WIDTH, k);
+          PRINT_VEC(T, cs);
+          PRINT_VEC(T, cp);
+        }
+        EXIT;
+      }
+    }
+    printErrorStats(errors, trials);
+#endif
+
+    Mask<T, SIMD_WIDTH> inputMask;
+    struct timespec start = getTimeSpecMonotonic();
+    for (size_t i = 0; i < repeats / SIMD_TIME_MEASUREMENT_UNROLL; i++) {
+      for (size_t j = 0; j < SIMD_TIME_MEASUREMENT_UNROLL; j++) {
+        doNotOptimize(inputMask);
+        Vec<T, SIMD_WIDTH> result =
+          FCT<T, SIMD_WIDTH>::template apply<Vec, Mask>(inputMask);
+        doNotOptimize(result);
+      }
+    }
+    struct timespec end = getTimeSpecMonotonic();
+    long int time       = timeSpecDiffNsec(end, start);
+    printTimeStats(time, repeats);
+  }
+};
+
 // =============================================================================
 // test for unary mask functions
 // =============================================================================
diff --git a/src/test/autotest/serial_mask.H b/src/test/autotest/serial_mask.H
@@ -137,14 +137,24 @@ struct SerialMask
   SerialMask(const typename _UInt<bits>::type &_mask) : mask(_mask) {}
   SerialMask(const SerialVec<T, SIMD_WIDTH> &x)
   {
+    const SerialVec<UInt<sizeof(T) * 8>, SIMD_WIDTH> &xUInt =
+      reinterpret<UInt<sizeof(T) * 8>>(x);
     mask = 0;
-    // avoids comparison with TypeInfo::trueval, which fails for
-    // Float (NaN)
-    SerialVec<T, SIMD_WIDTH> negX = bit_not(x);
     for (size_t i = 0; i < x.elements; i++) {
-      if (negX[i] == T(0)) { mask = mask | (UInt<bits>(1) << i); }
+      if ((xUInt[i] >> (sizeof(T) * 8 - 1)) != 0) {
+        mask = mask | (UInt<bits>(1) << i);
+      }
     }
   }
+  explicit operator SerialVec<T, SIMD_WIDTH>() const
+  {
+    SerialVec<T, SIMD_WIDTH> result;
+    for (size_t i = 0; i < bits; i++) {
+      result[i] =
+        (mask & (UInt<bits>(1) << i)) != 0 ? TypeInfo<T>::trueval() : T(0);
+    }
+    return result;
+  }
 
   operator UInt<bits>() const { return mask; }
   operator typename _UInt<bits>::type() const { return mask; }
diff --git a/src/test/autotest/testM.C b/src/test/autotest/testM.C
@@ -51,6 +51,9 @@ int main(int argc, char *argv[])
 
   printf("pattern \"%s\", repeats1 = %zu\n", pattern.c_str(), repeats1);
 
+  TestAll<TesterUnaryMaskToVec, SW, Mask_toVec>::test(repeats1, pattern);
+  TestAll<TesterBinaryWithMask, SW, Mask_ifelsezeroFromVec>::test(repeats1,
+                                                                  pattern);
   TestAll<TesterMaskConditionBinary, SW, Mask_ifelse>::test(repeats1, pattern);
   TestAll<TesterMaskConditionUnary, SW, Mask_ifelsezero>::test(repeats1,
                                                                pattern);
diff --git a/src/test/autotest/wrappers_mask.H b/src/test/autotest/wrappers_mask.H
@@ -41,6 +41,22 @@
 namespace simd {
 namespace auto_test {
 
+template <typename T, size_t SIMD_WIDTH>
+struct Mask_toVec
+{
+  static std::string name() { return t2s<T, SIMD_WIDTH>("Vec"); }
+  static void randomizeInput(SerialMask<T, SIMD_WIDTH> &mask)
+  {
+    mask.randomize();
+  }
+  template <template <typename, size_t> class Vec,
+            template <typename, size_t> class Mask>
+  static Vec<T, SIMD_WIDTH> apply(const Mask<T, SIMD_WIDTH> &a)
+  {
+    return Vec<T, SIMD_WIDTH>(a);
+  };
+};
+
 template <typename T, size_t SIMD_WIDTH>
 struct Mask_ifelse
 {
@@ -78,6 +94,26 @@ struct Mask_ifelsezero
   }
 };
 
+// the same as Mask_ifelsezero, but with the condition as a vector, to test
+// conversion from vector to mask
+template <typename T, size_t SIMD_WIDTH>
+struct Mask_ifelsezeroFromVec
+{
+  static std::string name() { return t2s<T, SIMD_WIDTH>("mask_ifelsezero"); }
+  static void randomizeInput(SerialMask<T, SIMD_WIDTH> &mask)
+  {
+    mask.randomize();
+  }
+  static void randomizeInput(SerialVec<T, SIMD_WIDTH> &vec) { vec.randomize(); }
+  template <template <typename, size_t> class Vec,
+            template <typename, size_t> class Mask>
+  static Vec<T, SIMD_WIDTH> apply(const Vec<T, SIMD_WIDTH> &cond,
+                                  const Vec<T, SIMD_WIDTH> &trueVal)
+  {
+    return mask_ifelsezero(Mask<T, SIMD_WIDTH>(cond), trueVal);
+  }
+};
+
 template <typename Tout, typename T, size_t SIMD_WIDTH>
 struct Mask_cvts
 {
