filter_benchmark.cpp (6082B)
1 2 #include <benchmark/benchmark.h> 3 4 #include "dsp/noise.hpp" 5 #include "dsp/filters/multimode.hpp" 6 #include "dsp/filters/resample.hpp" 7 #include "dsp/filters/utility.hpp" 8 #include "dsp/oscillator.hpp" 9 // #include "dsp/decimator.hpp" // rack 10 11 using namespace bogaudio::dsp; 12 13 static void BM_Filter_LPFDecimator(benchmark::State& state) { 14 WhiteNoiseGenerator r; 15 const int n = 8; 16 float buf[n]; 17 for (int i = 0; i < n; ++i) { 18 buf[i] = r.next(); 19 } 20 LPFDecimator d(44100.0, n); 21 for (auto _ : state) { 22 benchmark::DoNotOptimize(d.next(buf)); 23 } 24 } 25 BENCHMARK(BM_Filter_LPFDecimator); 26 27 static void BM_Filter_CICDecimator(benchmark::State& state) { 28 WhiteNoiseGenerator r; 29 const int n = 8; 30 float buf[n]; 31 for (int i = 0; i < n; ++i) { 32 buf[i] = r.next(); 33 } 34 CICDecimator d(4, 8); 35 for (auto _ : state) { 36 benchmark::DoNotOptimize(d.next(buf)); 37 } 38 } 39 BENCHMARK(BM_Filter_CICDecimator); 40 41 // static void BM_Filter_RackDecimator(benchmark::State& state) { 42 // WhiteNoiseGenerator r; 43 // const int n = 8; 44 // float buf[n]; 45 // for (int i = 0; i < n; ++i) { 46 // buf[i] = r.next(); 47 // } 48 // rack::Decimator<n, n> d; 49 // for (auto _ : state) { 50 // benchmark::DoNotOptimize(d.process(buf)); 51 // } 52 // } 53 // BENCHMARK(BM_Filter_RackDecimator); 54 55 static void BM_Filter_Biquad(benchmark::State& state) { 56 WhiteNoiseGenerator r; 57 const int n = 8; 58 float buf[n]; 59 for (int i = 0; i < n; ++i) { 60 buf[i] = r.next(); 61 } 62 63 BiquadFilter<double> f; 64 f.setParams(0.012672, 0.025345, 0.012672, 1.102730, -1.974655, 0.922615); 65 int i = 0; 66 for (auto _ : state) { 67 benchmark::DoNotOptimize(f.next(buf[i])); 68 i = (i + 1) % n; 69 } 70 } 71 BENCHMARK(BM_Filter_Biquad); 72 73 static void BM_Filter_AnalogFrequency(benchmark::State& state) { 74 WhiteNoiseGenerator r; 75 const int n = 128; 76 float buf[n]; 77 for (int i = 0; i < n; ++i) { 78 buf[i] = std::abs(r.next()) * 0.5f * M_PI; 79 } 80 81 int i = 0; 82 for (auto _ : state) { 83 benchmark::DoNotOptimize(std::tan(buf[i])); 84 i = (i + 1) % n; 85 } 86 } 87 BENCHMARK(BM_Filter_AnalogFrequency); 88 89 #ifdef RACK_SIMD 90 static void BM_Filter_Biquad4(benchmark::State& state) { 91 WhiteNoiseGenerator r; 92 const int n = 128; 93 float buf[n]; 94 for (int i = 0; i < n; ++i) { 95 buf[i] = std::abs(r.next()) * 0.5f * M_PI; 96 } 97 98 Biquad4 biquads; 99 for (int i = 0; i < 4; ++i) { 100 biquads.setParams(i, 0.012672, 0.025345, 0.012672, 1.102730, -1.974655, 0.922615); 101 } 102 int i = 0; 103 for (auto _ : state) { 104 benchmark::DoNotOptimize(biquads.next(buf[i])); 105 i = (i + 1) % n; 106 } 107 } 108 BENCHMARK(BM_Filter_Biquad4); 109 #endif 110 111 static void BM_Filter_BiquadBank4(benchmark::State& state) { 112 WhiteNoiseGenerator r; 113 const int n = 128; 114 float buf[n]; 115 for (int i = 0; i < n; ++i) { 116 buf[i] = std::abs(r.next()) * 0.5f * M_PI; 117 } 118 119 MultimodeDesigner<4> designer; 120 BiquadBank<float, 4> biquads; 121 float outGain; 122 designer.setParams( 123 biquads, 124 outGain, 125 44100.0f, 126 MultimodeTypes::BUTTERWORTH_TYPE, 127 4, 128 MultimodeTypes::BANDPASS_MODE, 129 2000.0f, 130 1.0f 131 ); 132 int i = 0; 133 for (auto _ : state) { 134 benchmark::DoNotOptimize(biquads.next(buf[i])); 135 i = (i + 1) % n; 136 } 137 } 138 BENCHMARK(BM_Filter_BiquadBank4); 139 140 static void BM_Filter_BiquadBank16(benchmark::State& state) { 141 WhiteNoiseGenerator r; 142 const int n = 128; 143 float buf[n]; 144 for (int i = 0; i < n; ++i) { 145 buf[i] = std::abs(r.next()) * 0.5f * M_PI; 146 } 147 148 MultimodeDesigner<16> designer; 149 BiquadBank<float, 16> biquads; 150 float outGain; 151 designer.setParams( 152 biquads, 153 outGain, 154 44100.0f, 155 MultimodeTypes::BUTTERWORTH_TYPE, 156 16, 157 MultimodeTypes::BANDPASS_MODE, 158 2000.0f, 159 1.0f 160 ); 161 int i = 0; 162 for (auto _ : state) { 163 benchmark::DoNotOptimize(biquads.next(buf[i])); 164 i = (i + 1) % n; 165 } 166 } 167 BENCHMARK(BM_Filter_BiquadBank16); 168 169 static void BM_Filter_BiquadBank16_2Pole(benchmark::State& state) { 170 WhiteNoiseGenerator r; 171 const int n = 128; 172 float buf[n]; 173 for (int i = 0; i < n; ++i) { 174 buf[i] = std::abs(r.next()) * 0.5f * M_PI; 175 } 176 177 MultimodeDesigner<16> designer; 178 BiquadBank<float, 16> biquads; 179 float outGain; 180 designer.setParams( 181 biquads, 182 outGain, 183 44100.0f, 184 MultimodeTypes::BUTTERWORTH_TYPE, 185 2, 186 MultimodeTypes::BANDPASS_MODE, 187 2000.0f, 188 1.0f 189 ); 190 int i = 0; 191 for (auto _ : state) { 192 benchmark::DoNotOptimize(biquads.next(buf[i])); 193 i = (i + 1) % n; 194 } 195 } 196 BENCHMARK(BM_Filter_BiquadBank16_2Pole); 197 198 static void BM_Filter_RMS_Short(benchmark::State& state) { 199 SineOscillator o(500.0, 100.0); 200 const int n = 256; 201 float buf[n]; 202 for (int i = 0; i < n; ++i) { 203 buf[i] = o.next() * 5.0f; 204 } 205 RootMeanSquare rms(44100.0, 0.05); 206 int i = 0; 207 for (auto _ : state) { 208 i = ++i % n; 209 rms.next(buf[i]); 210 } 211 } 212 BENCHMARK(BM_Filter_RMS_Short); 213 214 static void BM_Filter_RMS_Long(benchmark::State& state) { 215 SineOscillator o(500.0, 100.0); 216 const int n = 256; 217 float buf[n]; 218 for (int i = 0; i < n; ++i) { 219 buf[i] = o.next() * 5.0f; 220 } 221 RootMeanSquare rms(44100.0, 1.0); 222 int i = 0; 223 for (auto _ : state) { 224 i = ++i % n; 225 rms.next(buf[i]); 226 } 227 } 228 BENCHMARK(BM_Filter_RMS_Long); 229 230 static void BM_Filter_RMS_Modulating(benchmark::State& state) { 231 SineOscillator o(500.0, 100.0); 232 const int n = 256; 233 float buf[n]; 234 for (int i = 0; i < n; ++i) { 235 buf[i] = o.next() * 5.0f; 236 } 237 std::minstd_rand g; 238 std::uniform_real_distribution<float> r(0.0f, 1.0f); 239 RootMeanSquare rms(44100.0, 1.0); 240 int i = 0; 241 for (auto _ : state) { 242 i = ++i % n; 243 if (i % 50 == 0) { 244 rms.setSensitivity(r(g)); 245 } 246 rms.next(buf[i]); 247 } 248 } 249 BENCHMARK(BM_Filter_RMS_Modulating); 250 251 static void BM_Filter_PureRMS_Short(benchmark::State& state) { 252 SineOscillator o(500.0, 100.0); 253 const int n = 256; 254 float buf[n]; 255 for (int i = 0; i < n; ++i) { 256 buf[i] = o.next() * 5.0f; 257 } 258 PureRootMeanSquare rms(44100.0, 0.05); 259 int i = 0; 260 for (auto _ : state) { 261 i = ++i % n; 262 rms.next(buf[i]); 263 } 264 } 265 BENCHMARK(BM_Filter_PureRMS_Short); 266 267 static void BM_Filter_PucketteEnvelopeFollower(benchmark::State& state) { 268 SineOscillator o(500.0, 100.0); 269 const int n = 256; 270 float buf[n]; 271 for (int i = 0; i < n; ++i) { 272 buf[i] = o.next() * 5.0f; 273 } 274 PucketteEnvelopeFollower pef; 275 int i = 0; 276 for (auto _ : state) { 277 i = ++i % n; 278 pef.next(buf[i]); 279 } 280 } 281 BENCHMARK(BM_Filter_PucketteEnvelopeFollower);