BogaudioModules

BogaudioModules for VCV Rack
Log | Files | Refs | README | LICENSE

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