Make PFFFT functions non-blocking

Author: kcat

common/pffft.cpp

@@ -328,7 +328,7 @@ force_inline constexpr auto ld_ps1(float a) noexcept -> v4sf { return a; }
 [[maybe_unused, nodiscard]] inline
 auto valigned(const float *ptr) noexcept -> bool
 {
-    static constexpr auto alignmask = uintptr_t{SimdSize*sizeof(float) - 1};
+    constexpr auto alignmask = uintptr_t{SimdSize*sizeof(float) - 1};
     return (std::bit_cast<uintptr_t>(ptr) & alignmask) == 0;
 }
 #endif
@@ -812,9 +812,9 @@ void radf3_ps(const size_t ido, const size_t l1, const v4sf *RESTRICT cc, v4sf *
 void radb3_ps(const size_t ido, const size_t l1, const v4sf *RESTRICT cc, v4sf *RESTRICT ch,
     const float *const wa1)
 {
-    static constexpr auto taur = -0.5f;
-    static constexpr auto taui = 0.866025403784439f;
-    static constexpr auto taui_2 = taui*2.0f;
+    constexpr auto taur = -0.5f;
+    constexpr auto taui = 0.866025403784439f;
+    constexpr auto taui_2 = taui*2.0f;
 
     const auto vtaur = ld_ps1(taur);
     const auto vtaui_2 = ld_ps1(taui_2);
@@ -1789,7 +1789,7 @@ force_inline void pffft_real_finalize_4x4(const v4sf *in0, const v4sf *in1, cons
 NOINLINE void pffft_real_finalize(const size_t Ncvec, const v4sf *in, v4sf *RESTRICT out,
     const v4sf *e)
 {
-    static constexpr auto s = std::numbers::sqrt2_v<float>/2.0f;
+    constexpr auto s = std::numbers::sqrt2_v<float>/2.0f;
 
     Expects(in != out);
     const auto dk = size_t{Ncvec/SimdSize}; // number of 4x4 matrix blocks
@@ -1890,7 +1890,7 @@ force_inline void pffft_real_preprocess_4x4(const v4sf *in, const v4sf *e, v4sf
 NOINLINE void pffft_real_preprocess(const size_t Ncvec, const v4sf *in, v4sf *RESTRICT out,
     const v4sf *e)
 {
-    static constexpr auto sqrt2 = std::numbers::sqrt2_v<float>;
+    constexpr auto sqrt2 = std::numbers::sqrt2_v<float>;
 
     Expects(in != out);
     const auto dk = size_t{Ncvec/SimdSize}; // number of 4x4 matrix blocks
@@ -2172,7 +2172,7 @@ void pffft_zconvolve_accumulate_internal(const PFFFT_Setup *s, const v4sf *RESTR
  * vectors, these casts are needed.
  */
 void pffft_zreorder(const PFFFT_Setup *setup, const float *in, float *out,
-    pffft_direction_t direction)
+    pffft_direction_t direction) noexcept NONBLOCKING
 {
     Expects(in != out);
     Expects(valigned(in) && valigned(out));
@@ -2181,22 +2181,23 @@ void pffft_zreorder(const PFFFT_Setup *setup, const float *in, float *out,
 }
 
 void pffft_zconvolve_scale_accumulate(const PFFFT_Setup *s, const float *a, const float *b,
-    float *ab, float scaling)
+    float *ab, float scaling) noexcept NONBLOCKING
 {
     Expects(valigned(a) && valigned(b) && valigned(ab));
     pffft_zconvolve_scale_accumulate_internal(s, reinterpret_cast<const v4sf*>(a),
         reinterpret_cast<const v4sf*>(b), reinterpret_cast<v4sf*>(ab), scaling);
 }
 
 void pffft_zconvolve_accumulate(const PFFFT_Setup *s, const float *a, const float *b, float *ab)
+    noexcept NONBLOCKING
 {
     Expects(valigned(a) && valigned(b) && valigned(ab));
     pffft_zconvolve_accumulate_internal(s, reinterpret_cast<const v4sf*>(a),
         reinterpret_cast<const v4sf*>(b), reinterpret_cast<v4sf*>(ab));
 }
 
 void pffft_transform(const PFFFT_Setup *setup, const float *input, float *output, float *work,
-    pffft_direction_t direction)
+    pffft_direction_t direction) noexcept NONBLOCKING
 {
     Expects(valigned(input) && valigned(output) && valigned(work));
     pffft_transform_internal(setup, reinterpret_cast<const v4sf*>(std::assume_aligned<16>(input)),
@@ -2205,7 +2206,7 @@ void pffft_transform(const PFFFT_Setup *setup, const float *input, float *output
 }
 
 void pffft_transform_ordered(const PFFFT_Setup *setup, const float *input, float *output,
-    float *work, pffft_direction_t direction)
+    float *work, pffft_direction_t direction) noexcept NONBLOCKING
 {
     Expects(valigned(input) && valigned(output) && valigned(work));
     pffft_transform_internal(setup, reinterpret_cast<const v4sf*>(std::assume_aligned<16>(input)),
@@ -2273,7 +2274,7 @@ void pffft_transform_internal(const PFFFT_Setup *setup, const float *input, floa
 } // namespace
 
 void pffft_zreorder(const PFFFT_Setup *setup, const float *in, float *RESTRICT out,
-    pffft_direction_t direction)
+    pffft_direction_t direction) noexcept NONBLOCKING
 {
     const auto N = size_t{setup->N};
     if(setup->transform == PFFFT_COMPLEX)
@@ -2300,7 +2301,7 @@ void pffft_zreorder(const PFFFT_Setup *setup, const float *in, float *RESTRICT o
 }
 
 void pffft_zconvolve_scale_accumulate(const PFFFT_Setup *s, const float *a, const float *b,
-    float *ab, float scaling)
+    float *ab, float scaling) noexcept NONBLOCKING
 {
     auto Ncvec = size_t{s->Ncvec};
 
@@ -2324,6 +2325,7 @@ void pffft_zconvolve_scale_accumulate(const PFFFT_Setup *s, const float *a, cons
 }
 
 void pffft_zconvolve_accumulate(const PFFFT_Setup *s, const float *a, const float *b, float *ab)
+    noexcept NONBLOCKING
 {
     auto Ncvec = size_t{s->Ncvec};
 
@@ -2348,13 +2350,13 @@ void pffft_zconvolve_accumulate(const PFFFT_Setup *s, const float *a, const floa
 
 
 void pffft_transform(const PFFFT_Setup *setup, const float *input, float *output, float *work,
-    pffft_direction_t direction)
+    pffft_direction_t direction) noexcept NONBLOCKING
 {
     pffft_transform_internal(setup, input, output, work, direction, false);
 }
 
 void pffft_transform_ordered(const PFFFT_Setup *setup, const float *input, float *output,
-    float *work, pffft_direction_t direction)
+    float *work, pffft_direction_t direction) noexcept NONBLOCKING
 {
     pffft_transform_internal(setup, input, output, work, direction, true);
 }

common/pffft.h

@@ -84,6 +84,7 @@
 #include <memory>
 
 #include "almalloc.h"
+#include "opthelpers.h"
 
 
 /* opaque struct holding internal stuff (precomputed twiddle factors) this
@@ -125,7 +126,8 @@ PFFFTSetupPtr pffft_new_setup(unsigned int N, pffft_transform_t transform);
  *
  * The input and output parameters may alias.
  */
-void pffft_transform(const PFFFT_Setup *setup, const float *input, float *output, float *work, pffft_direction_t direction);
+void pffft_transform(const PFFFT_Setup *setup, const float *input, float *output, float *work,
+    pffft_direction_t direction) noexcept NONBLOCKING;
 
 /**
  * Similar to pffft_transform, but handles the complex values in the usual form
@@ -137,7 +139,8 @@ void pffft_transform(const PFFFT_Setup *setup, const float *input, float *output
  *
  * The input and output parameters may alias.
  */
-void pffft_transform_ordered(const PFFFT_Setup *setup, const float *input, float *output, float *work, pffft_direction_t direction);
+void pffft_transform_ordered(const PFFFT_Setup *setup, const float *input, float *output,
+    float *work, pffft_direction_t direction) noexcept NONBLOCKING;
 
 /**
  * Reorder the z-domain data. For PFFFT_FORWARD, it reorders from the internal
@@ -148,7 +151,8 @@ void pffft_transform_ordered(const PFFFT_Setup *setup, const float *input, float
  *
  * The input and output parameters should not alias.
  */
-void pffft_zreorder(const PFFFT_Setup *setup, const float *input, float *output, pffft_direction_t direction);
+void pffft_zreorder(const PFFFT_Setup *setup, const float *input, float *output,
+    pffft_direction_t direction) noexcept NONBLOCKING;
 
 /**
  * Perform a multiplication of the z-domain data in dft_a and dft_b, and scale
@@ -161,7 +165,8 @@ void pffft_zreorder(const PFFFT_Setup *setup, const float *input, float *output,
  *
  * The dft_a, dft_b, and dft_ab parameters may alias.
  */
-void pffft_zconvolve_scale_accumulate(const PFFFT_Setup *setup, const float *dft_a, const float *dft_b, float *dft_ab, float scaling);
+void pffft_zconvolve_scale_accumulate(const PFFFT_Setup *setup, const float *dft_a,
+    const float *dft_b, float *dft_ab, float scaling) noexcept NONBLOCKING;
 
 /**
  * Perform a multiplication of the z-domain data in dft_a and dft_b, and
@@ -171,7 +176,8 @@ void pffft_zconvolve_scale_accumulate(const PFFFT_Setup *setup, const float *dft
  *
  * The dft_a, dft_b, and dft_ab parameters may alias.
  */
-void pffft_zconvolve_accumulate(const PFFFT_Setup *setup, const float *dft_a, const float *dft_b, float *dft_ab);
+void pffft_zconvolve_accumulate(const PFFFT_Setup *setup, const float *dft_a, const float *dft_b,
+    float *dft_ab) noexcept NONBLOCKING;
 
 
 struct PFFFTSetup {