denormal.hpp

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <cstddef>
#include <cstdint>
 
namespace pulp::signal {

#ifndef PULP_DSP_ENABLE_SNAP_TO_ZERO
#define PULP_DSP_ENABLE_SNAP_TO_ZERO 1
#endif

template<typename T>
inline constexpr T snap_threshold() { return T(1e-15); }

template<typename T>
inline T snap_to_zero(T x) {
#if PULP_DSP_ENABLE_SNAP_TO_ZERO
    // One comparison on |x| rather than two joined by &&: the same result for
    // every input (NaN fails it and passes through; -0 becomes +0 as before),
    // and no short-circuit for a compiler to turn into control flow, which
    // keeps loops that snap vectorizable under GCC.
    return std::abs(x) < snap_threshold<T>() ? T(0) : x;
#else
    return x;
#endif
}

inline constexpr bool kSubnormalsAreFree =
#if defined(__aarch64__) || defined(_M_ARM64)
    true;
#else
    false;
#endif

template <typename T> inline T snap_recursion_state(T x) {
    if constexpr (kSubnormalsAreFree)
        return x;
    else
        return snap_to_zero(x);
}

template<typename T>
inline void snap_to_zero(T* samples, int n) {
#if PULP_DSP_ENABLE_SNAP_TO_ZERO
    for (int i = 0; i < n; ++i)
        samples[i] = snap_to_zero(samples[i]);
#else
    (void) samples;
    (void) n;
#endif
}

inline constexpr std::size_t kSnapChunkSamples = 64;

struct SnapChunk {
    std::size_t begin;
    std::size_t end;
};

class SnapChunks {
  public:
    explicit constexpr SnapChunks(std::size_t num_samples) noexcept : size_(num_samples) {}
 
    class iterator {
      public:
        constexpr iterator(std::size_t begin, std::size_t size) noexcept
            : begin_(begin), size_(size) {}
        constexpr SnapChunk operator*() const noexcept {
            return {begin_,
                    size_ - begin_ < kSnapChunkSamples ? size_ : begin_ + kSnapChunkSamples};
        }
        constexpr iterator& operator++() noexcept {
            begin_ = size_ - begin_ < kSnapChunkSamples ? size_ : begin_ + kSnapChunkSamples;
            return *this;
        }
        constexpr bool operator!=(const iterator& other) const noexcept {
            return begin_ != other.begin_;
        }
 
      private:
        std::size_t begin_;
        std::size_t size_;
    };
 
    constexpr iterator begin() const noexcept {
        return {0, size_};
    }
    constexpr iterator end() const noexcept {
        return {size_, size_};
    }
 
  private:
    std::size_t size_;
};
 
constexpr SnapChunks snap_chunks(std::size_t num_samples) noexcept {
    return SnapChunks(num_samples);
}

template<typename T>
inline bool is_denormal(T x) {
    return x != T(0) && std::fpclassify(x) == FP_SUBNORMAL;
}
 
} // namespace pulp::signal