From 0212d8a76a7ba8fa0c23a0b9dfba09414876848e Mon Sep 17 00:00:00 2001 From: Paul Ferrand Date: Fri, 7 Feb 2020 11:11:22 +0100 Subject: [PATCH 1/8] Add new benchmarks for the filters --- benchmarks/BM_filterModulation.cpp | 135 +++++++++++++ benchmarks/BM_filterStereoMono.cpp | 293 +++++++++++++++++++++++++++++ benchmarks/CMakeLists.txt | 10 + 3 files changed, 438 insertions(+) create mode 100644 benchmarks/BM_filterModulation.cpp create mode 100644 benchmarks/BM_filterStereoMono.cpp diff --git a/benchmarks/BM_filterModulation.cpp b/benchmarks/BM_filterModulation.cpp new file mode 100644 index 00000000..32640c41 --- /dev/null +++ b/benchmarks/BM_filterModulation.cpp @@ -0,0 +1,135 @@ +// SPDX-License-Identifier: BSD-2-Clause + +// This code is part of the sfizz library and is licensed under a BSD 2-clause +// license. You should have receive a LICENSE.md file along with the code. +// If not, contact the sfizz maintainers at https://github.com/sfztools/sfizz + +#include "SIMDHelpers.h" +#include "OnePoleFilter.h" +#include "SfzFilter.h" +#include +#include +#include +#include +#include +#include + +constexpr int blockSize { 1024 }; +constexpr float sampleRate { 48000.0f }; + +class FilterFixture : public benchmark::Fixture { +public: + void SetUp(const ::benchmark::State& state) { + input = std::vector(blockSize); + output = std::vector(blockSize); + cutoff = std::vector(blockSize); + q = std::vector(blockSize); + pksh = std::vector(blockSize); + sfz::linearRamp(absl::MakeSpan(cutoff), 500, 1.0f); + sfz::linearRamp(absl::MakeSpan(q), 0.0f, 0.001f); + sfz::linearRamp(absl::MakeSpan(pksh), 0.0f, 0.001f); + std::generate(input.begin(), input.end(), [&]() { return dist(gen); }); + } + + void TearDown(const ::benchmark::State& state [[maybe_unused]]) { + + } + std::random_device rd { }; + std::mt19937 gen { rd() }; + std::normal_distribution dist { 0, 0.5 }; + std::vector cutoff; + std::vector q; + std::vector pksh; + std::vector input; + std::vector output; +}; + +BENCHMARK_DEFINE_F(FilterFixture, OnePole_VA)(benchmark::State& state) { + sfz::OnePoleFilter filter; + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto inputIterator = input.begin(); + auto outputIterator = output.begin(); + while (cutoffIterator < cutoff.end()) + { + const auto gain = sfz::OnePoleFilter::normalizedGain(*cutoffIterator, sampleRate); + filter.setGain(gain); + filter.processLowpass({ inputIterator.base(), step }, { outputIterator.base(), step } ); + cutoffIterator += step; + inputIterator += step; + outputIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, OnePole_Faust)(benchmark::State& state) { + sfz::Filter<1> filter; + filter.setType(sfz::FilterType::kFilterLpf1p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto inputIterator = input.begin(); + auto outputIterator = output.begin(); + while (cutoffIterator < cutoff.end()) + { + filter.process(&inputIterator.base(), &outputIterator.base(), *cutoffIterator, 0.0, 0.0, step); + cutoffIterator += step; + inputIterator += step; + outputIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Faust)(benchmark::State& state) { + sfz::Filter<1> filter; + filter.setType(sfz::FilterType::kFilterLpf2p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto qIterator = q.begin(); + auto inputIterator = input.begin(); + auto outputIterator = output.begin(); + while (cutoffIterator < cutoff.end()) + { + filter.process(&inputIterator.base(), &outputIterator.base(), *cutoffIterator, *qIterator, 0.0, step); + qIterator += step; + cutoffIterator += step; + inputIterator += step; + outputIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, TwoPoleShelf_Faust)(benchmark::State& state) { + sfz::Filter<1> filter; + filter.setType(sfz::FilterType::kFilterLsh); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto qIterator = q.begin(); + auto pkshIterator = pksh.begin(); + auto inputIterator = input.begin(); + auto outputIterator = output.begin(); + while (cutoffIterator < cutoff.end()) + { + filter.process(&inputIterator.base(), &outputIterator.base(), *cutoffIterator, *qIterator, *pkshIterator, step); + qIterator += step; + cutoffIterator += step; + pkshIterator += step; + inputIterator += step; + outputIterator += step; + } + } +} + +BENCHMARK_REGISTER_F(FilterFixture, OnePole_VA)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, OnePole_Faust)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, TwoPole_Faust)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, TwoPoleShelf_Faust)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_MAIN(); + diff --git a/benchmarks/BM_filterStereoMono.cpp b/benchmarks/BM_filterStereoMono.cpp new file mode 100644 index 00000000..d7168ed1 --- /dev/null +++ b/benchmarks/BM_filterStereoMono.cpp @@ -0,0 +1,293 @@ +// SPDX-License-Identifier: BSD-2-Clause + +// This code is part of the sfizz library and is licensed under a BSD 2-clause +// license. You should have receive a LICENSE.md file along with the code. +// If not, contact the sfizz maintainers at https://github.com/sfztools/sfizz + +#include "SIMDHelpers.h" +#include "OnePoleFilter.h" +#include "SfzFilter.h" +#include +#include +#include +#include +#include +#include + +constexpr int blockSize { 1024 }; +constexpr float sampleRate { 48000.0f }; + +class FilterFixture : public benchmark::Fixture { +public: + void SetUp(const ::benchmark::State& state) { + inputLeft = std::vector(blockSize); + inputRight = std::vector(blockSize); + outputLeft = std::vector(blockSize); + outputRight = std::vector(blockSize); + cutoff = std::vector(blockSize); + q = std::vector(blockSize); + pksh = std::vector(blockSize); + sfz::linearRamp(absl::MakeSpan(cutoff), 500, 1.0f); + sfz::linearRamp(absl::MakeSpan(q), 0.0f, 0.001f); + sfz::linearRamp(absl::MakeSpan(pksh), 0.0f, 0.001f); + std::generate(inputLeft.begin(), inputLeft.end(), [&]() { return dist(gen); }); + std::generate(inputRight.begin(), inputRight.end(), [&]() { return dist(gen); }); + } + + void TearDown(const ::benchmark::State& state [[maybe_unused]]) { + + } + std::random_device rd { }; + std::mt19937 gen { rd() }; + std::normal_distribution dist { 0, 0.5 }; + std::vector cutoff; + std::vector q; + std::vector pksh; + std::vector inputLeft; + std::vector inputRight; + std::vector outputLeft; + std::vector outputRight; +}; + +BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoOnce)(benchmark::State& state) { + sfz::Filter<1> filterLeft; + sfz::Filter<1> filterRight; + filterLeft.setType(sfz::FilterType::kFilterLpf1p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto inLIterator = inputLeft.begin(); + auto outLIterator = outputRight.begin(); + while (cutoffIterator < cutoff.end()) + { + filterLeft.process( &inLIterator.base(), &outLIterator.base(), *cutoffIterator, 0.0, 0.0, step); + cutoffIterator += step; + inLIterator += step; + outLIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoTwice)(benchmark::State& state) { + sfz::Filter<1> filterLeft; + sfz::Filter<1> filterRight; + filterLeft.setType(sfz::FilterType::kFilterLpf1p); + filterRight.setType(sfz::FilterType::kFilterLpf1p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto inLIterator = inputLeft.begin(); + auto inRIterator = inputRight.begin(); + auto outRIterator = outputLeft.begin(); + auto outLIterator = outputRight.begin(); + while (cutoffIterator < cutoff.end()) + { + filterLeft.process( &inLIterator.base(), &outLIterator.base(), *cutoffIterator, 0.0, 0.0, step); + filterRight.process(&inRIterator.base(), &outRIterator.base(), *cutoffIterator, 0.0, 0.0, step); + cutoffIterator += step; + inLIterator += step; + inRIterator += step; + outLIterator += step; + outRIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, OnePole_Stereo)(benchmark::State& state) { + sfz::Filter<2> filter; + filter.setType(sfz::FilterType::kFilterLpf1p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto inLIterator = inputLeft.begin(); + auto inRIterator = inputRight.begin(); + auto outRIterator = outputLeft.begin(); + auto outLIterator = outputRight.begin(); + while (cutoffIterator < cutoff.end()) + { + float * inputs[2] = { inLIterator.base(), inRIterator.base() }; + float * outputs[2] = { outLIterator.base(), outRIterator.base() }; + filter.process(inputs, outputs, *cutoffIterator, 0.0, 0.0, step); + cutoffIterator += step; + inLIterator += step; + inRIterator += step; + outLIterator += step; + outRIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoOnce)(benchmark::State& state) { + sfz::Filter<1> filterLeft; + sfz::Filter<1> filterRight; + filterLeft.setType(sfz::FilterType::kFilterLpf2p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto qIterator = q.begin(); + auto inLIterator = inputLeft.begin(); + auto outLIterator = outputRight.begin(); + while (cutoffIterator < cutoff.end()) + { + filterLeft.process(&inLIterator.base(), &outLIterator.base(), *cutoffIterator, *qIterator, 0.0, step); + cutoffIterator += step; + qIterator += step; + inLIterator += step; + outLIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoTwice)(benchmark::State& state) { + sfz::Filter<1> filterLeft; + sfz::Filter<1> filterRight; + filterLeft.setType(sfz::FilterType::kFilterLpf2p); + filterRight.setType(sfz::FilterType::kFilterLpf2p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto qIterator = q.begin(); + auto inLIterator = inputLeft.begin(); + auto inRIterator = inputRight.begin(); + auto outRIterator = outputLeft.begin(); + auto outLIterator = outputRight.begin(); + while (cutoffIterator < cutoff.end()) + { + filterLeft.process( &inLIterator.base(), &outLIterator.base(), *cutoffIterator, *qIterator, 0.0, step); + filterRight.process(&inRIterator.base(), &outRIterator.base(), *cutoffIterator, *qIterator, 0.0, step); + cutoffIterator += step; + qIterator += step; + inLIterator += step; + inRIterator += step; + outLIterator += step; + outRIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Stereo)(benchmark::State& state) { + sfz::Filter<2> filter; + filter.setType(sfz::FilterType::kFilterLpf2p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto qIterator = q.begin(); + auto inLIterator = inputLeft.begin(); + auto inRIterator = inputRight.begin(); + auto outRIterator = outputLeft.begin(); + auto outLIterator = outputRight.begin(); + while (cutoffIterator < cutoff.end()) + { + float * inputs[2] = { inLIterator.base(), inRIterator.base() }; + float * outputs[2] = { outLIterator.base(), outRIterator.base() }; + filter.process(inputs, outputs, *cutoffIterator, *qIterator, 0.0, step); + cutoffIterator += step; + qIterator += step; + inLIterator += step; + inRIterator += step; + outLIterator += step; + outRIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoOnce)(benchmark::State& state) { + sfz::Filter<1> filterLeft; + sfz::Filter<1> filterRight; + filterLeft.setType(sfz::FilterType::kFilterLpf2p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto qIterator = q.begin(); + auto pkshIterator = pksh.begin(); + auto inLIterator = inputLeft.begin(); + auto outLIterator = outputRight.begin(); + while (cutoffIterator < cutoff.end()) + { + filterLeft.process(&inLIterator.base(), &outLIterator.base(), *cutoffIterator, *qIterator, *pkshIterator, step); + cutoffIterator += step; + qIterator += step; + pkshIterator += step; + inLIterator += step; + outLIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoTwice)(benchmark::State& state) { + sfz::Filter<1> filterLeft; + sfz::Filter<1> filterRight; + filterLeft.setType(sfz::FilterType::kFilterLpf2p); + filterRight.setType(sfz::FilterType::kFilterLpf2p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto qIterator = q.begin(); + auto pkshIterator = pksh.begin(); + auto inLIterator = inputLeft.begin(); + auto inRIterator = inputRight.begin(); + auto outRIterator = outputLeft.begin(); + auto outLIterator = outputRight.begin(); + while (cutoffIterator < cutoff.end()) + { + filterLeft.process( &inLIterator.base(), &outLIterator.base(), *cutoffIterator, *qIterator, *pkshIterator, step); + filterRight.process(&inRIterator.base(), &outRIterator.base(), *cutoffIterator, *qIterator, *pkshIterator, step); + cutoffIterator += step; + qIterator += step; + pkshIterator += step; + inLIterator += step; + inRIterator += step; + outLIterator += step; + outRIterator += step; + } + } +} + +BENCHMARK_DEFINE_F(FilterFixture, Shelf_Stereo)(benchmark::State& state) { + sfz::Filter<2> filter; + filter.setType(sfz::FilterType::kFilterLpf2p); + for (auto _ : state) + { + const auto step = static_cast(state.range(0)); + auto cutoffIterator = cutoff.begin(); + auto qIterator = q.begin(); + auto pkshIterator = pksh.begin(); + auto inLIterator = inputLeft.begin(); + auto inRIterator = inputRight.begin(); + auto outRIterator = outputLeft.begin(); + auto outLIterator = outputRight.begin(); + while (cutoffIterator < cutoff.end()) + { + float * inputs[2] = { inLIterator.base(), inRIterator.base() }; + float * outputs[2] = { outLIterator.base(), outRIterator.base() }; + filter.process(inputs, outputs, *cutoffIterator, *qIterator, *pkshIterator, step); + cutoffIterator += step; + qIterator += step; + pkshIterator += step; + inLIterator += step; + inRIterator += step; + outLIterator += step; + outRIterator += step; + } + } +} + +BENCHMARK_REGISTER_F(FilterFixture, OnePole_MonoOnce)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, OnePole_MonoTwice)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, OnePole_Stereo)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, TwoPole_MonoOnce)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, TwoPole_MonoTwice)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, TwoPole_Stereo)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, Shelf_MonoOnce)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, Shelf_MonoTwice)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_REGISTER_F(FilterFixture, Shelf_Stereo)->RangeMultiplier(2)->Range(1, 1 << 8); +BENCHMARK_MAIN(); + diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt index cd888984..e47f10f1 100644 --- a/benchmarks/CMakeLists.txt +++ b/benchmarks/CMakeLists.txt @@ -120,6 +120,14 @@ add_executable(bm_resampleChunk BM_resampleChunk.cpp ${BENCHMARK_SIMD_SOURCES}) target_link_libraries(bm_resampleChunk PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile) target_include_directories(bm_resampleChunk PRIVATE ../src/sfizz ../src/external) +add_executable(bm_filterModulation BM_filterModulation.cpp ${BENCHMARK_SIMD_SOURCES} ../src/sfizz/SfzFilter.cpp) +target_link_libraries(bm_filterModulation PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile) +target_include_directories(bm_filterModulation PRIVATE ../src/sfizz ../src/external) + +add_executable(bm_filterStereoMono BM_filterStereoMono.cpp ${BENCHMARK_SIMD_SOURCES} ../src/sfizz/SfzFilter.cpp) +target_link_libraries(bm_filterStereoMono PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile) +target_include_directories(bm_filterStereoMono PRIVATE ../src/sfizz ../src/external) + add_custom_target(sfizz_benchmarks) add_dependencies(sfizz_benchmarks bm_opf_high_vs_low @@ -148,6 +156,8 @@ add_dependencies(sfizz_benchmarks bm_envelopes bm_wavfile bm_flacfile + bm_filterModulation + bm_filterStereoMono ) if (NOT WIN32) From 5ad4e6ae2472f460b2bccd225e56295fd06e025c Mon Sep 17 00:00:00 2001 From: Jean Pierre Cimalando Date: Sat, 8 Feb 2020 12:50:44 +0100 Subject: [PATCH 2/8] Update benchmarks using new filter API --- benchmarks/BM_filterModulation.cpp | 6 +++--- benchmarks/BM_filterStereoMono.cpp | 33 ++++++++++++++++-------------- 2 files changed, 21 insertions(+), 18 deletions(-) diff --git a/benchmarks/BM_filterModulation.cpp b/benchmarks/BM_filterModulation.cpp index 32640c41..71732651 100644 --- a/benchmarks/BM_filterModulation.cpp +++ b/benchmarks/BM_filterModulation.cpp @@ -65,7 +65,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_VA)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, OnePole_Faust)(benchmark::State& state) { - sfz::Filter<1> filter; + sfz::Filter filter; filter.setType(sfz::FilterType::kFilterLpf1p); for (auto _ : state) { @@ -84,7 +84,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_Faust)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Faust)(benchmark::State& state) { - sfz::Filter<1> filter; + sfz::Filter filter; filter.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { @@ -105,7 +105,7 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Faust)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPoleShelf_Faust)(benchmark::State& state) { - sfz::Filter<1> filter; + sfz::Filter filter; filter.setType(sfz::FilterType::kFilterLsh); for (auto _ : state) { diff --git a/benchmarks/BM_filterStereoMono.cpp b/benchmarks/BM_filterStereoMono.cpp index d7168ed1..b4243297 100644 --- a/benchmarks/BM_filterStereoMono.cpp +++ b/benchmarks/BM_filterStereoMono.cpp @@ -50,8 +50,8 @@ public: }; BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoOnce)(benchmark::State& state) { - sfz::Filter<1> filterLeft; - sfz::Filter<1> filterRight; + sfz::Filter filterLeft; + sfz::Filter filterRight; filterLeft.setType(sfz::FilterType::kFilterLpf1p); for (auto _ : state) { @@ -70,8 +70,8 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoOnce)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoTwice)(benchmark::State& state) { - sfz::Filter<1> filterLeft; - sfz::Filter<1> filterRight; + sfz::Filter filterLeft; + sfz::Filter filterRight; filterLeft.setType(sfz::FilterType::kFilterLpf1p); filterRight.setType(sfz::FilterType::kFilterLpf1p); for (auto _ : state) @@ -96,7 +96,8 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoTwice)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, OnePole_Stereo)(benchmark::State& state) { - sfz::Filter<2> filter; + sfz::Filter filter; + filter.setChannels(2); filter.setType(sfz::FilterType::kFilterLpf1p); for (auto _ : state) { @@ -121,8 +122,8 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_Stereo)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoOnce)(benchmark::State& state) { - sfz::Filter<1> filterLeft; - sfz::Filter<1> filterRight; + sfz::Filter filterLeft; + sfz::Filter filterRight; filterLeft.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { @@ -143,8 +144,8 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoOnce)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoTwice)(benchmark::State& state) { - sfz::Filter<1> filterLeft; - sfz::Filter<1> filterRight; + sfz::Filter filterLeft; + sfz::Filter filterRight; filterLeft.setType(sfz::FilterType::kFilterLpf2p); filterRight.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) @@ -171,7 +172,8 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoTwice)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Stereo)(benchmark::State& state) { - sfz::Filter<2> filter; + sfz::Filter filter; + filter.setChannels(2); filter.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { @@ -198,8 +200,8 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Stereo)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoOnce)(benchmark::State& state) { - sfz::Filter<1> filterLeft; - sfz::Filter<1> filterRight; + sfz::Filter filterLeft; + sfz::Filter filterRight; filterLeft.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { @@ -222,8 +224,8 @@ BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoOnce)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoTwice)(benchmark::State& state) { - sfz::Filter<1> filterLeft; - sfz::Filter<1> filterRight; + sfz::Filter filterLeft; + sfz::Filter filterRight; filterLeft.setType(sfz::FilterType::kFilterLpf2p); filterRight.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) @@ -252,7 +254,8 @@ BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoTwice)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, Shelf_Stereo)(benchmark::State& state) { - sfz::Filter<2> filter; + sfz::Filter filter; + filter.setChannels(2); filter.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { From 1a8fcd9d496274a4e0b90343b41f198b43d35e0b Mon Sep 17 00:00:00 2001 From: Jean Pierre Cimalando Date: Sat, 8 Feb 2020 12:51:39 +0100 Subject: [PATCH 3/8] Eliminate some warnings in benchmarks --- benchmarks/BM_filterModulation.cpp | 2 +- benchmarks/BM_filterStereoMono.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/benchmarks/BM_filterModulation.cpp b/benchmarks/BM_filterModulation.cpp index 71732651..9f4dbeac 100644 --- a/benchmarks/BM_filterModulation.cpp +++ b/benchmarks/BM_filterModulation.cpp @@ -19,7 +19,7 @@ constexpr float sampleRate { 48000.0f }; class FilterFixture : public benchmark::Fixture { public: - void SetUp(const ::benchmark::State& state) { + void SetUp(const ::benchmark::State&) { input = std::vector(blockSize); output = std::vector(blockSize); cutoff = std::vector(blockSize); diff --git a/benchmarks/BM_filterStereoMono.cpp b/benchmarks/BM_filterStereoMono.cpp index b4243297..29e5832b 100644 --- a/benchmarks/BM_filterStereoMono.cpp +++ b/benchmarks/BM_filterStereoMono.cpp @@ -19,7 +19,7 @@ constexpr float sampleRate { 48000.0f }; class FilterFixture : public benchmark::Fixture { public: - void SetUp(const ::benchmark::State& state) { + void SetUp(const ::benchmark::State&) { inputLeft = std::vector(blockSize); inputRight = std::vector(blockSize); outputLeft = std::vector(blockSize); From 8eaa2a39de4ddd5cd23cc304a00d292d5c0f7868 Mon Sep 17 00:00:00 2001 From: Jean Pierre Cimalando Date: Sat, 8 Feb 2020 12:56:03 +0100 Subject: [PATCH 4/8] Run filter init in the benchmarks --- benchmarks/BM_filterModulation.cpp | 3 +++ benchmarks/BM_filterStereoMono.cpp | 15 ++++++++++++--- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/benchmarks/BM_filterModulation.cpp b/benchmarks/BM_filterModulation.cpp index 9f4dbeac..0edb3878 100644 --- a/benchmarks/BM_filterModulation.cpp +++ b/benchmarks/BM_filterModulation.cpp @@ -66,6 +66,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_VA)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, OnePole_Faust)(benchmark::State& state) { sfz::Filter filter; + filter.init(sampleRate); filter.setType(sfz::FilterType::kFilterLpf1p); for (auto _ : state) { @@ -85,6 +86,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_Faust)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Faust)(benchmark::State& state) { sfz::Filter filter; + filter.init(sampleRate); filter.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { @@ -106,6 +108,7 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Faust)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, TwoPoleShelf_Faust)(benchmark::State& state) { sfz::Filter filter; + filter.init(sampleRate); filter.setType(sfz::FilterType::kFilterLsh); for (auto _ : state) { diff --git a/benchmarks/BM_filterStereoMono.cpp b/benchmarks/BM_filterStereoMono.cpp index 29e5832b..898b771f 100644 --- a/benchmarks/BM_filterStereoMono.cpp +++ b/benchmarks/BM_filterStereoMono.cpp @@ -51,7 +51,7 @@ public: BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoOnce)(benchmark::State& state) { sfz::Filter filterLeft; - sfz::Filter filterRight; + filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf1p); for (auto _ : state) { @@ -72,7 +72,9 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoOnce)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoTwice)(benchmark::State& state) { sfz::Filter filterLeft; sfz::Filter filterRight; + filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf1p); + filterRight.init(sampleRate); filterRight.setType(sfz::FilterType::kFilterLpf1p); for (auto _ : state) { @@ -97,6 +99,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoTwice)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, OnePole_Stereo)(benchmark::State& state) { sfz::Filter filter; + filter.init(sampleRate); filter.setChannels(2); filter.setType(sfz::FilterType::kFilterLpf1p); for (auto _ : state) @@ -123,7 +126,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_Stereo)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoOnce)(benchmark::State& state) { sfz::Filter filterLeft; - sfz::Filter filterRight; + filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { @@ -146,7 +149,9 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoOnce)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoTwice)(benchmark::State& state) { sfz::Filter filterLeft; sfz::Filter filterRight; + filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf2p); + filterRight.init(sampleRate); filterRight.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { @@ -173,6 +178,7 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoTwice)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Stereo)(benchmark::State& state) { sfz::Filter filter; + filter.init(sampleRate); filter.setChannels(2); filter.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) @@ -201,7 +207,7 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Stereo)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoOnce)(benchmark::State& state) { sfz::Filter filterLeft; - sfz::Filter filterRight; + filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { @@ -226,7 +232,9 @@ BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoOnce)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoTwice)(benchmark::State& state) { sfz::Filter filterLeft; sfz::Filter filterRight; + filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf2p); + filterRight.init(sampleRate); filterRight.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { @@ -255,6 +263,7 @@ BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoTwice)(benchmark::State& state) { BENCHMARK_DEFINE_F(FilterFixture, Shelf_Stereo)(benchmark::State& state) { sfz::Filter filter; + filter.init(sampleRate); filter.setChannels(2); filter.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) From f2fa0cf55a590bc85e31df19457ade6b293db10c Mon Sep 17 00:00:00 2001 From: Paul Ferrand Date: Sun, 9 Feb 2020 11:16:58 +0100 Subject: [PATCH 5/8] Change iterators to pointers MSVC STL and libc++ iterators do not decay to pointers as easily as gcc --- benchmarks/BM_filterModulation.cpp | 70 ++++---- benchmarks/BM_filterStereoMono.cpp | 259 +++++++++++++++-------------- 2 files changed, 170 insertions(+), 159 deletions(-) diff --git a/benchmarks/BM_filterModulation.cpp b/benchmarks/BM_filterModulation.cpp index 0edb3878..1b5d6d58 100644 --- a/benchmarks/BM_filterModulation.cpp +++ b/benchmarks/BM_filterModulation.cpp @@ -49,17 +49,18 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_VA)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto inputIterator = input.begin(); - auto outputIterator = output.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto inputPtr = input.data(); + auto outputPtr = output.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - const auto gain = sfz::OnePoleFilter::normalizedGain(*cutoffIterator, sampleRate); + const auto gain = sfz::OnePoleFilter::normalizedGain(*cutoffPtr, sampleRate); filter.setGain(gain); - filter.processLowpass({ inputIterator.base(), step }, { outputIterator.base(), step } ); - cutoffIterator += step; - inputIterator += step; - outputIterator += step; + filter.processLowpass({ inputPtr, step }, { outputPtr, step } ); + cutoffPtr += step; + inputPtr += step; + outputPtr += step; } } } @@ -71,15 +72,16 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_Faust)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto inputIterator = input.begin(); - auto outputIterator = output.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto inputPtr = input.data(); + auto outputPtr = output.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - filter.process(&inputIterator.base(), &outputIterator.base(), *cutoffIterator, 0.0, 0.0, step); - cutoffIterator += step; - inputIterator += step; - outputIterator += step; + filter.process(&inputPtr, &outputPtr, *cutoffPtr, 0.0, 0.0, step); + cutoffPtr += step; + inputPtr += step; + outputPtr += step; } } } @@ -91,17 +93,18 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Faust)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); + auto cutoffPtr = cutoff.data(); auto qIterator = q.begin(); - auto inputIterator = input.begin(); - auto outputIterator = output.begin(); - while (cutoffIterator < cutoff.end()) + auto inputPtr = input.data(); + auto outputPtr = output.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - filter.process(&inputIterator.base(), &outputIterator.base(), *cutoffIterator, *qIterator, 0.0, step); + filter.process(&inputPtr, &outputPtr, *cutoffPtr, *qIterator, 0.0, step); qIterator += step; - cutoffIterator += step; - inputIterator += step; - outputIterator += step; + cutoffPtr += step; + inputPtr += step; + outputPtr += step; } } } @@ -113,19 +116,20 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPoleShelf_Faust)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); + auto cutoffPtr = cutoff.data(); auto qIterator = q.begin(); auto pkshIterator = pksh.begin(); - auto inputIterator = input.begin(); - auto outputIterator = output.begin(); - while (cutoffIterator < cutoff.end()) + auto inputPtr = input.data(); + auto outputPtr = output.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - filter.process(&inputIterator.base(), &outputIterator.base(), *cutoffIterator, *qIterator, *pkshIterator, step); + filter.process(&inputPtr, &outputPtr, *cutoffPtr, *qIterator, *pkshIterator, step); qIterator += step; - cutoffIterator += step; + cutoffPtr += step; pkshIterator += step; - inputIterator += step; - outputIterator += step; + inputPtr += step; + outputPtr += step; } } } diff --git a/benchmarks/BM_filterStereoMono.cpp b/benchmarks/BM_filterStereoMono.cpp index 898b771f..b86f25f8 100644 --- a/benchmarks/BM_filterStereoMono.cpp +++ b/benchmarks/BM_filterStereoMono.cpp @@ -19,7 +19,7 @@ constexpr float sampleRate { 48000.0f }; class FilterFixture : public benchmark::Fixture { public: - void SetUp(const ::benchmark::State&) { + void SetUp(const ::benchmark::State& state) { inputLeft = std::vector(blockSize); inputRight = std::vector(blockSize); outputLeft = std::vector(blockSize); @@ -56,15 +56,16 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoOnce)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto inLIterator = inputLeft.begin(); - auto outLIterator = outputRight.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto inLPtr = inputLeft.data(); + auto outLPtr = outputRight.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - filterLeft.process( &inLIterator.base(), &outLIterator.base(), *cutoffIterator, 0.0, 0.0, step); - cutoffIterator += step; - inLIterator += step; - outLIterator += step; + filterLeft.process( &inLPtr, &outLPtr, *cutoffPtr, 0.0, 0.0, step); + cutoffPtr += step; + inLPtr += step; + outLPtr += step; } } } @@ -79,20 +80,21 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoTwice)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto inLIterator = inputLeft.begin(); - auto inRIterator = inputRight.begin(); - auto outRIterator = outputLeft.begin(); - auto outLIterator = outputRight.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto inLPtr = inputLeft.data(); + auto inRPtr = inputRight.data(); + auto outRPtr = outputLeft.data(); + auto outLPtr = outputRight.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - filterLeft.process( &inLIterator.base(), &outLIterator.base(), *cutoffIterator, 0.0, 0.0, step); - filterRight.process(&inRIterator.base(), &outRIterator.base(), *cutoffIterator, 0.0, 0.0, step); - cutoffIterator += step; - inLIterator += step; - inRIterator += step; - outLIterator += step; - outRIterator += step; + filterLeft.process( &inLPtr, &outLPtr, *cutoffPtr, 0.0, 0.0, step); + filterRight.process(&inRPtr, &outRPtr, *cutoffPtr, 0.0, 0.0, step); + cutoffPtr += step; + inLPtr += step; + inRPtr += step; + outLPtr += step; + outRPtr += step; } } } @@ -105,21 +107,22 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_Stereo)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto inLIterator = inputLeft.begin(); - auto inRIterator = inputRight.begin(); - auto outRIterator = outputLeft.begin(); - auto outLIterator = outputRight.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto inLPtr = inputLeft.data(); + auto inRPtr = inputRight.data(); + auto outRPtr = outputLeft.data(); + auto outLPtr = outputRight.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - float * inputs[2] = { inLIterator.base(), inRIterator.base() }; - float * outputs[2] = { outLIterator.base(), outRIterator.base() }; - filter.process(inputs, outputs, *cutoffIterator, 0.0, 0.0, step); - cutoffIterator += step; - inLIterator += step; - inRIterator += step; - outLIterator += step; - outRIterator += step; + float * inputs[2] = { inLPtr, inRPtr }; + float * outputs[2] = { outLPtr, outRPtr }; + filter.process(inputs, outputs, *cutoffPtr, 0.0, 0.0, step); + cutoffPtr += step; + inLPtr += step; + inRPtr += step; + outLPtr += step; + outRPtr += step; } } } @@ -131,17 +134,18 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoOnce)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto qIterator = q.begin(); - auto inLIterator = inputLeft.begin(); - auto outLIterator = outputRight.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto qPtr = q.data(); + auto inLPtr = inputLeft.data(); + auto outLPtr = outputRight.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - filterLeft.process(&inLIterator.base(), &outLIterator.base(), *cutoffIterator, *qIterator, 0.0, step); - cutoffIterator += step; - qIterator += step; - inLIterator += step; - outLIterator += step; + filterLeft.process(&inLPtr, &outLPtr, *cutoffPtr, *qPtr, 0.0, step); + cutoffPtr += step; + qPtr += step; + inLPtr += step; + outLPtr += step; } } } @@ -156,22 +160,23 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoTwice)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto qIterator = q.begin(); - auto inLIterator = inputLeft.begin(); - auto inRIterator = inputRight.begin(); - auto outRIterator = outputLeft.begin(); - auto outLIterator = outputRight.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto qPtr = q.data(); + auto inLPtr = inputLeft.data(); + auto inRPtr = inputRight.data(); + auto outRPtr = outputLeft.data(); + auto outLPtr = outputRight.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - filterLeft.process( &inLIterator.base(), &outLIterator.base(), *cutoffIterator, *qIterator, 0.0, step); - filterRight.process(&inRIterator.base(), &outRIterator.base(), *cutoffIterator, *qIterator, 0.0, step); - cutoffIterator += step; - qIterator += step; - inLIterator += step; - inRIterator += step; - outLIterator += step; - outRIterator += step; + filterLeft.process( &inLPtr, &outLPtr, *cutoffPtr, *qPtr, 0.0, step); + filterRight.process(&inRPtr, &outRPtr, *cutoffPtr, *qPtr, 0.0, step); + cutoffPtr += step; + qPtr += step; + inLPtr += step; + inRPtr += step; + outLPtr += step; + outRPtr += step; } } } @@ -184,23 +189,24 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Stereo)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto qIterator = q.begin(); - auto inLIterator = inputLeft.begin(); - auto inRIterator = inputRight.begin(); - auto outRIterator = outputLeft.begin(); - auto outLIterator = outputRight.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto qPtr = q.data(); + auto inLPtr = inputLeft.data(); + auto inRPtr = inputRight.data(); + auto outRPtr = outputLeft.data(); + auto outLPtr = outputRight.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - float * inputs[2] = { inLIterator.base(), inRIterator.base() }; - float * outputs[2] = { outLIterator.base(), outRIterator.base() }; - filter.process(inputs, outputs, *cutoffIterator, *qIterator, 0.0, step); - cutoffIterator += step; - qIterator += step; - inLIterator += step; - inRIterator += step; - outLIterator += step; - outRIterator += step; + float * inputs[2] = { inLPtr, inRPtr }; + float * outputs[2] = { outLPtr, outRPtr }; + filter.process(inputs, outputs, *cutoffPtr, *qPtr, 0.0, step); + cutoffPtr += step; + qPtr += step; + inLPtr += step; + inRPtr += step; + outLPtr += step; + outRPtr += step; } } } @@ -212,19 +218,20 @@ BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoOnce)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto qIterator = q.begin(); - auto pkshIterator = pksh.begin(); - auto inLIterator = inputLeft.begin(); - auto outLIterator = outputRight.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto qPtr = q.data(); + auto pkshPtr = pksh.data(); + auto inLPtr = inputLeft.data(); + auto outLPtr = outputRight.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - filterLeft.process(&inLIterator.base(), &outLIterator.base(), *cutoffIterator, *qIterator, *pkshIterator, step); - cutoffIterator += step; - qIterator += step; - pkshIterator += step; - inLIterator += step; - outLIterator += step; + filterLeft.process(&inLPtr, &outLPtr, *cutoffPtr, *qPtr, *pkshPtr, step); + cutoffPtr += step; + qPtr += step; + pkshPtr += step; + inLPtr += step; + outLPtr += step; } } } @@ -235,28 +242,28 @@ BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoTwice)(benchmark::State& state) { filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf2p); filterRight.init(sampleRate); - filterRight.setType(sfz::FilterType::kFilterLpf2p); for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto qIterator = q.begin(); - auto pkshIterator = pksh.begin(); - auto inLIterator = inputLeft.begin(); - auto inRIterator = inputRight.begin(); - auto outRIterator = outputLeft.begin(); - auto outLIterator = outputRight.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto qPtr = q.data(); + auto pkshPtr = pksh.data(); + auto inLPtr = inputLeft.data(); + auto inRPtr = inputRight.data(); + auto outRPtr = outputLeft.data(); + auto outLPtr = outputRight.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - filterLeft.process( &inLIterator.base(), &outLIterator.base(), *cutoffIterator, *qIterator, *pkshIterator, step); - filterRight.process(&inRIterator.base(), &outRIterator.base(), *cutoffIterator, *qIterator, *pkshIterator, step); - cutoffIterator += step; - qIterator += step; - pkshIterator += step; - inLIterator += step; - inRIterator += step; - outLIterator += step; - outRIterator += step; + filterLeft.process( &inLPtr, &outLPtr, *cutoffPtr, *qPtr, *pkshPtr, step); + filterRight.process(&inRPtr, &outRPtr, *cutoffPtr, *qPtr, *pkshPtr, step); + cutoffPtr += step; + qPtr += step; + pkshPtr += step; + inLPtr += step; + inRPtr += step; + outLPtr += step; + outRPtr += step; } } } @@ -269,25 +276,26 @@ BENCHMARK_DEFINE_F(FilterFixture, Shelf_Stereo)(benchmark::State& state) { for (auto _ : state) { const auto step = static_cast(state.range(0)); - auto cutoffIterator = cutoff.begin(); - auto qIterator = q.begin(); - auto pkshIterator = pksh.begin(); - auto inLIterator = inputLeft.begin(); - auto inRIterator = inputRight.begin(); - auto outRIterator = outputLeft.begin(); - auto outLIterator = outputRight.begin(); - while (cutoffIterator < cutoff.end()) + auto cutoffPtr = cutoff.data(); + auto qPtr = q.data(); + auto pkshPtr = pksh.data(); + auto inLPtr = inputLeft.data(); + auto inRPtr = inputRight.data(); + auto outRPtr = outputLeft.data(); + auto outLPtr = outputRight.data(); + const auto sentinel = cutoff.data() + blockSize; + while (cutoffPtr < sentinel) { - float * inputs[2] = { inLIterator.base(), inRIterator.base() }; - float * outputs[2] = { outLIterator.base(), outRIterator.base() }; - filter.process(inputs, outputs, *cutoffIterator, *qIterator, *pkshIterator, step); - cutoffIterator += step; - qIterator += step; - pkshIterator += step; - inLIterator += step; - inRIterator += step; - outLIterator += step; - outRIterator += step; + float * inputs[2] = { inLPtr, inRPtr }; + float * outputs[2] = { outLPtr, outRPtr }; + filter.process(inputs, outputs, *cutoffPtr, *qPtr, *pkshPtr, step); + cutoffPtr += step; + qPtr += step; + pkshPtr += step; + inLPtr += step; + inRPtr += step; + outLPtr += step; + outRPtr += step; } } } @@ -302,4 +310,3 @@ BENCHMARK_REGISTER_F(FilterFixture, Shelf_MonoOnce)->RangeMultiplier(2)->Range(1 BENCHMARK_REGISTER_F(FilterFixture, Shelf_MonoTwice)->RangeMultiplier(2)->Range(1, 1 << 8); BENCHMARK_REGISTER_F(FilterFixture, Shelf_Stereo)->RangeMultiplier(2)->Range(1, 1 << 8); BENCHMARK_MAIN(); - From e0bb415b026b4f32c9dbccff400ca06ff68f0bd1 Mon Sep 17 00:00:00 2001 From: Paul Ferrand Date: Sun, 9 Feb 2020 11:37:25 +0100 Subject: [PATCH 6/8] Distinguish between mingw and msvc flags --- cmake/SfizzSIMDSourceFilesCheck.cmake | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/cmake/SfizzSIMDSourceFilesCheck.cmake b/cmake/SfizzSIMDSourceFilesCheck.cmake index be5212da..94eb80fb 100644 --- a/cmake/SfizzSIMDSourceFilesCheck.cmake +++ b/cmake/SfizzSIMDSourceFilesCheck.cmake @@ -12,7 +12,11 @@ if (HAVE_X86INTRIN_H AND UNIX) add_compile_options (-DHAVE_X86INTRIN_H) set (SFIZZ_SIMD_SOURCES sfizz/SIMDSSE.cpp) elseif (HAVE_INTRIN_H AND WIN32) - add_compile_options (-DHAVE_INTRIN_H) + if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + add_compile_options ("/DHAVE_INTRIN_H") + else() + add_compile_options ("-DHAVE_INTRIN_H") + endif() set (SFIZZ_SIMD_SOURCES sfizz/SIMDSSE.cpp) elseif (CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7l") add_compile_options (-DHAVE_ARM_NEON_H) From f71dfff3359509655845b2da5bd231b9b64bbc60 Mon Sep 17 00:00:00 2001 From: Paul Ferrand Date: Sun, 9 Feb 2020 11:38:27 +0100 Subject: [PATCH 7/8] Add FTZ and streamline the compilation of BM --- benchmarks/CMakeLists.txt | 113 ++++++++++++++++++++------------------ 1 file changed, 59 insertions(+), 54 deletions(-) diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt index e47f10f1..599b111c 100644 --- a/benchmarks/CMakeLists.txt +++ b/benchmarks/CMakeLists.txt @@ -6,92 +6,97 @@ set(BENCHMARK_SIMD_SOURCES ${SFIZZ_SIMD_SOURCES}) list(TRANSFORM BENCHMARK_SIMD_SOURCES PREPEND "../src/") find_package(benchmark CONFIG REQUIRED) +add_library(bm_simd STATIC ${BENCHMARK_SIMD_SOURCES}) +target_link_libraries(bm_simd PRIVATE absl::span) +target_include_directories(bm_simd PRIVATE ../src/external) +add_library(bm_ftz STATIC ../src/sfizz/ScopedFTZ.cpp) + add_executable(bm_opf_high_vs_low BM_OPF_high_vs_low.cpp) target_link_libraries(bm_opf_high_vs_low PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main) target_include_directories(bm_opf_high_vs_low PRIVATE ../src/sfizz ../src/external) -add_executable(bm_write BM_writeInterleaved.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_write PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_write BM_writeInterleaved.cpp) +target_link_libraries(bm_write PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_write PRIVATE ../src/sfizz ../src/external) -add_executable(bm_read BM_readInterleaved.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_read PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_read BM_readInterleaved.cpp) +target_link_libraries(bm_read PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_read PRIVATE ../src/sfizz ../src/external) -add_executable(bm_fill BM_fill.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_fill PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_fill BM_fill.cpp) +target_link_libraries(bm_fill PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_fill PRIVATE ../src/sfizz ../src/external) -add_executable(bm_mathfuns BM_mathfuns.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_mathfuns PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_mathfuns BM_mathfuns.cpp) +target_link_libraries(bm_mathfuns PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_mathfuns PRIVATE ../src/sfizz ../src/external) -add_executable(bm_gain BM_gain.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_gain PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_gain BM_gain.cpp) +target_link_libraries(bm_gain PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_gain PRIVATE ../src/sfizz ../src/external) -add_executable(bm_divide BM_divide.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_divide PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_divide BM_divide.cpp) +target_link_libraries(bm_divide PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_divide PRIVATE ../src/sfizz ../src/external) -add_executable(bm_looping BM_looping.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_looping PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_looping BM_looping.cpp) +target_link_libraries(bm_looping PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_looping PRIVATE ../src/sfizz ../src/external) -add_executable(bm_saturating BM_saturating.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_saturating PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_saturating BM_saturating.cpp) +target_link_libraries(bm_saturating PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_saturating PRIVATE ../src/sfizz ../src/external) -add_executable(bm_ramp BM_ramp.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_ramp PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_ramp BM_ramp.cpp) +target_link_libraries(bm_ramp PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_ramp PRIVATE ../src/sfizz ../src/external) -add_executable(bm_ADSR BM_ADSR.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_ADSR PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_ADSR BM_ADSR.cpp) +target_link_libraries(bm_ADSR PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_ADSR PRIVATE ../src/sfizz ../src/external) -add_executable(bm_add BM_add.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_add PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_add BM_add.cpp) +target_link_libraries(bm_add PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_add PRIVATE ../src/sfizz ../src/external) -add_executable(bm_multiplyAdd BM_multiplyAdd.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_multiplyAdd PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_multiplyAdd BM_multiplyAdd.cpp) +target_link_libraries(bm_multiplyAdd PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_multiplyAdd PRIVATE ../src/sfizz ../src/external) -add_executable(bm_subtract BM_subtract.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_subtract PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_subtract BM_subtract.cpp) +target_link_libraries(bm_subtract PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_subtract PRIVATE ../src/sfizz ../src/external) -add_executable(bm_copy BM_copy.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_copy PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_copy BM_copy.cpp) +target_link_libraries(bm_copy PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_copy PRIVATE ../src/sfizz ../src/external) -add_executable(bm_pan BM_pan.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_pan PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_pan BM_pan.cpp) +target_link_libraries(bm_pan PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_pan PRIVATE ../src/sfizz ../src/external) -add_executable(bm_mean BM_mean.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_mean PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_mean BM_mean.cpp) +target_link_libraries(bm_mean PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_mean PRIVATE ../src/sfizz ../src/external) -add_executable(bm_meanSquared BM_meanSquared.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_meanSquared PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_meanSquared BM_meanSquared.cpp) +target_link_libraries(bm_meanSquared PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_meanSquared PRIVATE ../src/sfizz ../src/external) -add_executable(bm_cumsum BM_cumsum.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_cumsum PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_cumsum BM_cumsum.cpp) +target_link_libraries(bm_cumsum PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_cumsum PRIVATE ../src/sfizz ../src/external) -add_executable(bm_diff BM_diff.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_diff PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_diff BM_diff.cpp) +target_link_libraries(bm_diff PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_diff PRIVATE ../src/sfizz ../src/external) -add_executable(bm_interpolationCast BM_interpolationCast.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_interpolationCast PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_interpolationCast BM_interpolationCast.cpp) +target_link_libraries(bm_interpolationCast PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_interpolationCast PRIVATE ../src/sfizz ../src/external) -add_executable(bm_pointerIterationOrOffsets BM_pointerIterationOrOffsets.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_pointerIterationOrOffsets PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_pointerIterationOrOffsets BM_pointerIterationOrOffsets.cpp) +target_link_libraries(bm_pointerIterationOrOffsets PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_pointerIterationOrOffsets PRIVATE ../src/sfizz ../src/external) if (NOT WIN32) @@ -100,32 +105,32 @@ if (NOT WIN32) target_include_directories(bm_resample PRIVATE ../src/sfizz ../src/external) endif() -add_executable(bm_envelopes BM_envelopes.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_envelopes PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main) +add_executable(bm_envelopes BM_envelopes.cpp) +target_link_libraries(bm_envelopes PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main bm_simd bm_ftz) target_include_directories(bm_envelopes PRIVATE ../src/sfizz ../src/external) -add_executable(bm_wavfile BM_wavfile.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_wavfile PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile) +add_executable(bm_wavfile BM_wavfile.cpp) +target_link_libraries(bm_wavfile PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile bm_simd bm_ftz) target_include_directories(bm_wavfile PRIVATE ../src/sfizz ../src/external) -add_executable(bm_flacfile BM_flacfile.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_flacfile PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile) +add_executable(bm_flacfile BM_flacfile.cpp) +target_link_libraries(bm_flacfile PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile bm_simd bm_ftz) target_include_directories(bm_flacfile PRIVATE ../src/sfizz ../src/external) -add_executable(bm_readChunk BM_readChunk.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_readChunk PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile) +add_executable(bm_readChunk BM_readChunk.cpp) +target_link_libraries(bm_readChunk PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile bm_simd bm_ftz) target_include_directories(bm_readChunk PRIVATE ../src/sfizz ../src/external) -add_executable(bm_resampleChunk BM_resampleChunk.cpp ${BENCHMARK_SIMD_SOURCES}) -target_link_libraries(bm_resampleChunk PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile) +add_executable(bm_resampleChunk BM_resampleChunk.cpp) +target_link_libraries(bm_resampleChunk PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile bm_simd bm_ftz) target_include_directories(bm_resampleChunk PRIVATE ../src/sfizz ../src/external) add_executable(bm_filterModulation BM_filterModulation.cpp ${BENCHMARK_SIMD_SOURCES} ../src/sfizz/SfzFilter.cpp) -target_link_libraries(bm_filterModulation PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile) +target_link_libraries(bm_filterModulation PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile bm_ftz) target_include_directories(bm_filterModulation PRIVATE ../src/sfizz ../src/external) add_executable(bm_filterStereoMono BM_filterStereoMono.cpp ${BENCHMARK_SIMD_SOURCES} ../src/sfizz/SfzFilter.cpp) -target_link_libraries(bm_filterStereoMono PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile) +target_link_libraries(bm_filterStereoMono PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile bm_ftz) target_include_directories(bm_filterStereoMono PRIVATE ../src/sfizz ../src/external) add_custom_target(sfizz_benchmarks) From 9ba094979849784bd38f0b415e99957d0a81557a Mon Sep 17 00:00:00 2001 From: Paul Ferrand Date: Sun, 9 Feb 2020 11:38:44 +0100 Subject: [PATCH 8/8] Add FTZ to the filter benchmarks Could add it in others too --- benchmarks/BM_filterModulation.cpp | 5 +++++ benchmarks/BM_filterStereoMono.cpp | 10 ++++++++++ 2 files changed, 15 insertions(+) diff --git a/benchmarks/BM_filterModulation.cpp b/benchmarks/BM_filterModulation.cpp index 1b5d6d58..e03a3d5e 100644 --- a/benchmarks/BM_filterModulation.cpp +++ b/benchmarks/BM_filterModulation.cpp @@ -7,6 +7,7 @@ #include "SIMDHelpers.h" #include "OnePoleFilter.h" #include "SfzFilter.h" +#include "ScopedFTZ.h" #include #include #include @@ -45,6 +46,7 @@ public: }; BENCHMARK_DEFINE_F(FilterFixture, OnePole_VA)(benchmark::State& state) { + ScopedFTZ ftz; sfz::OnePoleFilter filter; for (auto _ : state) { @@ -66,6 +68,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_VA)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, OnePole_Faust)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filter; filter.init(sampleRate); filter.setType(sfz::FilterType::kFilterLpf1p); @@ -87,6 +90,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_Faust)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Faust)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filter; filter.init(sampleRate); filter.setType(sfz::FilterType::kFilterLpf2p); @@ -110,6 +114,7 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Faust)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPoleShelf_Faust)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filter; filter.init(sampleRate); filter.setType(sfz::FilterType::kFilterLsh); diff --git a/benchmarks/BM_filterStereoMono.cpp b/benchmarks/BM_filterStereoMono.cpp index b86f25f8..40ab97ba 100644 --- a/benchmarks/BM_filterStereoMono.cpp +++ b/benchmarks/BM_filterStereoMono.cpp @@ -7,6 +7,7 @@ #include "SIMDHelpers.h" #include "OnePoleFilter.h" #include "SfzFilter.h" +#include "ScopedFTZ.h" #include #include #include @@ -50,6 +51,7 @@ public: }; BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoOnce)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filterLeft; filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf1p); @@ -71,6 +73,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoOnce)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoTwice)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filterLeft; sfz::Filter filterRight; filterLeft.init(sampleRate); @@ -100,6 +103,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoTwice)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, OnePole_Stereo)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filter; filter.init(sampleRate); filter.setChannels(2); @@ -128,6 +132,7 @@ BENCHMARK_DEFINE_F(FilterFixture, OnePole_Stereo)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoOnce)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filterLeft; filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf2p); @@ -151,6 +156,7 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoOnce)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoTwice)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filterLeft; sfz::Filter filterRight; filterLeft.init(sampleRate); @@ -182,6 +188,7 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoTwice)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Stereo)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filter; filter.init(sampleRate); filter.setChannels(2); @@ -212,6 +219,7 @@ BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Stereo)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoOnce)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filterLeft; filterLeft.init(sampleRate); filterLeft.setType(sfz::FilterType::kFilterLpf2p); @@ -237,6 +245,7 @@ BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoOnce)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoTwice)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filterLeft; sfz::Filter filterRight; filterLeft.init(sampleRate); @@ -269,6 +278,7 @@ BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoTwice)(benchmark::State& state) { } BENCHMARK_DEFINE_F(FilterFixture, Shelf_Stereo)(benchmark::State& state) { + ScopedFTZ ftz; sfz::Filter filter; filter.init(sampleRate); filter.setChannels(2);