sam/sfizz
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Moved divide to the new format

Browse source
This commit is contained in:
Paul Ferrand 2020-05-30 22:26:35 +02:00 • committed by Jean Pierre Cimalando
parent 1ab1ab802b
commit 1b68331f38
4 changed files with 49 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
benchmarks/BM_divide.cpp
View file

@ -46,28 +46,28 @@ BENCHMARK_DEFINE_F(Divide, Straight)(benchmark::State& state) {
BENCHMARK_DEFINE_F(Divide, Scalar)(benchmark::State& state) {
for (auto _ : state)
{
sfz::divide<float, false>(input, divisor, absl::MakeSpan(output));
sfz::divide<float>(input, divisor, absl::MakeSpan(output));
}
}
BENCHMARK_DEFINE_F(Divide, SIMD)(benchmark::State& state) {
for (auto _ : state)
{
sfz::divide<float, true>(input, divisor, absl::MakeSpan(output));
sfz::divide<float>(input, divisor, absl::MakeSpan(output));
}
}
BENCHMARK_DEFINE_F(Divide, Scalar_Unaligned)(benchmark::State& state) {
for (auto _ : state)
{
sfz::divide<float, false>(absl::MakeSpan(input).subspan(1), absl::MakeSpan(divisor).subspan(1), absl::MakeSpan(output).subspan(1));
sfz::divide<float>(absl::MakeSpan(input).subspan(1), absl::MakeSpan(divisor).subspan(1), absl::MakeSpan(output).subspan(1));
}
}
BENCHMARK_DEFINE_F(Divide, SIMD_Unaligned)(benchmark::State& state) {
for (auto _ : state)
{
sfz::divide<float, true>(absl::MakeSpan(input).subspan(1), absl::MakeSpan(divisor).subspan(1), absl::MakeSpan(output).subspan(1));
sfz::divide<float>(absl::MakeSpan(input).subspan(1), absl::MakeSpan(divisor).subspan(1), absl::MakeSpan(output).subspan(1));
}
}

26
src/sfizz/SIMDHelpers.cpp
View file

@ -188,4 +188,30 @@ void applyGain<float>(const float* gain, const float* input, float* output, unsi
*output++ = (*gain++) * (*input++);
}
template <>
void sfz::divide<float>(const float* input, const float* divisor, float* output, unsigned size) noexcept
{
const auto sentinel = output + size;
if (getSIMDOpStatus(SIMDOps::divide)) {
#if SFIZZ_CPU_FAMILY_X86_64 || SFIZZ_CPU_FAMILY_I386
if (cpuInfo.has_sse()) {
const auto* lastAligned = prevAligned(sentinel);
while (unaligned(input, output) && output < lastAligned)
*output++ = (*input++) / (*divisor++);
while (output < lastAligned) {
_mm_store_ps(output, _mm_div_ps(_mm_load_ps(input), _mm_load_ps(divisor)));
incrementAll<4>(divisor, input, output);
}
// fallthrough from lastAligned to sentinel
}
#endif
}
while (output < sentinel)
*output++ = (*input++) / (*divisor++);
}
}

45
src/sfizz/SIMDHelpers.h
View file

@ -242,56 +242,49 @@ inline void applyGain(absl::Span<const T> gain, absl::Span<T> array) noexcept
applyGain<T>(gain.data(), array.data(), array.data(), minSpanSize(gain, array));
}
namespace _internals {
template <class T>
inline void snippetDivSpan(const T*& input, const T*& divisor,T*& output)
{
*output++ = (*input++) / (*divisor++);
}
}
/**
* @brief Divide a vector by another vector
*
* The output size will be the minimum of the divisor, input span and output span size.
*
* @tparam T the underlying type
* @tparam SIMD use the SIMD version or the scalar version
* @param input
* @param divisor
* @param output
* @param size
*/
template <class T, bool SIMD = SIMDConfig::divide>
void divide(absl::Span<const T> input, absl::Span<const T> divisor, absl::Span<T> output) noexcept
template <class T>
void divide(const T* input, const T* divisor, T* output, unsigned size) noexcept
{
CHECK(divisor.size() == input.size());
CHECK(input.size() <= output.size());
auto* in = input.begin();
auto* d = divisor.begin();
auto* out = output.begin();
auto* sentinel = out + std::min(divisor.size(), std::min(output.size(), input.size()));
while (out < sentinel)
_internals::snippetDivSpan<T>(in, d, out);
const auto sentinel = output + size;
while (output < sentinel)
*output++ = (*input++) / (*divisor++);
}
template <>
void divide<float>(const float* input, const float* divisor, float* output, unsigned size) noexcept;
template <class T>
inline void divide(absl::Span<const T> input, absl::Span<const T> divisor, absl::Span<T> output) noexcept
{
CHECK_SPAN_SIZES(input, divisor, output);
divide<T>(input.data(), divisor.data(), output.data(), minSpanSize(input, divisor, output));
}
/**
* @brief Divide a vector by another in place
*
* @tparam T the underlying type
* @tparam SIMD use the SIMD version or the scalar version
* @param output
* @param divisor
*/
template <class T, bool SIMD = SIMDConfig::divide>
template <class T>
void divide(absl::Span<T> output, absl::Span<const T> divisor) noexcept
{
divide<T, SIMD>(output, divisor, output);
CHECK_SPAN_SIZES(divisor, output);
divide<T>(output.data(), divisor.data(), output.data(), minSpanSize(divisor, output));
}
template <>
void divide<float, true>(absl::Span<const float> input, absl::Span<const float> divisor, absl::Span<float> output) noexcept;
namespace _internals {
template <class T>
inline void snippetMultiplyAdd(const T*& gain, const T*& input, T*& output)

24
src/sfizz/SIMDSSE.cpp
View file

@ -16,30 +16,6 @@
constexpr uintptr_t TypeAlignment = 4;
template <>
void sfz::divide<float, true>(absl::Span<const float> input, absl::Span<const float> divisor, absl::Span<float> output) noexcept
{
auto* in = input.begin();
auto* out = output.begin();
auto* div = divisor.begin();
const auto size = std::min(output.size(), std::min(input.size(), divisor.size()));
const auto* lastAligned = prevAligned(output.begin() + size);
while (unaligned(out, in, div) && out < lastAligned)
_internals::snippetDivSpan<float>(in, div, out);
while (out < lastAligned) {
_mm_store_ps(out, _mm_div_ps(_mm_load_ps(in), _mm_load_ps(div)));
incrementAll<TypeAlignment>(in, div, out);
}
while (out < output.end())
_internals::snippetDivSpan<float>(in, div, out);
}
template <>
void sfz::multiplyAdd<float, true>(absl::Span<const float> gain, absl::Span<const float> input, absl::Span<float> output) noexcept
{