Merge pull request #46 from jpcima/filter-benchmarks

Filter benchmarks

benchmarks/BM_filterModulation.cpp

@@ -0,0 +1,147 @@
+// 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 "ScopedFTZ.h"
+#include <benchmark/benchmark.h>
+#include <random>
+#include <numeric>
+#include <vector>
+#include <cmath>
+#include <iostream>
+
+constexpr int blockSize { 1024 };
+constexpr float sampleRate { 48000.0f };
+
+class FilterFixture : public benchmark::Fixture {
+public:
+    void SetUp(const ::benchmark::State&) {
+        input = std::vector<float>(blockSize);
+        output = std::vector<float>(blockSize);
+        cutoff = std::vector<float>(blockSize);
+        q = std::vector<float>(blockSize);
+        pksh = std::vector<float>(blockSize);
+        sfz::linearRamp<float>(absl::MakeSpan(cutoff), 500, 1.0f);
+        sfz::linearRamp<float>(absl::MakeSpan(q), 0.0f, 0.001f);
+        sfz::linearRamp<float>(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<float> dist { 0, 0.5 };
+    std::vector<float> cutoff;
+    std::vector<float> q;
+    std::vector<float> pksh;
+    std::vector<float> input;
+    std::vector<float> output;
+};
+
+BENCHMARK_DEFINE_F(FilterFixture, OnePole_VA)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::OnePoleFilter<float> filter;
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        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<float>::normalizedGain(*cutoffPtr, sampleRate);
+            filter.setGain(gain);
+            filter.processLowpass({ inputPtr, step }, { outputPtr, step } );
+            cutoffPtr += step;
+            inputPtr += step;
+            outputPtr += step;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, OnePole_Faust)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filter;
+    filter.init(sampleRate);
+    filter.setType(sfz::FilterType::kFilterLpf1p);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        auto cutoffPtr = cutoff.data();
+        auto inputPtr = input.data();
+        auto outputPtr = output.data();
+        const auto sentinel = cutoff.data() + blockSize;
+        while (cutoffPtr < sentinel)
+        {
+            filter.process(&inputPtr, &outputPtr, *cutoffPtr, 0.0, 0.0, step);
+            cutoffPtr += step;
+            inputPtr += step;
+            outputPtr += step;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Faust)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filter;
+    filter.init(sampleRate);
+    filter.setType(sfz::FilterType::kFilterLpf2p);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        auto cutoffPtr = cutoff.data();
+        auto qIterator = q.begin();
+        auto inputPtr = input.data();
+        auto outputPtr = output.data();
+        const auto sentinel = cutoff.data() + blockSize;
+        while (cutoffPtr < sentinel)
+        {
+            filter.process(&inputPtr, &outputPtr, *cutoffPtr, *qIterator, 0.0, step);
+            qIterator += step;
+            cutoffPtr += step;
+            inputPtr += step;
+            outputPtr += step;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, TwoPoleShelf_Faust)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filter;
+    filter.init(sampleRate);
+    filter.setType(sfz::FilterType::kFilterLsh);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        auto cutoffPtr = cutoff.data();
+        auto qIterator = q.begin();
+        auto pkshIterator = pksh.begin();
+        auto inputPtr = input.data();
+        auto outputPtr = output.data();
+        const auto sentinel = cutoff.data() + blockSize;
+        while (cutoffPtr < sentinel)
+        {
+            filter.process(&inputPtr, &outputPtr, *cutoffPtr, *qIterator, *pkshIterator, step);
+            qIterator += step;
+            cutoffPtr += step;
+            pkshIterator += step;
+            inputPtr += step;
+            outputPtr += 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();
+

benchmarks/BM_filterStereoMono.cpp

@@ -0,0 +1,322 @@
+// 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 "ScopedFTZ.h"
+#include <benchmark/benchmark.h>
+#include <random>
+#include <numeric>
+#include <vector>
+#include <cmath>
+#include <iostream>
+
+constexpr int blockSize { 1024 };
+constexpr float sampleRate { 48000.0f };
+
+class FilterFixture : public benchmark::Fixture {
+public:
+    void SetUp(const ::benchmark::State& state) {
+        inputLeft = std::vector<float>(blockSize);
+        inputRight = std::vector<float>(blockSize);
+        outputLeft = std::vector<float>(blockSize);
+        outputRight = std::vector<float>(blockSize);
+        cutoff = std::vector<float>(blockSize);
+        q = std::vector<float>(blockSize);
+        pksh = std::vector<float>(blockSize);
+        sfz::linearRamp<float>(absl::MakeSpan(cutoff), 500, 1.0f);
+        sfz::linearRamp<float>(absl::MakeSpan(q), 0.0f, 0.001f);
+        sfz::linearRamp<float>(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<float> dist { 0, 0.5 };
+    std::vector<float> cutoff;
+    std::vector<float> q;
+    std::vector<float> pksh;
+    std::vector<float> inputLeft;
+    std::vector<float> inputRight;
+    std::vector<float> outputLeft;
+    std::vector<float> outputRight;
+};
+
+BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoOnce)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filterLeft;
+    filterLeft.init(sampleRate);
+    filterLeft.setType(sfz::FilterType::kFilterLpf1p);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        auto cutoffPtr = cutoff.data();
+        auto inLPtr = inputLeft.data();
+        auto outLPtr = outputRight.data();
+        const auto sentinel = cutoff.data() + blockSize;
+        while (cutoffPtr < sentinel)
+        {
+            filterLeft.process( &inLPtr, &outLPtr, *cutoffPtr, 0.0, 0.0, step);
+            cutoffPtr += step;
+            inLPtr += step;
+            outLPtr += step;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, OnePole_MonoTwice)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    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)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        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( &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;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, OnePole_Stereo)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filter;
+    filter.init(sampleRate);
+    filter.setChannels(2);
+    filter.setType(sfz::FilterType::kFilterLpf1p);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        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] = { 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;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoOnce)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filterLeft;
+    filterLeft.init(sampleRate);
+    filterLeft.setType(sfz::FilterType::kFilterLpf2p);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        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(&inLPtr, &outLPtr, *cutoffPtr, *qPtr, 0.0, step);
+            cutoffPtr += step;
+            qPtr += step;
+            inLPtr += step;
+            outLPtr += step;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, TwoPole_MonoTwice)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    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)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        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( &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;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, TwoPole_Stereo)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filter;
+    filter.init(sampleRate);
+    filter.setChannels(2);
+    filter.setType(sfz::FilterType::kFilterLpf2p);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        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] = { 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;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoOnce)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filterLeft;
+    filterLeft.init(sampleRate);
+    filterLeft.setType(sfz::FilterType::kFilterLpf2p);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        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(&inLPtr, &outLPtr, *cutoffPtr, *qPtr, *pkshPtr, step);
+            cutoffPtr += step;
+            qPtr += step;
+            pkshPtr += step;
+            inLPtr += step;
+            outLPtr += step;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, Shelf_MonoTwice)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filterLeft;
+    sfz::Filter filterRight;
+    filterLeft.init(sampleRate);
+    filterLeft.setType(sfz::FilterType::kFilterLpf2p);
+    filterRight.init(sampleRate);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        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( &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;
+        }
+    }
+}
+
+BENCHMARK_DEFINE_F(FilterFixture, Shelf_Stereo)(benchmark::State& state) {
+    ScopedFTZ ftz;
+    sfz::Filter filter;
+    filter.init(sampleRate);
+    filter.setChannels(2);
+    filter.setType(sfz::FilterType::kFilterLpf2p);
+    for (auto _ : state)
+    {
+        const auto step = static_cast<size_t>(state.range(0));
+        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] = { 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;
+        }
+    }
+}
+
+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();

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})
+add_executable(bm_write BM_writeInterleaved.cpp)
-target_link_libraries(bm_write PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_read BM_readInterleaved.cpp)
-target_link_libraries(bm_read PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_fill BM_fill.cpp)
-target_link_libraries(bm_fill PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_mathfuns BM_mathfuns.cpp)
-target_link_libraries(bm_mathfuns PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_gain BM_gain.cpp)
-target_link_libraries(bm_gain PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_divide BM_divide.cpp)
-target_link_libraries(bm_divide PRIVATE absl::span benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_looping BM_looping.cpp)
-target_link_libraries(bm_looping PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_saturating BM_saturating.cpp)
-target_link_libraries(bm_saturating PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_ramp BM_ramp.cpp)
-target_link_libraries(bm_ramp PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_ADSR BM_ADSR.cpp)
-target_link_libraries(bm_ADSR PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_add BM_add.cpp)
-target_link_libraries(bm_add PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_multiplyAdd BM_multiplyAdd.cpp)
-target_link_libraries(bm_multiplyAdd PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_subtract BM_subtract.cpp)
-target_link_libraries(bm_subtract PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_copy BM_copy.cpp)
-target_link_libraries(bm_copy PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_pan BM_pan.cpp)
-target_link_libraries(bm_pan PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_mean BM_mean.cpp)
-target_link_libraries(bm_mean PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_meanSquared BM_meanSquared.cpp)
-target_link_libraries(bm_meanSquared PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_cumsum BM_cumsum.cpp)
-target_link_libraries(bm_cumsum PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_diff BM_diff.cpp)
-target_link_libraries(bm_diff PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_interpolationCast BM_interpolationCast.cpp)
-target_link_libraries(bm_interpolationCast PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_pointerIterationOrOffsets BM_pointerIterationOrOffsets.cpp)
-target_link_libraries(bm_pointerIterationOrOffsets PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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,26 +105,34 @@ if (NOT WIN32)
 	target_include_directories(bm_resample PRIVATE ../src/sfizz ../src/external)
 endif()
 
-add_executable(bm_envelopes BM_envelopes.cpp ${BENCHMARK_SIMD_SOURCES})
+add_executable(bm_envelopes BM_envelopes.cpp)
-target_link_libraries(bm_envelopes PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main)
+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})
+add_executable(bm_wavfile BM_wavfile.cpp)
-target_link_libraries(bm_wavfile PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile)
+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})
+add_executable(bm_flacfile BM_flacfile.cpp)
-target_link_libraries(bm_flacfile PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile)
+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})
+add_executable(bm_readChunk BM_readChunk.cpp)
-target_link_libraries(bm_readChunk PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile)
+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})
+add_executable(bm_resampleChunk BM_resampleChunk.cpp)
-target_link_libraries(bm_resampleChunk PRIVATE absl::span absl::algorithm benchmark::benchmark benchmark::benchmark_main sfizz-sndfile)
+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 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 bm_ftz)
+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 +161,8 @@ add_dependencies(sfizz_benchmarks
 	bm_envelopes
 	bm_wavfile
 	bm_flacfile
+	bm_filterModulation
+	bm_filterStereoMono
 )
 
 if (NOT WIN32)

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)