From 7f041f4098a2a3b93b9ac56966b03a644fad72f1 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Thu, 28 Mar 2019 13:26:06 +0100 Subject: [PATCH] audioconvert: improve benchmark Also include the simd versions in the benchmark Fix some issues found by new test --- spa/include/spa/support/cpu.h | 64 +++--- spa/include/spa/utils/defs.h | 1 + spa/plugins/audioconvert/benchmark-fmt-ops.c | 149 +++++++++----- spa/plugins/audioconvert/benchmark-resample.c | 183 ++++++++++++++++++ spa/plugins/audioconvert/fmt-ops-sse2.c | 25 ++- spa/plugins/audioconvert/fmt-ops-ssse3.c | 13 +- spa/plugins/audioconvert/meson.build | 6 +- spa/plugins/audioconvert/resample-native.h | 10 +- 8 files changed, 350 insertions(+), 101 deletions(-) create mode 100644 spa/plugins/audioconvert/benchmark-resample.c diff --git a/spa/include/spa/support/cpu.h b/spa/include/spa/support/cpu.h index 338fe1253..f4afbb5f1 100644 --- a/spa/include/spa/support/cpu.h +++ b/spa/include/spa/support/cpu.h @@ -33,38 +33,42 @@ extern "C" { #include -#define SPA_CPU_FLAG_MMX (1<<0) /**< standard MMX */ -#define SPA_CPU_FLAG_MMXEXT (1<<1) /**< SSE integer or AMD MMX ext */ -#define SPA_CPU_FLAG_3DNOW (1<<2) /**< AMD 3DNOW */ -#define SPA_CPU_FLAG_SSE (1<<3) /**< SSE */ -#define SPA_CPU_FLAG_SSE2 (1<<4) /**< SSE2 */ -#define SPA_CPU_FLAG_3DNOWEXT (1<<5) /**< AMD 3DNowExt */ -#define SPA_CPU_FLAG_SSE3 (1<<6) /**< Prescott SSE3 */ -#define SPA_CPU_FLAG_SSSE3 (1<<7) /**< Conroe SSSE3 */ -#define SPA_CPU_FLAG_SSE41 (1<<8) /**< Penryn SSE4.1 */ -#define SPA_CPU_FLAG_SSE42 (1<<9) /**< Nehalem SSE4.2 */ -#define SPA_CPU_FLAG_AESNI (1<<10) /**< Advanced Encryption Standard */ -#define SPA_CPU_FLAG_AVX (1<<11) /**< AVX */ -#define SPA_CPU_FLAG_XOP (1<<12) /**< Bulldozer XOP */ -#define SPA_CPU_FLAG_FMA4 (1<<13) /**< Bulldozer FMA4 */ -#define SPA_CPU_FLAG_CMOV (1<<14) /**< supports cmov */ -#define SPA_CPU_FLAG_AVX2 (1<<15) /**< AVX2 */ -#define SPA_CPU_FLAG_FMA3 (1<<16) /**< Haswell FMA3 */ -#define SPA_CPU_FLAG_BMI1 (1<<17) /**< Bit Manipulation Instruction Set 1 */ -#define SPA_CPU_FLAG_BMI2 (1<<18) /**< Bit Manipulation Instruction Set 2 */ -#define SPA_CPU_FLAG_AVX512 (1<<19) /**< AVX-512 */ +/* x86 specific */ +#define SPA_CPU_FLAG_MMX (1<<0) /**< standard MMX */ +#define SPA_CPU_FLAG_MMXEXT (1<<1) /**< SSE integer or AMD MMX ext */ +#define SPA_CPU_FLAG_3DNOW (1<<2) /**< AMD 3DNOW */ +#define SPA_CPU_FLAG_SSE (1<<3) /**< SSE */ +#define SPA_CPU_FLAG_SSE2 (1<<4) /**< SSE2 */ +#define SPA_CPU_FLAG_3DNOWEXT (1<<5) /**< AMD 3DNowExt */ +#define SPA_CPU_FLAG_SSE3 (1<<6) /**< Prescott SSE3 */ +#define SPA_CPU_FLAG_SSSE3 (1<<7) /**< Conroe SSSE3 */ +#define SPA_CPU_FLAG_SSE41 (1<<8) /**< Penryn SSE4.1 */ +#define SPA_CPU_FLAG_SSE42 (1<<9) /**< Nehalem SSE4.2 */ +#define SPA_CPU_FLAG_AESNI (1<<10) /**< Advanced Encryption Standard */ +#define SPA_CPU_FLAG_AVX (1<<11) /**< AVX */ +#define SPA_CPU_FLAG_XOP (1<<12) /**< Bulldozer XOP */ +#define SPA_CPU_FLAG_FMA4 (1<<13) /**< Bulldozer FMA4 */ +#define SPA_CPU_FLAG_CMOV (1<<14) /**< supports cmov */ +#define SPA_CPU_FLAG_AVX2 (1<<15) /**< AVX2 */ +#define SPA_CPU_FLAG_FMA3 (1<<16) /**< Haswell FMA3 */ +#define SPA_CPU_FLAG_BMI1 (1<<17) /**< Bit Manipulation Instruction Set 1 */ +#define SPA_CPU_FLAG_BMI2 (1<<18) /**< Bit Manipulation Instruction Set 2 */ +#define SPA_CPU_FLAG_AVX512 (1<<19) /**< AVX-512 */ +#define SPA_CPU_FLAG_SLOW_UNALIGNED (1<<20) /**< unaligned loads/stores are slow */ -#define SPA_CPU_FLAG_ALTIVEC (1<<0) /**< standard */ -#define SPA_CPU_FLAG_VSX (1<<1) /**< ISA 2.06 */ -#define SPA_CPU_FLAG_POWER8 (1<<2) /**< ISA 2.07 */ +/* PPC specific */ +#define SPA_CPU_FLAG_ALTIVEC (1<<0) /**< standard */ +#define SPA_CPU_FLAG_VSX (1<<1) /**< ISA 2.06 */ +#define SPA_CPU_FLAG_POWER8 (1<<2) /**< ISA 2.07 */ -#define SPA_CPU_FLAG_ARMV5TE (1 << 0) -#define SPA_CPU_FLAG_ARMV6 (1 << 1) -#define SPA_CPU_FLAG_ARMV6T2 (1 << 2) -#define SPA_CPU_FLAG_VFP (1 << 3) -#define SPA_CPU_FLAG_VFPV3 (1 << 4) -#define SPA_CPU_FLAG_NEON (1 << 5) -#define SPA_CPU_FLAG_ARMV8 (1 << 6) +/* ARM specific */ +#define SPA_CPU_FLAG_ARMV5TE (1 << 0) +#define SPA_CPU_FLAG_ARMV6 (1 << 1) +#define SPA_CPU_FLAG_ARMV6T2 (1 << 2) +#define SPA_CPU_FLAG_VFP (1 << 3) +#define SPA_CPU_FLAG_VFPV3 (1 << 4) +#define SPA_CPU_FLAG_NEON (1 << 5) +#define SPA_CPU_FLAG_ARMV8 (1 << 6) #define SPA_CPU_FORCE_AUTODETECT ((uint32_t)-1) /** diff --git a/spa/include/spa/utils/defs.h b/spa/include/spa/utils/defs.h index fb1e3ddb7..f5ba1d656 100644 --- a/spa/include/spa/utils/defs.h +++ b/spa/include/spa/utils/defs.h @@ -121,6 +121,7 @@ struct spa_param_info { }) #define SPA_MEMBER(b,o,t) ((t*)((uint8_t*)(b) + (int)(o))) +#define SPA_MEMBER_ALIGN(b,o,a,t) SPA_PTR_ALIGN(SPA_MEMBER(b,o,t),a,t) #define SPA_CONTAINER_OF(p,t,m) (t*)((uint8_t*)p - offsetof (t,m)) diff --git a/spa/plugins/audioconvert/benchmark-fmt-ops.c b/spa/plugins/audioconvert/benchmark-fmt-ops.c index 823030328..d26f5bcff 100644 --- a/spa/plugins/audioconvert/benchmark-fmt-ops.c +++ b/spa/plugins/audioconvert/benchmark-fmt-ops.c @@ -31,6 +31,14 @@ #include "fmt-ops.c" +struct stats { + uint32_t n_samples; + uint32_t n_channels; + uint64_t perf; + const char *name; + const char *impl; +}; + #define MAX_SAMPLES 4096 #define MAX_CHANNELS 11 @@ -42,8 +50,13 @@ static uint8_t samp_out[MAX_SAMPLES * MAX_CHANNELS * 4]; static const int sample_sizes[] = { 0, 1, 128, 513, 4096 }; static const int channel_counts[] = { 1, 2, 4, 6, 8, 11 }; -static void run_test1(const char *name, bool in_packed, bool out_packed, convert_func_t func, - int n_channels, int n_samples) +#define MAX_RESULTS SPA_N_ELEMENTS(sample_sizes) * SPA_N_ELEMENTS(channel_counts) * 60 + +static uint32_t n_results = 0; +static struct stats results[MAX_RESULTS]; + +static void run_test1(const char *name, const char *impl, bool in_packed, bool out_packed, + convert_func_t func, int n_channels, int n_samples) { int i, j; const void *ip[n_channels]; @@ -67,18 +80,22 @@ static void run_test1(const char *name, bool in_packed, bool out_packed, convert clock_gettime(CLOCK_MONOTONIC, &ts); t2 = SPA_TIMESPEC_TO_NSEC(&ts); - fprintf(stderr, "%s: samples %d, channels %d: elapsed %"PRIu64" count %" - PRIu64" = %"PRIu64"/sec\n", name, n_samples, n_channels, - t2 - t1, count, count * (uint64_t)SPA_NSEC_PER_SEC / (t2 - t1)); + results[n_results++] = (struct stats) { + .n_samples = n_samples, + .n_channels = n_channels, + .perf = count * (uint64_t)SPA_NSEC_PER_SEC / (t2 - t1), + .name = name, + .impl = impl + }; } -static void run_test(const char *name, bool in_packed, bool out_packed, convert_func_t func) +static void run_test(const char *name, const char *impl, bool in_packed, bool out_packed, convert_func_t func) { size_t i, j; for (i = 0; i < SPA_N_ELEMENTS(sample_sizes); i++) { for (j = 0; j < SPA_N_ELEMENTS(channel_counts); j++) { - run_test1(name, in_packed, out_packed, func, channel_counts[j], + run_test1(name, impl, in_packed, out_packed, func, channel_counts[j], (sample_sizes[i] + (channel_counts[j] -1)) / channel_counts[j]); } } @@ -86,93 +103,124 @@ static void run_test(const char *name, bool in_packed, bool out_packed, convert_ static void test_f32_u8(void) { - run_test("test_f32_u8", true, true, conv_f32_to_u8); - run_test("test_f32d_u8", false, true, conv_f32d_to_u8); - run_test("test_f32_u8d", true, false, conv_f32_to_u8d); - run_test("test_f32d_u8d", false, false, conv_f32d_to_u8d); + run_test("test_f32_u8", "c", true, true, conv_f32_to_u8); + run_test("test_f32d_u8", "c", false, true, conv_f32d_to_u8); + run_test("test_f32_u8d", "c", true, false, conv_f32_to_u8d); + run_test("test_f32d_u8d", "c", false, false, conv_f32d_to_u8d); } static void test_u8_f32(void) { - run_test("test_u8_f32", true, true, conv_u8_to_f32); - run_test("test_u8d_f32", false, true, conv_u8d_to_f32); - run_test("test_u8_f32d", true, false, conv_u8_to_f32d); + run_test("test_u8_f32", "c", true, true, conv_u8_to_f32); + run_test("test_u8d_f32", "c", false, true, conv_u8d_to_f32); + run_test("test_u8_f32d", "c", true, false, conv_u8_to_f32d); } static void test_f32_s16(void) { - run_test("test_f32_s16", true, true, conv_f32_to_s16); - run_test("test_f32d_s16", false, true, conv_f32d_to_s16); - run_test("test_f32_s16d", true, false, conv_f32_to_s16d); + run_test("test_f32_s16", "c", true, true, conv_f32_to_s16); + run_test("test_f32d_s16", "c", false, true, conv_f32d_to_s16); +#if defined (HAVE_SSE2) + run_test("test_f32d_s16", "sse2", false, true, conv_f32d_to_s16_sse2); +#endif + run_test("test_f32_s16d", "c", true, false, conv_f32_to_s16d); } static void test_s16_f32(void) { - run_test("test_s16_f32", true, true, conv_s16_to_f32); - run_test("test_s16d_f32", false, true, conv_s16d_to_f32); - run_test("test_s16_f32d", true, false, conv_s16_to_f32d); + run_test("test_s16_f32", "c", true, true, conv_s16_to_f32); + run_test("test_s16d_f32", "c", false, true, conv_s16d_to_f32); + run_test("test_s16_f32d", "c", true, false, conv_s16_to_f32d); +#if defined (HAVE_SSE2) + run_test("test_s16_f32d", "sse2", true, false, conv_s16_to_f32d_sse2); +#endif } static void test_f32_s32(void) { - run_test("test_f32_s32", true, true, conv_f32_to_s32); - run_test("test_f32d_s32", false, true, conv_f32d_to_s32); - run_test("test_f32_s32d", true, false, conv_f32_to_s32d); + run_test("test_f32_s32", "c", true, true, conv_f32_to_s32); + run_test("test_f32d_s32", "c", false, true, conv_f32d_to_s32); +#if defined (HAVE_SSE2) + run_test("test_f32d_s32", "sse2", false, true, conv_f32d_to_s32_sse2); +#endif + run_test("test_f32_s32d", "c", true, false, conv_f32_to_s32d); } static void test_s32_f32(void) { - run_test("test_s32_f32", true, true, conv_s32_to_f32); - run_test("test_s32d_f32", false, true, conv_s32d_to_f32); - run_test("test_s32_f32d", true, false, conv_s32_to_f32d); + run_test("test_s32_f32", "c", true, true, conv_s32_to_f32); + run_test("test_s32d_f32", "c", false, true, conv_s32d_to_f32); + run_test("test_s32_f32d", "c", true, false, conv_s32_to_f32d); } static void test_f32_s24(void) { - run_test("test_f32_s24", true, true, conv_f32_to_s24); - run_test("test_f32d_s24", false, true, conv_f32d_to_s24); - run_test("test_f32_s24d", true, false, conv_f32_to_s24d); + run_test("test_f32_s24", "c", true, true, conv_f32_to_s24); + run_test("test_f32d_s24", "c", false, true, conv_f32d_to_s24); + run_test("test_f32_s24d", "c", true, false, conv_f32_to_s24d); } static void test_s24_f32(void) { - run_test("test_s24_f32", true, true, conv_s24_to_f32); - run_test("test_s24d_f32", false, true, conv_s24d_to_f32); - run_test("test_s24_f32d", true, false, conv_s24_to_f32d); + run_test("test_s24_f32", "c", true, true, conv_s24_to_f32); + run_test("test_s24d_f32", "c", false, true, conv_s24d_to_f32); + run_test("test_s24_f32d", "c", true, false, conv_s24_to_f32d); +#if defined (HAVE_SSE2) + run_test("test_s24_f32d", "sse2", true, false, conv_s24_to_f32d_sse2); +#endif +#if defined (HAVE_SSSE3) + run_test("test_s24_f32d", "ssse3", true, false, conv_s24_to_f32d_ssse3); +#endif +#if defined (HAVE_SSE41) + run_test("test_s24_f32d", "sse41", true, false, conv_s24_to_f32d_sse41); +#endif } static void test_f32_s24_32(void) { - run_test("test_f32_s24_32", true, true, conv_f32_to_s24_32); - run_test("test_f32d_s24_32", false, true, conv_f32d_to_s24_32); - run_test("test_f32_s24_32d", true, false, conv_f32_to_s24_32d); + run_test("test_f32_s24_32", "c", true, true, conv_f32_to_s24_32); + run_test("test_f32d_s24_32", "c", false, true, conv_f32d_to_s24_32); + run_test("test_f32_s24_32d", "c", true, false, conv_f32_to_s24_32d); } static void test_s24_32_f32(void) { - run_test("test_s24_32_f32", true, true, conv_s24_32_to_f32); - run_test("test_s24_32d_f32", false, true, conv_s24_32d_to_f32); - run_test("test_s24_32_f32d", true, false, conv_s24_32_to_f32d); + run_test("test_s24_32_f32", "c", true, true, conv_s24_32_to_f32); + run_test("test_s24_32d_f32", "c", false, true, conv_s24_32d_to_f32); + run_test("test_s24_32_f32d", "c", true, false, conv_s24_32_to_f32d); } static void test_interleave(void) { - run_test("test_interleave_8", false, true, interleave_8); - run_test("test_interleave_16", false, true, interleave_16); - run_test("test_interleave_24", false, true, interleave_24); - run_test("test_interleave_32", false, true, interleave_32); + run_test("test_interleave_8", "c", false, true, interleave_8); + run_test("test_interleave_16", "c", false, true, interleave_16); + run_test("test_interleave_24", "c", false, true, interleave_24); + run_test("test_interleave_32", "c", false, true, interleave_32); } static void test_deinterleave(void) { - run_test("test_deinterleave_8", true, false, deinterleave_8); - run_test("test_deinterleave_16", true, false, deinterleave_16); - run_test("test_deinterleave_24", true, false, deinterleave_24); - run_test("test_deinterleave_32", true, false, deinterleave_32); + run_test("test_deinterleave_8", "c", true, false, deinterleave_8); + run_test("test_deinterleave_16", "c", true, false, deinterleave_16); + run_test("test_deinterleave_24", "c", true, false, deinterleave_24); + run_test("test_deinterleave_32", "c", true, false, deinterleave_32); +} + +static int compare_func(const void *_a, const void *_b) +{ + const struct stats *a = _a, *b = _b; + int diff; + if ((diff = strcmp(a->name, b->name)) != 0) return diff; + if ((diff = a->n_samples - b->n_samples) != 0) return diff; + if ((diff = a->n_channels - b->n_channels) != 0) return diff; + if ((diff = b->perf - a->perf) != 0) return diff; + return 0; } int main(int argc, char *argv[]) { + uint32_t i; + find_conv_info(0, 0, 0); test_f32_u8(); @@ -188,5 +236,14 @@ int main(int argc, char *argv[]) test_interleave(); test_deinterleave(); + spa_assert(n_results <= MAX_RESULTS); + + qsort(results, n_results, sizeof(struct stats), compare_func); + + for (i = 0; i < n_results; i++) { + struct stats *s = &results[i]; + fprintf(stderr, "%-12."PRIu64" \t%-32.32s %s \t samples %d, channels %d\n", + s->perf, s->name, s->impl, s->n_samples, s->n_channels); + } return 0; } diff --git a/spa/plugins/audioconvert/benchmark-resample.c b/spa/plugins/audioconvert/benchmark-resample.c new file mode 100644 index 000000000..1126881a9 --- /dev/null +++ b/spa/plugins/audioconvert/benchmark-resample.c @@ -0,0 +1,183 @@ +/* Spa + * + * Copyright © 2019 Wim Taymans + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include +#include +#include +#include +#include + +#include "resample.h" +#include "resample-native.h" +#include "resample-speex.h" + +#define MAX_SAMPLES 4096 +#define MAX_CHANNELS 11 + +#define MAX_COUNT 200 + +struct stats { + uint32_t in_rate; + uint32_t out_rate; + uint32_t n_samples; + uint32_t n_channels; + uint64_t perf; + const char *name; + const char *impl; +}; + +static float samp_in[MAX_SAMPLES * MAX_CHANNELS]; +static float samp_out[MAX_SAMPLES * MAX_CHANNELS]; + +static const int sample_sizes[] = { 0, 1, 128, 513, 4096 }; +static const int in_rates[] = { 44100, 44100, 48000, 96000, 22050, 96000 }; +static const int out_rates[] = { 44100, 48000, 44100, 48000, 48000, 44100 }; + + +#define MAX_RESAMPLER 4 +#define MAX_SIZES SPA_N_ELEMENTS(sample_sizes) +#define MAX_RATES SPA_N_ELEMENTS(in_rates) + +static uint32_t n_results = 0; +static struct stats results[MAX_RESAMPLER * MAX_SIZES * MAX_RATES]; + +static void run_test1(const char *name, const char *impl, struct resample *r, int n_samples) +{ + uint32_t i, j; + const void *ip[MAX_CHANNELS]; + void *op[MAX_CHANNELS]; + struct timespec ts; + uint64_t count, t1, t2; + uint32_t in_len, out_len; + + for (j = 0; j < r->channels; j++) { + ip[j] = &samp_in[j * MAX_SAMPLES]; + op[j] = &samp_out[j * MAX_SAMPLES]; + } + + clock_gettime(CLOCK_MONOTONIC, &ts); + t1 = SPA_TIMESPEC_TO_NSEC(&ts); + + count = 0; + for (i = 0; i < MAX_COUNT; i++) { + in_len = n_samples; + out_len = MAX_SAMPLES; + resample_process(r, ip, &in_len, op, &out_len); + count++; + } + clock_gettime(CLOCK_MONOTONIC, &ts); + t2 = SPA_TIMESPEC_TO_NSEC(&ts); + + results[n_results++] = (struct stats) { + .in_rate = r->i_rate, + .out_rate = r->o_rate, + .n_samples = n_samples, + .n_channels = r->channels, + .perf = count * (uint64_t)SPA_NSEC_PER_SEC / (t2 - t1), + .name = name, + .impl = impl + }; +} + +static void run_test(const char *name, const char *impl, struct resample *r) +{ + size_t i; + for (i = 0; i < SPA_N_ELEMENTS(sample_sizes); i++) + run_test1(name, impl, r, sample_sizes[i]); +} + +static int compare_func(const void *_a, const void *_b) +{ + const struct stats *a = _a, *b = _b; + int diff; + + if ((diff = a->in_rate - b->in_rate) != 0) return diff; + if ((diff = a->out_rate - b->out_rate) != 0) return diff; + if ((diff = a->n_samples - b->n_samples) != 0) return diff; + if ((diff = a->n_channels - b->n_channels) != 0) return diff; + if ((diff = b->perf - a->perf) != 0) return diff; + return 0; +} + +int main(int argc, char *argv[]) +{ + struct resample r; + uint32_t i; + + for (i = 0; i < SPA_N_ELEMENTS(in_rates); i++) { + spa_zero(r); + r.channels = 2; + r.cpu_flags = 0; + r.i_rate = in_rates[i]; + r.o_rate = out_rates[i]; + impl_native_init(&r); + run_test("native", "c", &r); + resample_free(&r); + } +#if defined (HAVE_SSE) + for (i = 0; i < SPA_N_ELEMENTS(in_rates); i++) { + spa_zero(r); + r.channels = 2; + r.cpu_flags = SPA_CPU_FLAG_SSE; + r.i_rate = in_rates[i]; + r.o_rate = out_rates[i]; + impl_native_init(&r); + run_test("native", "sse", &r); + resample_free(&r); + } +#endif +#if defined (HAVE_SSSE3) + for (i = 0; i < SPA_N_ELEMENTS(in_rates); i++) { + spa_zero(r); + r.channels = 2; + r.cpu_flags = SPA_CPU_FLAG_SSSE3 | SPA_CPU_FLAG_SLOW_UNALIGNED; + r.i_rate = in_rates[i]; + r.o_rate = out_rates[i]; + impl_native_init(&r); + run_test("native", "ssse3", &r); + resample_free(&r); + } +#endif + + for (i = 0; i < SPA_N_ELEMENTS(in_rates); i++) { + spa_zero(r); + r.channels = 2; + r.i_rate = in_rates[i]; + r.o_rate = out_rates[i]; + impl_speex_init(&r); + run_test("speex", "def", &r); + resample_free(&r); + } + + qsort(results, n_results, sizeof(struct stats), compare_func); + + for (i = 0; i < n_results; i++) { + struct stats *s = &results[i]; + fprintf(stderr, "%-12."PRIu64" \t%-16.16s %s \t%d->%d samples %d, channels %d\n", + s->perf, s->name, s->impl, s->in_rate, s->out_rate, + s->n_samples, s->n_channels); + } + return 0; +} diff --git a/spa/plugins/audioconvert/fmt-ops-sse2.c b/spa/plugins/audioconvert/fmt-ops-sse2.c index c14c4da86..3e2e58000 100644 --- a/spa/plugins/audioconvert/fmt-ops-sse2.c +++ b/spa/plugins/audioconvert/fmt-ops-sse2.c @@ -118,7 +118,7 @@ conv_s16_to_f32d_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RE conv_s16_to_f32d_1_sse2(data, &dst[i], &s[i], n_channels, n_samples); } -static void +void conv_s24_to_f32d_1_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src, uint32_t n_channels, uint32_t n_samples) { const uint8_t *s = src; @@ -128,7 +128,7 @@ conv_s24_to_f32d_1_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_ __m128i in; __m128 out, factor = _mm_set1_ps(1.0f / S24_SCALE); - if (SPA_IS_ALIGNED(d0, 16)) { + if (SPA_IS_ALIGNED(d0, 16) && n_samples > 0) { unrolled = n_samples / 4; if ((n_samples & 3) == 0) unrolled--; @@ -167,7 +167,9 @@ conv_s24_to_f32d_2_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_ __m128i in[2]; __m128 out[2], factor = _mm_set1_ps(1.0f / S24_SCALE); - if (SPA_IS_ALIGNED(d0, 16)) { + if (SPA_IS_ALIGNED(d0, 16) && + SPA_IS_ALIGNED(d1, 16) && + n_samples > 0) { unrolled = n_samples / 4; if ((n_samples & 3) == 0) unrolled--; @@ -224,7 +226,11 @@ conv_s24_to_f32d_4_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_ __m128i in[4]; __m128 out[4], factor = _mm_set1_ps(1.0f / S24_SCALE); - if (SPA_IS_ALIGNED(d0, 16)) { + if (SPA_IS_ALIGNED(d0, 16) && + SPA_IS_ALIGNED(d1, 16) && + SPA_IS_ALIGNED(d2, 16) && + SPA_IS_ALIGNED(d3, 16) && + n_samples > 0) { unrolled = n_samples / 4; if ((n_samples & 3) == 0) unrolled--; @@ -418,8 +424,7 @@ conv_f32d_to_s32_4_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_RE if (SPA_IS_ALIGNED(s0, 16) && SPA_IS_ALIGNED(s1, 16) && SPA_IS_ALIGNED(s2, 16) && - SPA_IS_ALIGNED(s3, 16) && - SPA_IS_ALIGNED(d, 16)) + SPA_IS_ALIGNED(s3, 16)) unrolled = n_samples / 4; else unrolled = 0; @@ -442,10 +447,10 @@ conv_f32d_to_s32_4_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_RE out[2] = _mm_cvtps_epi32(in[2]); out[3] = _mm_cvtps_epi32(in[3]); - _mm_store_si128((__m128i*)(d + 0*n_channels), out[0]); - _mm_store_si128((__m128i*)(d + 1*n_channels), out[1]); - _mm_store_si128((__m128i*)(d + 2*n_channels), out[2]); - _mm_store_si128((__m128i*)(d + 3*n_channels), out[3]); + _mm_storeu_si128((__m128i*)(d + 0*n_channels), out[0]); + _mm_storeu_si128((__m128i*)(d + 1*n_channels), out[1]); + _mm_storeu_si128((__m128i*)(d + 2*n_channels), out[2]); + _mm_storeu_si128((__m128i*)(d + 3*n_channels), out[3]); d += 4*n_channels; } for(; n < n_samples; n++) { diff --git a/spa/plugins/audioconvert/fmt-ops-ssse3.c b/spa/plugins/audioconvert/fmt-ops-ssse3.c index dcfc81c03..772354ba0 100644 --- a/spa/plugins/audioconvert/fmt-ops-ssse3.c +++ b/spa/plugins/audioconvert/fmt-ops-ssse3.c @@ -38,7 +38,10 @@ conv_s24_to_f32d_4_ssse3(void *data, void * SPA_RESTRICT dst[], const void * SPA const __m128i mask = _mm_setr_epi8(-1, 0, 1, 2, -1, 3, 4, 5, -1, 6, 7, 8, -1, 9, 10, 11); //const __m128i mask = _mm_set_epi8(15, 14, 13, -1, 12, 11, 10, -1, 9, 8, 7, -1, 6, 5, 4, -1); - if (SPA_IS_ALIGNED(d0, 16)) + if (SPA_IS_ALIGNED(d0, 16) && + SPA_IS_ALIGNED(d1, 16) && + SPA_IS_ALIGNED(d2, 16) && + SPA_IS_ALIGNED(d3, 16)) unrolled = n_samples / 4; else unrolled = 0; @@ -90,8 +93,8 @@ conv_s24_to_f32d_4_ssse3(void *data, void * SPA_RESTRICT dst[], const void * SPA } } -extern void conv_s24_to_f32d_2_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src, uint32_t n_channels, uint32_t n_samples); -extern void conv_s24_to_f32d_1_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src, uint32_t n_channels, uint32_t n_samples); +void +conv_s24_to_f32d_1_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src, uint32_t n_channels, uint32_t n_samples); void conv_s24_to_f32d_ssse3(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples) @@ -101,10 +104,6 @@ conv_s24_to_f32d_ssse3(void *data, void * SPA_RESTRICT dst[], const void * SPA_R for(; i + 3 < n_channels; i += 4) conv_s24_to_f32d_4_ssse3(data, &dst[i], &s[3*i], n_channels, n_samples); -#if defined (HAVE_SSE2) - for(; i + 1 < n_channels; i += 2) - conv_s24_to_f32d_2_sse2(data, &dst[i], &s[3*i], n_channels, n_samples); for(; i < n_channels; i++) conv_s24_to_f32d_1_sse2(data, &dst[i], &s[3*i], n_channels, n_samples); -#endif } diff --git a/spa/plugins/audioconvert/meson.build b/spa/plugins/audioconvert/meson.build index 0c57790bd..c916cee61 100644 --- a/spa/plugins/audioconvert/meson.build +++ b/spa/plugins/audioconvert/meson.build @@ -79,14 +79,16 @@ endforeach benchmark_apps = [ 'benchmark-fmt-ops', + 'benchmark-resample', ] foreach a : benchmark_apps benchmark(a, executable(a, a + '.c', - dependencies : [dl_lib, pthread_lib, mathlib ], + dependencies : [dl_lib, pthread_lib, mathlib, speexdsp_dep, ], include_directories : [spa_inc ], - c_args : [ '-D_GNU_SOURCE' ], + c_args : [ simd_cargs, '-D_GNU_SOURCE' ], + link_with : simd_dependencies, install : false), env : [ 'SPA_PLUGIN_DIR=@0@/spa/plugins/'.format(meson.build_root()), diff --git a/spa/plugins/audioconvert/resample-native.h b/spa/plugins/audioconvert/resample-native.h index 1e3faee36..dd2fac94e 100644 --- a/spa/plugins/audioconvert/resample-native.h +++ b/spa/plugins/audioconvert/resample-native.h @@ -119,11 +119,11 @@ static void impl_native_update_rate(struct resample *r, double rate) data->func = is_full ? do_resample_full_c : do_resample_inter_c; #if defined (HAVE_SSE) - if (r->cpu_flags & SPA_CPU_FLAG_SSE) + if (SPA_FLAG_CHECK(r->cpu_flags, SPA_CPU_FLAG_SSE)) data->func = is_full ? do_resample_full_sse : do_resample_inter_sse; #endif #if defined (HAVE_SSSE3) - if (r->cpu_flags & SPA_CPU_FLAG_SSSE3) + if (SPA_FLAG_CHECK(r->cpu_flags, SPA_CPU_FLAG_SSSE3 | SPA_CPU_FLAG_SLOW_UNALIGNED)) data->func = is_full ? do_resample_full_ssse3 : do_resample_inter_ssse3; #endif } @@ -276,10 +276,8 @@ static int impl_native_init(struct resample *r) d->n_phases = n_phases; d->in_rate = in_rate; d->out_rate = out_rate; - d->filter = SPA_MEMBER(d, sizeof(struct native_data), float); - d->filter = SPA_PTR_ALIGN(d->filter, 64, float); - d->hist_mem = SPA_MEMBER(d->filter, filter_size, float); - d->hist_mem = SPA_PTR_ALIGN(d->hist_mem, 64, float); + d->filter = SPA_MEMBER_ALIGN(d, sizeof(struct native_data), 64, float); + d->hist_mem = SPA_MEMBER_ALIGN(d->filter, filter_size, 64, float); d->history = SPA_MEMBER(d->hist_mem, history_size, float*); d->filter_stride = filter_stride / sizeof(float); d->filter_stride_os = d->filter_stride * oversample;