From b89ef09406d88a95400b0fe1498dd6aac05ab9f3 Mon Sep 17 00:00:00 2001
From: Paul Ferrand <paul@ferrand.cc>
Date: Fri, 29 May 2020 13:57:03 +0200
Subject: [PATCH] SIMD helpers  asserts are more checks

---
 src/sfizz/SIMDHelpers.h | 68 ++++++++++++++++++++---------------------
 src/sfizz/SIMDSSE.cpp   | 54 ++++++++++++++++----------------
 2 files changed, 61 insertions(+), 61 deletions(-)

diff --git a/src/sfizz/SIMDHelpers.h b/src/sfizz/SIMDHelpers.h
index 3db5d7bb..7773b794 100644
--- a/src/sfizz/SIMDHelpers.h
+++ b/src/sfizz/SIMDHelpers.h
@@ -65,8 +65,8 @@ template <class T, bool SIMD = SIMDConfig::readInterleaved>
 void readInterleaved(absl::Span<const T> input, absl::Span<T> outputLeft, absl::Span<T> outputRight) noexcept
 {
     // The size of the output is not big enough for the input...
-    ASSERT(outputLeft.size() >= input.size() / 2);
-    ASSERT(outputRight.size() >= input.size() / 2);
+    CHECK(outputLeft.size() >= input.size() / 2);
+    CHECK(outputRight.size() >= input.size() / 2);
 
     auto* in = input.begin();
     auto* lOut = outputLeft.begin();
@@ -98,8 +98,8 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::writeInterleaved>
 void writeInterleaved(absl::Span<const T> inputLeft, absl::Span<const T> inputRight, absl::Span<T> output) noexcept
 {
-    ASSERT(inputLeft.size() <= output.size() / 2);
-    ASSERT(inputRight.size() <= output.size() / 2);
+    CHECK(inputLeft.size() <= output.size() / 2);
+    CHECK(inputRight.size() <= output.size() / 2);
 
     auto* lIn = inputLeft.begin();
     auto* rIn = inputRight.begin();
@@ -142,7 +142,7 @@ void fill<float, true>(absl::Span<float> output, float value) noexcept;
 template <class Type, bool SIMD = SIMDConfig::mathfuns>
 void exp(absl::Span<const Type> input, absl::Span<Type> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto sentinel = std::min(input.size(), output.size());
     for (decltype(sentinel) i = 0; i < sentinel; ++i)
         output[i] = std::exp(input[i]);
@@ -164,7 +164,7 @@ void exp<float, true>(absl::Span<const float> input, absl::Span<float> output) n
 template <class Type, bool SIMD = SIMDConfig::mathfuns>
 void log(absl::Span<const Type> input, absl::Span<Type> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto sentinel = std::min(input.size(), output.size());
     for (decltype(sentinel) i = 0; i < sentinel; ++i)
         output[i] = std::log(input[i]);
@@ -186,7 +186,7 @@ void log<float, true>(absl::Span<const float> input, absl::Span<float> output) n
 template <class Type, bool SIMD = SIMDConfig::mathfuns>
 void sin(absl::Span<const Type> input, absl::Span<Type> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto sentinel = std::min(input.size(), output.size());
     for (decltype(sentinel) i = 0; i < sentinel; ++i)
         output[i] = std::sin(input[i]);
@@ -208,7 +208,7 @@ void sin<float, true>(absl::Span<const float> input, absl::Span<float> output) n
 template <class Type, bool SIMD = SIMDConfig::mathfuns>
 void cos(absl::Span<const Type> input, absl::Span<Type> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto sentinel = std::min(input.size(), output.size());
     for (decltype(sentinel) i = 0; i < sentinel; ++i)
         output[i] = std::cos(input[i]);
@@ -259,9 +259,9 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::saturatingSFZIndex>
 float saturatingSFZIndex(absl::Span<const T> jumps, absl::Span<T> leftCoeffs, absl::Span<T> rightCoeffs, absl::Span<int> indices, T floatIndex, T loopEnd) noexcept
 {
-    ASSERT(indices.size() >= jumps.size());
-    ASSERT(indices.size() == leftCoeffs.size());
-    ASSERT(indices.size() == rightCoeffs.size());
+    CHECK(indices.size() >= jumps.size());
+    CHECK(indices.size() == leftCoeffs.size());
+    CHECK(indices.size() == rightCoeffs.size());
 
     auto* index = indices.begin();
     auto* leftCoeff = leftCoeffs.begin();
@@ -312,9 +312,9 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::loopingSFZIndex>
 float loopingSFZIndex(absl::Span<const T> jumps, absl::Span<T> leftCoeffs, absl::Span<T> rightCoeffs, absl::Span<int> indices, T floatIndex, T loopEnd, T loopStart) noexcept
 {
-    ASSERT(indices.size() >= jumps.size());
-    ASSERT(indices.size() == leftCoeffs.size());
-    ASSERT(indices.size() == rightCoeffs.size());
+    CHECK(indices.size() >= jumps.size());
+    CHECK(indices.size() == leftCoeffs.size());
+    CHECK(indices.size() == rightCoeffs.size());
 
     auto* index = indices.begin();
     auto* leftCoeff = leftCoeffs.begin();
@@ -353,7 +353,7 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::gain>
 void applyGain(T gain, absl::Span<const T> input, absl::Span<T> output) noexcept
 {
-    ASSERT(input.size() <= output.size());
+    CHECK(input.size() <= output.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = out + std::min(output.size(), input.size());
@@ -383,8 +383,8 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::gain>
 void applyGain(absl::Span<const T> gain, absl::Span<const T> input, absl::Span<T> output) noexcept
 {
-    ASSERT(gain.size() == input.size());
-    ASSERT(input.size() <= output.size());
+    CHECK(gain.size() == input.size());
+    CHECK(input.size() <= output.size());
     auto* in = input.begin();
     auto* g = gain.begin();
     auto* out = output.begin();
@@ -451,8 +451,8 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::divide>
 void divide(absl::Span<const T> input, absl::Span<const T> divisor, absl::Span<T> output) noexcept
 {
-    ASSERT(divisor.size() == input.size());
-    ASSERT(input.size() <= output.size());
+    CHECK(divisor.size() == input.size());
+    CHECK(input.size() <= output.size());
     auto* in = input.begin();
     auto* d = divisor.begin();
     auto* out = output.begin();
@@ -507,8 +507,8 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::multiplyAdd>
 void multiplyAdd(absl::Span<const T> gain, absl::Span<const T> input, absl::Span<T> output) noexcept
 {
-    ASSERT(gain.size() == input.size());
-    ASSERT(input.size() <= output.size());
+    CHECK(gain.size() == input.size());
+    CHECK(input.size() <= output.size());
     auto* in = input.begin();
     auto* g = gain.begin();
     auto* out = output.begin();
@@ -523,7 +523,7 @@ void multiplyAdd<float, true>(absl::Span<const float> gain, absl::Span<const flo
 template <class T, bool SIMD = SIMDConfig::multiplyAdd>
 void multiplyAdd(const T gain, absl::Span<const T> input, absl::Span<T> output) noexcept
 {
-    // ASSERT(input.size() <= output.size());
+    // CHECK(input.size() <= output.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = out + std::min(output.size(), input.size());
@@ -622,7 +622,7 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::add>
 void add(absl::Span<const T> input, absl::Span<T> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = out + min(input.size(), output.size());
@@ -689,7 +689,7 @@ void subtract(const T value, absl::Span<T> output) noexcept
 template <class T, bool SIMD = SIMDConfig::subtract>
 void subtract(absl::Span<const T> input, absl::Span<T> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = out + min(input.size(), output.size());
@@ -724,7 +724,7 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::copy>
 void copy(absl::Span<const T> input, absl::Span<T> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     if (output.data() == input.data() && output.size() == input.size())
         return;
     auto* in = input.begin();
@@ -801,8 +801,8 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::pan>
 void pan(absl::Span<const T> panEnvelope, absl::Span<T> leftBuffer, absl::Span<T> rightBuffer) noexcept
 {
-    ASSERT(leftBuffer.size() >= panEnvelope.size());
-    ASSERT(rightBuffer.size() >= panEnvelope.size());
+    CHECK(leftBuffer.size() >= panEnvelope.size());
+    CHECK(rightBuffer.size() >= panEnvelope.size());
     auto* pan = panEnvelope.begin();
     auto* left = leftBuffer.begin();
     auto* right = rightBuffer.begin();
@@ -831,8 +831,8 @@ void pan<float, true>(absl::Span<const float> panEnvelope, absl::Span<float> lef
 template <class T, bool SIMD = SIMDConfig::pan>
 void width(absl::Span<const T> widthEnvelope, absl::Span<T> leftBuffer, absl::Span<T> rightBuffer) noexcept
 {
-    ASSERT(leftBuffer.size() >= widthEnvelope.size());
-    ASSERT(rightBuffer.size() >= widthEnvelope.size());
+    CHECK(leftBuffer.size() >= widthEnvelope.size());
+    CHECK(rightBuffer.size() >= widthEnvelope.size());
     auto* width = widthEnvelope.begin();
     auto* left = leftBuffer.begin();
     auto* right = rightBuffer.begin();
@@ -921,7 +921,7 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::cumsum>
 void cumsum(absl::Span<const T> input, absl::Span<T> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     if (input.size() == 0)
         return;
 
@@ -962,9 +962,9 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::sfzInterpolationCast>
 void sfzInterpolationCast(absl::Span<const T> floatJumps, absl::Span<int> jumps, absl::Span<T> leftCoeffs, absl::Span<T> rightCoeffs) noexcept
 {
-    ASSERT(jumps.size() >= floatJumps.size());
-    ASSERT(jumps.size() == leftCoeffs.size());
-    ASSERT(jumps.size() == rightCoeffs.size());
+    CHECK(jumps.size() >= floatJumps.size());
+    CHECK(jumps.size() == leftCoeffs.size());
+    CHECK(jumps.size() == rightCoeffs.size());
 
     auto floatJump = floatJumps.data();
     auto jump = jumps.data();
@@ -1003,7 +1003,7 @@ namespace _internals {
 template <class T, bool SIMD = SIMDConfig::diff>
 void diff(absl::Span<const T> input, absl::Span<T> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     if (input.size() == 0)
         return;
 
diff --git a/src/sfizz/SIMDSSE.cpp b/src/sfizz/SIMDSSE.cpp
index 1048e9cc..062d5476 100644
--- a/src/sfizz/SIMDSSE.cpp
+++ b/src/sfizz/SIMDSSE.cpp
@@ -50,10 +50,10 @@ template <>
 void sfz::readInterleaved<float, true>(absl::Span<const float> input, absl::Span<float> outputLeft, absl::Span<float> outputRight) noexcept
 {
     // The size of the outputs is not big enough for the input...
-    ASSERT(outputLeft.size() >= input.size() / 2);
-    ASSERT(outputRight.size() >= input.size() / 2);
+    CHECK(outputLeft.size() >= input.size() / 2);
+    CHECK(outputRight.size() >= input.size() / 2);
     // Input is too small
-    ASSERT(input.size() > 1);
+    CHECK(input.size() > 1);
 
     auto* in = input.begin();
     auto* lOut = outputLeft.begin();
@@ -90,8 +90,8 @@ template <>
 void sfz::writeInterleaved<float, true>(absl::Span<const float> inputLeft, absl::Span<const float> inputRight, absl::Span<float> output) noexcept
 {
     // The size of the output is not big enough for the inputs...
-    ASSERT(inputLeft.size() <= output.size() / 2);
-    ASSERT(inputRight.size() <= output.size() / 2);
+    CHECK(inputLeft.size() <= output.size() / 2);
+    CHECK(inputRight.size() <= output.size() / 2);
 
     auto* lIn = inputLeft.begin();
     auto* rIn = inputRight.begin();
@@ -146,7 +146,7 @@ void sfz::fill<float, true>(absl::Span<float> output, float value) noexcept
 template <>
 void sfz::exp<float, true>(absl::Span<const float> input, absl::Span<float> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = in + std::min(input.size(), output.size());
@@ -167,7 +167,7 @@ void sfz::exp<float, true>(absl::Span<const float> input, absl::Span<float> outp
 template <>
 void sfz::cos<float, true>(absl::Span<const float> input, absl::Span<float> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = in + std::min(input.size(), output.size());
@@ -188,7 +188,7 @@ void sfz::cos<float, true>(absl::Span<const float> input, absl::Span<float> outp
 template <>
 void sfz::log<float, true>(absl::Span<const float> input, absl::Span<float> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = in + std::min(input.size(), output.size());
@@ -209,7 +209,7 @@ void sfz::log<float, true>(absl::Span<const float> input, absl::Span<float> outp
 template <>
 void sfz::sin<float, true>(absl::Span<const float> input, absl::Span<float> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = in + std::min(input.size(), output.size());
@@ -347,9 +347,9 @@ float sfz::loopingSFZIndex<float, true>(absl::Span<const float> jumps,
     float loopEnd,
     float loopStart) noexcept
 {
-    ASSERT(indices.size() >= jumps.size());
-    ASSERT(indices.size() == leftCoeffs.size());
-    ASSERT(indices.size() == rightCoeffs.size());
+    CHECK(indices.size() >= jumps.size());
+    CHECK(indices.size() == leftCoeffs.size());
+    CHECK(indices.size() == rightCoeffs.size());
 
     auto index = indices.data();
     auto leftCoeff = leftCoeffs.data();
@@ -405,9 +405,9 @@ float sfz::saturatingSFZIndex<float, true>(absl::Span<const float> jumps,
     float floatIndex,
     float loopEnd) noexcept
 {
-    ASSERT(indices.size() >= jumps.size());
-    ASSERT(indices.size() == leftCoeffs.size());
-    ASSERT(indices.size() == rightCoeffs.size());
+    CHECK(indices.size() >= jumps.size());
+    CHECK(indices.size() == leftCoeffs.size());
+    CHECK(indices.size() == rightCoeffs.size());
 
     auto index = indices.data();
     auto leftCoeff = leftCoeffs.data();
@@ -506,7 +506,7 @@ float sfz::multiplicativeRamp<float, true>(absl::Span<float> output, float value
 template <>
 void sfz::add<float, true>(absl::Span<const float> input, absl::Span<float> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = out + min(input.size(), output.size());
@@ -547,7 +547,7 @@ void sfz::add<float, true>(float value, absl::Span<float> output) noexcept
 template <>
 void sfz::subtract<float, true>(absl::Span<const float> input, absl::Span<float> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = out + min(input.size(), output.size());
@@ -588,7 +588,7 @@ void sfz::subtract<float, true>(const float value, absl::Span<float> output) noe
 template <>
 void sfz::copy<float, true>(absl::Span<const float> input, absl::Span<float> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     auto* in = input.begin();
     auto* out = output.begin();
     auto* sentinel = out + min(input.size(), output.size());
@@ -609,8 +609,8 @@ void sfz::copy<float, true>(absl::Span<const float> input, absl::Span<float> out
 template <>
 void sfz::pan<float, true>(absl::Span<const float> panEnvelope, absl::Span<float> leftBuffer, absl::Span<float> rightBuffer) noexcept
 {
-    ASSERT(leftBuffer.size() >= panEnvelope.size());
-    ASSERT(rightBuffer.size() >= panEnvelope.size());
+    CHECK(leftBuffer.size() >= panEnvelope.size());
+    CHECK(rightBuffer.size() >= panEnvelope.size());
     auto* pan = panEnvelope.begin();
     auto* left = leftBuffer.begin();
     auto* right = rightBuffer.begin();
@@ -647,8 +647,8 @@ void sfz::pan<float, true>(absl::Span<const float> panEnvelope, absl::Span<float
 template <>
 void sfz::width<float, true>(absl::Span<const float> widthEnvelope, absl::Span<float> leftBuffer, absl::Span<float> rightBuffer) noexcept
 {
-    ASSERT(leftBuffer.size() >= widthEnvelope.size());
-    ASSERT(rightBuffer.size() >= widthEnvelope.size());
+    CHECK(leftBuffer.size() >= widthEnvelope.size());
+    CHECK(rightBuffer.size() >= widthEnvelope.size());
     auto* width = widthEnvelope.begin();
     auto* left = leftBuffer.begin();
     auto* right = rightBuffer.begin();
@@ -757,7 +757,7 @@ float sfz::meanSquared<float, true>(absl::Span<const float> vector) noexcept
 template <>
 void sfz::cumsum<float, true>(absl::Span<const float> input, absl::Span<float> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     if (input.size() == 0)
         return;
 
@@ -789,9 +789,9 @@ template <>
 void sfz::sfzInterpolationCast<float, true>(absl::Span<const float> floatJumps, absl::Span<int> jumps, absl::Span<float> leftCoeffs, absl::Span<float> rightCoeffs) noexcept
 {
     sfz::sfzInterpolationCast<float, false>(floatJumps, jumps, leftCoeffs, rightCoeffs);
-    // ASSERT(jumps.size() >= floatJumps.size());
-    // ASSERT(jumps.size() == leftCoeffs.size());
-    // ASSERT(jumps.size() == rightCoeffs.size());
+    // CHECK(jumps.size() >= floatJumps.size());
+    // CHECK(jumps.size() == leftCoeffs.size());
+    // CHECK(jumps.size() == rightCoeffs.size());
 
     // auto floatJump = floatJumps.data();
     // auto jump = jumps.data();
@@ -822,7 +822,7 @@ void sfz::sfzInterpolationCast<float, true>(absl::Span<const float> floatJumps,
 template <>
 void sfz::diff<float, true>(absl::Span<const float> input, absl::Span<float> output) noexcept
 {
-    ASSERT(output.size() >= input.size());
+    CHECK(output.size() >= input.size());
     if (input.size() == 0)
         return;