scoped_flush_denormals.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstdint>
 
#if defined(__x86_64__) || defined(_M_X64)
#define PULP_FLUSH_DENORMALS_X86 1
#if defined(_MSC_VER)
// MSVC requires the intrinsic declarations header before the SSE headers,
// including when compiling the x64 slice of an ARM64EC translation unit.
#include <intrin.h>
#endif
#include <pmmintrin.h>  // DAZ (SSE3 intrinsics header; also pulls SSE)
#include <xmmintrin.h>  // FTZ + MXCSR access
#elif (defined(__aarch64__) || defined(_M_ARM64)) && defined(__GNUC__)
#define PULP_FLUSH_DENORMALS_ARM64 1
#endif
 
namespace pulp::signal {
namespace detail {
 
#if defined(PULP_FLUSH_DENORMALS_X86)
// FTZ (bit 15) only — universally supported on SSE and never faults. DAZ
// (bit 6) is deliberately omitted; see the header doc comment.
inline constexpr unsigned int kMxcsrFtz = 0x8000u;  // flush-to-zero (results)
#elif defined(PULP_FLUSH_DENORMALS_ARM64)
inline constexpr std::uint64_t kFpcrFz = std::uint64_t(1) << 24;  // FPCR.FZ
 
inline std::uint64_t read_fpcr() noexcept {
    std::uint64_t fpcr = 0;
    __asm__ __volatile__("mrs %0, fpcr" : "=r"(fpcr));
    return fpcr;
}
inline void write_fpcr(std::uint64_t fpcr) noexcept {
    __asm__ __volatile__("msr fpcr, %0" : : "r"(fpcr));
}
#endif
 
}  // namespace detail

#if defined(PULP_FLUSH_DENORMALS_X86) || defined(PULP_FLUSH_DENORMALS_ARM64)
inline constexpr bool kHardwareFlushSupported = true;
#else
inline constexpr bool kHardwareFlushSupported = false;
#endif

inline bool denormals_are_flushed() noexcept {
#if defined(PULP_FLUSH_DENORMALS_X86)
    return (_mm_getcsr() & detail::kMxcsrFtz) != 0;
#elif defined(PULP_FLUSH_DENORMALS_ARM64)
    return (detail::read_fpcr() & detail::kFpcrFz) != 0;
#else
    return false;
#endif
}
 
class ScopedFlushDenormals {
  public:
    // Control-register writes are not free on the audio path, and many hosts
    // already run their audio threads with flush-to-zero on. Each write is
    // therefore made only when it changes the register; the observable
    // contract (FTZ on inside the scope, the caller's exact value restored on
    // exit) is unchanged.
    ScopedFlushDenormals() noexcept {
#if defined(PULP_FLUSH_DENORMALS_X86)
        saved_csr_ = _mm_getcsr();
        if ((saved_csr_ & detail::kMxcsrFtz) == 0)
            _mm_setcsr(saved_csr_ | detail::kMxcsrFtz);
#elif defined(PULP_FLUSH_DENORMALS_ARM64)
        saved_fpcr_ = detail::read_fpcr();
        if ((saved_fpcr_ & detail::kFpcrFz) == 0)
            detail::write_fpcr(saved_fpcr_ | detail::kFpcrFz);
#endif
    }
 
    ~ScopedFlushDenormals() noexcept {
#if defined(PULP_FLUSH_DENORMALS_X86)
        if (_mm_getcsr() != saved_csr_)
            _mm_setcsr(saved_csr_);
#elif defined(PULP_FLUSH_DENORMALS_ARM64)
        if (detail::read_fpcr() != saved_fpcr_)
            detail::write_fpcr(saved_fpcr_);
#endif
    }
 
    ScopedFlushDenormals(const ScopedFlushDenormals&) = delete;
    ScopedFlushDenormals& operator=(const ScopedFlushDenormals&) = delete;
    ScopedFlushDenormals(ScopedFlushDenormals&&) = delete;
    ScopedFlushDenormals& operator=(ScopedFlushDenormals&&) = delete;
 
private:
#if defined(PULP_FLUSH_DENORMALS_X86)
    unsigned int saved_csr_ = 0;
#elif defined(PULP_FLUSH_DENORMALS_ARM64)
    std::uint64_t saved_fpcr_ = 0;
#endif
};
 
}  // namespace pulp::signal