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

Merge pull request #46 from jpcima/filter-benchmarks

Browse source 
Filter benchmarks
This commit is contained in:
Paul Ferrand 2020-02-09 12:52:08 +01:00 • committed by GitHub
commit 8f49b5c78e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 541 additions and 53 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

147
benchmarks/BM_filterModulation.cpp Normal file
View file

@ -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();

322
benchmarks/BM_filterStereoMono.cpp Normal file
View file

@ -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();

119
benchmarks/CMakeLists.txt
View file

@ -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,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})
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 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)

6
cmake/SfizzSIMDSourceFilesCheck.cmake
View file

@ -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)