2015-07-11 20:32:11 +02:00
|
|
|
/*
|
|
|
|
* Assembly testing and benchmarking tool
|
|
|
|
* Copyright (c) 2015 Henrik Gramner
|
|
|
|
* Copyright (c) 2008 Loren Merritt
|
|
|
|
*
|
2015-07-12 21:00:50 +02:00
|
|
|
* This file is part of FFmpeg.
|
2015-07-11 20:32:11 +02:00
|
|
|
*
|
2015-07-12 21:00:50 +02:00
|
|
|
* FFmpeg is free software; you can redistribute it and/or modify
|
2015-07-11 20:32:11 +02:00
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
2015-07-12 21:00:50 +02:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2015-07-11 20:32:11 +02:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
2015-07-12 21:00:50 +02:00
|
|
|
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
|
2015-07-11 20:32:11 +02:00
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#if CONFIG_LINUX_PERF
|
|
|
|
# ifndef _GNU_SOURCE
|
|
|
|
# define _GNU_SOURCE // for syscall (performance monitoring API)
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
#include <stdarg.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "checkasm.h"
|
|
|
|
#include "libavutil/common.h"
|
|
|
|
#include "libavutil/cpu.h"
|
2015-12-07 17:14:46 +02:00
|
|
|
#include "libavutil/intfloat.h"
|
2015-07-11 20:32:11 +02:00
|
|
|
#include "libavutil/random_seed.h"
|
|
|
|
|
2015-07-29 22:08:09 +02:00
|
|
|
#if HAVE_IO_H
|
|
|
|
#include <io.h>
|
|
|
|
#endif
|
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
#if HAVE_SETCONSOLETEXTATTRIBUTE
|
|
|
|
#include <windows.h>
|
|
|
|
#define COLOR_RED FOREGROUND_RED
|
|
|
|
#define COLOR_GREEN FOREGROUND_GREEN
|
|
|
|
#define COLOR_YELLOW (FOREGROUND_RED|FOREGROUND_GREEN)
|
|
|
|
#else
|
|
|
|
#define COLOR_RED 1
|
|
|
|
#define COLOR_GREEN 2
|
|
|
|
#define COLOR_YELLOW 3
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if !HAVE_ISATTY
|
|
|
|
#define isatty(fd) 1
|
|
|
|
#endif
|
|
|
|
|
2015-12-30 23:46:06 +02:00
|
|
|
#if ARCH_ARM && HAVE_ARMV5TE_EXTERNAL
|
|
|
|
#include "libavutil/arm/cpu.h"
|
|
|
|
|
|
|
|
void (*checkasm_checked_call)(void *func, int dummy, ...) = checkasm_checked_call_novfp;
|
|
|
|
#endif
|
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
/* List of tests to invoke */
|
2015-07-24 23:46:20 +02:00
|
|
|
static const struct {
|
|
|
|
const char *name;
|
|
|
|
void (*func)(void);
|
|
|
|
} tests[] = {
|
2015-10-01 19:25:33 +02:00
|
|
|
#if CONFIG_AVCODEC
|
2017-06-02 10:06:08 +02:00
|
|
|
#if CONFIG_AAC_DECODER
|
|
|
|
{ "aacpsdsp", checkasm_check_aacpsdsp },
|
2017-06-09 11:34:12 +02:00
|
|
|
{ "sbrdsp", checkasm_check_sbrdsp },
|
2017-06-02 10:06:08 +02:00
|
|
|
#endif
|
2015-10-07 01:25:49 +02:00
|
|
|
#if CONFIG_ALAC_DECODER
|
|
|
|
{ "alacdsp", checkasm_check_alacdsp },
|
|
|
|
#endif
|
2017-03-20 20:10:56 +02:00
|
|
|
#if CONFIG_AUDIODSP
|
|
|
|
{ "audiodsp", checkasm_check_audiodsp },
|
|
|
|
#endif
|
2017-03-20 20:04:12 +02:00
|
|
|
#if CONFIG_BLOCKDSP
|
|
|
|
{ "blockdsp", checkasm_check_blockdsp },
|
|
|
|
#endif
|
2015-10-01 19:25:33 +02:00
|
|
|
#if CONFIG_BSWAPDSP
|
|
|
|
{ "bswapdsp", checkasm_check_bswapdsp },
|
|
|
|
#endif
|
2016-01-16 10:54:38 +02:00
|
|
|
#if CONFIG_DCA_DECODER
|
2016-01-02 13:45:34 +02:00
|
|
|
{ "synth_filter", checkasm_check_synth_filter },
|
2016-01-16 10:54:38 +02:00
|
|
|
#endif
|
2017-09-17 23:48:02 +02:00
|
|
|
#if CONFIG_EXR_DECODER
|
|
|
|
{ "exrdsp", checkasm_check_exrdsp },
|
|
|
|
#endif
|
2015-10-01 19:25:33 +02:00
|
|
|
#if CONFIG_FLACDSP
|
|
|
|
{ "flacdsp", checkasm_check_flacdsp },
|
|
|
|
#endif
|
2016-01-02 13:50:13 +02:00
|
|
|
#if CONFIG_FMTCONVERT
|
|
|
|
{ "fmtconvert", checkasm_check_fmtconvert },
|
|
|
|
#endif
|
2017-07-05 21:34:00 +02:00
|
|
|
#if CONFIG_G722DSP
|
|
|
|
{ "g722dsp", checkasm_check_g722dsp },
|
|
|
|
#endif
|
2016-07-13 17:16:14 +02:00
|
|
|
#if CONFIG_H264DSP
|
|
|
|
{ "h264dsp", checkasm_check_h264dsp },
|
|
|
|
#endif
|
2015-10-01 19:25:33 +02:00
|
|
|
#if CONFIG_H264PRED
|
|
|
|
{ "h264pred", checkasm_check_h264pred },
|
|
|
|
#endif
|
|
|
|
#if CONFIG_H264QPEL
|
|
|
|
{ "h264qpel", checkasm_check_h264qpel },
|
|
|
|
#endif
|
2017-02-02 12:39:30 +02:00
|
|
|
#if CONFIG_HEVC_DECODER
|
2017-03-24 13:37:09 +02:00
|
|
|
{ "hevc_add_res", checkasm_check_hevc_add_res },
|
2017-02-02 12:39:30 +02:00
|
|
|
{ "hevc_idct", checkasm_check_hevc_idct },
|
2018-03-07 06:42:30 +02:00
|
|
|
{ "hevc_sao", checkasm_check_hevc_sao },
|
2017-02-02 12:39:30 +02:00
|
|
|
#endif
|
2017-11-21 10:09:42 +02:00
|
|
|
#if CONFIG_HUFFYUV_DECODER
|
|
|
|
{ "huffyuvdsp", checkasm_check_huffyuvdsp },
|
|
|
|
#endif
|
2015-10-01 19:25:33 +02:00
|
|
|
#if CONFIG_JPEG2000_DECODER
|
|
|
|
{ "jpeg2000dsp", checkasm_check_jpeg2000dsp },
|
|
|
|
#endif
|
2017-03-22 17:29:44 +02:00
|
|
|
#if CONFIG_HUFFYUVDSP
|
|
|
|
{ "llviddsp", checkasm_check_llviddsp },
|
|
|
|
#endif
|
2018-01-14 15:23:42 +02:00
|
|
|
#if CONFIG_LLVIDENCDSP
|
|
|
|
{ "llviddspenc", checkasm_check_llviddspenc },
|
|
|
|
#endif
|
2015-11-01 13:31:22 +02:00
|
|
|
#if CONFIG_PIXBLOCKDSP
|
|
|
|
{ "pixblockdsp", checkasm_check_pixblockdsp },
|
|
|
|
#endif
|
2017-11-21 09:31:12 +02:00
|
|
|
#if CONFIG_UTVIDEO_DECODER
|
|
|
|
{ "utvideodsp", checkasm_check_utvideodsp },
|
|
|
|
#endif
|
2015-10-01 19:25:33 +02:00
|
|
|
#if CONFIG_V210_ENCODER
|
|
|
|
{ "v210enc", checkasm_check_v210enc },
|
|
|
|
#endif
|
2016-11-14 16:27:48 +02:00
|
|
|
#if CONFIG_VP8DSP
|
|
|
|
{ "vp8dsp", checkasm_check_vp8dsp },
|
|
|
|
#endif
|
2015-10-01 19:25:33 +02:00
|
|
|
#if CONFIG_VP9_DECODER
|
|
|
|
{ "vp9dsp", checkasm_check_vp9dsp },
|
|
|
|
#endif
|
2016-01-17 23:22:26 +02:00
|
|
|
#if CONFIG_VIDEODSP
|
|
|
|
{ "videodsp", checkasm_check_videodsp },
|
|
|
|
#endif
|
2016-02-19 01:23:49 +02:00
|
|
|
#endif
|
|
|
|
#if CONFIG_AVFILTER
|
|
|
|
#if CONFIG_BLEND_FILTER
|
|
|
|
{ "vf_blend", checkasm_check_blend },
|
|
|
|
#endif
|
2016-04-06 20:09:08 +02:00
|
|
|
#if CONFIG_COLORSPACE_FILTER
|
|
|
|
{ "vf_colorspace", checkasm_check_colorspace },
|
|
|
|
#endif
|
2017-12-11 12:26:44 +02:00
|
|
|
#if CONFIG_HFLIP_FILTER
|
|
|
|
{ "vf_hflip", checkasm_check_vf_hflip },
|
|
|
|
#endif
|
2017-12-03 17:56:25 +02:00
|
|
|
#if CONFIG_THRESHOLD_FILTER
|
|
|
|
{ "vf_threshold", checkasm_check_vf_threshold },
|
|
|
|
#endif
|
2017-04-11 22:12:21 +02:00
|
|
|
#endif
|
|
|
|
#if CONFIG_AVUTIL
|
|
|
|
{ "fixed_dsp", checkasm_check_fixed_dsp },
|
2017-04-11 22:16:56 +02:00
|
|
|
{ "float_dsp", checkasm_check_float_dsp },
|
2015-07-11 20:32:11 +02:00
|
|
|
#endif
|
2015-07-24 23:46:20 +02:00
|
|
|
{ NULL }
|
2015-07-11 20:32:11 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/* List of cpu flags to check */
|
|
|
|
static const struct {
|
|
|
|
const char *name;
|
|
|
|
const char *suffix;
|
|
|
|
int flag;
|
|
|
|
} cpus[] = {
|
2015-07-12 16:41:42 +02:00
|
|
|
#if ARCH_AARCH64
|
|
|
|
{ "ARMV8", "armv8", AV_CPU_FLAG_ARMV8 },
|
|
|
|
{ "NEON", "neon", AV_CPU_FLAG_NEON },
|
|
|
|
#elif ARCH_ARM
|
|
|
|
{ "ARMV5TE", "armv5te", AV_CPU_FLAG_ARMV5TE },
|
|
|
|
{ "ARMV6", "armv6", AV_CPU_FLAG_ARMV6 },
|
|
|
|
{ "ARMV6T2", "armv6t2", AV_CPU_FLAG_ARMV6T2 },
|
|
|
|
{ "VFP", "vfp", AV_CPU_FLAG_VFP },
|
2015-12-09 23:28:36 +02:00
|
|
|
{ "VFP_VM", "vfp_vm", AV_CPU_FLAG_VFP_VM },
|
2015-07-12 16:41:42 +02:00
|
|
|
{ "VFPV3", "vfp3", AV_CPU_FLAG_VFPV3 },
|
|
|
|
{ "NEON", "neon", AV_CPU_FLAG_NEON },
|
|
|
|
#elif ARCH_PPC
|
|
|
|
{ "ALTIVEC", "altivec", AV_CPU_FLAG_ALTIVEC },
|
|
|
|
{ "VSX", "vsx", AV_CPU_FLAG_VSX },
|
|
|
|
{ "POWER8", "power8", AV_CPU_FLAG_POWER8 },
|
|
|
|
#elif ARCH_X86
|
2015-07-11 20:32:11 +02:00
|
|
|
{ "MMX", "mmx", AV_CPU_FLAG_MMX|AV_CPU_FLAG_CMOV },
|
|
|
|
{ "MMXEXT", "mmxext", AV_CPU_FLAG_MMXEXT },
|
|
|
|
{ "3DNOW", "3dnow", AV_CPU_FLAG_3DNOW },
|
|
|
|
{ "3DNOWEXT", "3dnowext", AV_CPU_FLAG_3DNOWEXT },
|
|
|
|
{ "SSE", "sse", AV_CPU_FLAG_SSE },
|
|
|
|
{ "SSE2", "sse2", AV_CPU_FLAG_SSE2|AV_CPU_FLAG_SSE2SLOW },
|
|
|
|
{ "SSE3", "sse3", AV_CPU_FLAG_SSE3|AV_CPU_FLAG_SSE3SLOW },
|
|
|
|
{ "SSSE3", "ssse3", AV_CPU_FLAG_SSSE3|AV_CPU_FLAG_ATOM },
|
|
|
|
{ "SSE4.1", "sse4", AV_CPU_FLAG_SSE4 },
|
|
|
|
{ "SSE4.2", "sse42", AV_CPU_FLAG_SSE42 },
|
2015-10-26 09:08:58 +02:00
|
|
|
{ "AES-NI", "aesni", AV_CPU_FLAG_AESNI },
|
2015-07-11 20:32:11 +02:00
|
|
|
{ "AVX", "avx", AV_CPU_FLAG_AVX },
|
|
|
|
{ "XOP", "xop", AV_CPU_FLAG_XOP },
|
|
|
|
{ "FMA3", "fma3", AV_CPU_FLAG_FMA3 },
|
|
|
|
{ "FMA4", "fma4", AV_CPU_FLAG_FMA4 },
|
|
|
|
{ "AVX2", "avx2", AV_CPU_FLAG_AVX2 },
|
2017-10-30 14:04:59 +02:00
|
|
|
{ "AVX-512", "avx512", AV_CPU_FLAG_AVX512 },
|
2015-07-11 20:32:11 +02:00
|
|
|
#endif
|
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct CheckasmFuncVersion {
|
|
|
|
struct CheckasmFuncVersion *next;
|
2015-08-16 13:00:21 +02:00
|
|
|
void *func;
|
2015-07-11 20:32:11 +02:00
|
|
|
int ok;
|
|
|
|
int cpu;
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
CheckasmPerf perf;
|
2015-07-11 20:32:11 +02:00
|
|
|
} CheckasmFuncVersion;
|
|
|
|
|
|
|
|
/* Binary search tree node */
|
|
|
|
typedef struct CheckasmFunc {
|
|
|
|
struct CheckasmFunc *child[2];
|
|
|
|
CheckasmFuncVersion versions;
|
2015-09-25 18:56:00 +02:00
|
|
|
uint8_t color; /* 0 = red, 1 = black */
|
2015-07-11 20:32:11 +02:00
|
|
|
char name[1];
|
|
|
|
} CheckasmFunc;
|
|
|
|
|
|
|
|
/* Internal state */
|
|
|
|
static struct {
|
|
|
|
CheckasmFunc *funcs;
|
|
|
|
CheckasmFunc *current_func;
|
|
|
|
CheckasmFuncVersion *current_func_ver;
|
2015-07-24 23:46:20 +02:00
|
|
|
const char *current_test_name;
|
2015-07-11 20:32:11 +02:00
|
|
|
const char *bench_pattern;
|
|
|
|
int bench_pattern_len;
|
|
|
|
int num_checked;
|
|
|
|
int num_failed;
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
|
|
|
|
/* perf */
|
2015-07-11 20:32:11 +02:00
|
|
|
int nop_time;
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
int sysfd;
|
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
int cpu_flag;
|
|
|
|
const char *cpu_flag_name;
|
2016-11-04 00:40:26 +02:00
|
|
|
const char *test_name;
|
2015-07-11 20:32:11 +02:00
|
|
|
} state;
|
|
|
|
|
|
|
|
/* PRNG state */
|
|
|
|
AVLFG checkasm_lfg;
|
|
|
|
|
2015-12-07 17:14:46 +02:00
|
|
|
/* float compare support code */
|
|
|
|
static int is_negative(union av_intfloat32 u)
|
|
|
|
{
|
|
|
|
return u.i >> 31;
|
|
|
|
}
|
|
|
|
|
|
|
|
int float_near_ulp(float a, float b, unsigned max_ulp)
|
|
|
|
{
|
|
|
|
union av_intfloat32 x, y;
|
|
|
|
|
|
|
|
x.f = a;
|
|
|
|
y.f = b;
|
|
|
|
|
|
|
|
if (is_negative(x) != is_negative(y)) {
|
|
|
|
// handle -0.0 == +0.0
|
|
|
|
return a == b;
|
|
|
|
}
|
|
|
|
|
2016-07-19 05:26:33 +02:00
|
|
|
if (llabs((int64_t)x.i - y.i) <= max_ulp)
|
2015-12-07 17:14:46 +02:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int float_near_ulp_array(const float *a, const float *b, unsigned max_ulp,
|
|
|
|
unsigned len)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (!float_near_ulp(a[i], b[i], max_ulp))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int float_near_abs_eps(float a, float b, float eps)
|
|
|
|
{
|
|
|
|
float abs_diff = fabsf(a - b);
|
|
|
|
|
|
|
|
return abs_diff < eps;
|
|
|
|
}
|
|
|
|
|
|
|
|
int float_near_abs_eps_array(const float *a, const float *b, float eps,
|
|
|
|
unsigned len)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (!float_near_abs_eps(a[i], b[i], eps))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int float_near_abs_eps_ulp(float a, float b, float eps, unsigned max_ulp)
|
|
|
|
{
|
|
|
|
return float_near_ulp(a, b, max_ulp) || float_near_abs_eps(a, b, eps);
|
|
|
|
}
|
|
|
|
|
|
|
|
int float_near_abs_eps_array_ulp(const float *a, const float *b, float eps,
|
|
|
|
unsigned max_ulp, unsigned len)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (!float_near_abs_eps_ulp(a[i], b[i], eps, max_ulp))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-04-11 22:16:56 +02:00
|
|
|
int double_near_abs_eps(double a, double b, double eps)
|
|
|
|
{
|
|
|
|
double abs_diff = fabs(a - b);
|
|
|
|
|
|
|
|
return abs_diff < eps;
|
|
|
|
}
|
|
|
|
|
|
|
|
int double_near_abs_eps_array(const double *a, const double *b, double eps,
|
|
|
|
unsigned len)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (!double_near_abs_eps(a[i], b[i], eps))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
/* Print colored text to stderr if the terminal supports it */
|
|
|
|
static void color_printf(int color, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
static int use_color = -1;
|
|
|
|
va_list arg;
|
|
|
|
|
|
|
|
#if HAVE_SETCONSOLETEXTATTRIBUTE
|
|
|
|
static HANDLE con;
|
|
|
|
static WORD org_attributes;
|
|
|
|
|
|
|
|
if (use_color < 0) {
|
|
|
|
CONSOLE_SCREEN_BUFFER_INFO con_info;
|
|
|
|
con = GetStdHandle(STD_ERROR_HANDLE);
|
|
|
|
if (con && con != INVALID_HANDLE_VALUE && GetConsoleScreenBufferInfo(con, &con_info)) {
|
|
|
|
org_attributes = con_info.wAttributes;
|
|
|
|
use_color = 1;
|
|
|
|
} else
|
|
|
|
use_color = 0;
|
|
|
|
}
|
|
|
|
if (use_color)
|
|
|
|
SetConsoleTextAttribute(con, (org_attributes & 0xfff0) | (color & 0x0f));
|
|
|
|
#else
|
|
|
|
if (use_color < 0) {
|
|
|
|
const char *term = getenv("TERM");
|
|
|
|
use_color = term && strcmp(term, "dumb") && isatty(2);
|
|
|
|
}
|
|
|
|
if (use_color)
|
|
|
|
fprintf(stderr, "\x1b[%d;3%dm", (color & 0x08) >> 3, color & 0x07);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
va_start(arg, fmt);
|
|
|
|
vfprintf(stderr, fmt, arg);
|
|
|
|
va_end(arg);
|
|
|
|
|
|
|
|
if (use_color) {
|
|
|
|
#if HAVE_SETCONSOLETEXTATTRIBUTE
|
|
|
|
SetConsoleTextAttribute(con, org_attributes);
|
|
|
|
#else
|
|
|
|
fprintf(stderr, "\x1b[0m");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Deallocate a tree */
|
|
|
|
static void destroy_func_tree(CheckasmFunc *f)
|
|
|
|
{
|
|
|
|
if (f) {
|
|
|
|
CheckasmFuncVersion *v = f->versions.next;
|
|
|
|
while (v) {
|
|
|
|
CheckasmFuncVersion *next = v->next;
|
|
|
|
free(v);
|
|
|
|
v = next;
|
|
|
|
}
|
|
|
|
|
|
|
|
destroy_func_tree(f->child[0]);
|
|
|
|
destroy_func_tree(f->child[1]);
|
|
|
|
free(f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a zero-initialized block, clean up and exit on failure */
|
|
|
|
static void *checkasm_malloc(size_t size)
|
|
|
|
{
|
|
|
|
void *ptr = calloc(1, size);
|
|
|
|
if (!ptr) {
|
|
|
|
fprintf(stderr, "checkasm: malloc failed\n");
|
|
|
|
destroy_func_tree(state.funcs);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the suffix of the specified cpu flag */
|
|
|
|
static const char *cpu_suffix(int cpu)
|
|
|
|
{
|
|
|
|
int i = FF_ARRAY_ELEMS(cpus);
|
|
|
|
|
|
|
|
while (--i >= 0)
|
|
|
|
if (cpu & cpus[i].flag)
|
|
|
|
return cpus[i].suffix;
|
|
|
|
|
|
|
|
return "c";
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmp_nop(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
return *(const uint16_t*)a - *(const uint16_t*)b;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Measure the overhead of the timing code (in decicycles) */
|
|
|
|
static int measure_nop_time(void)
|
|
|
|
{
|
|
|
|
uint16_t nops[10000];
|
|
|
|
int i, nop_sum = 0;
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
av_unused const int sysfd = state.sysfd;
|
2015-07-11 20:32:11 +02:00
|
|
|
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
uint64_t t = 0;
|
2015-07-11 20:32:11 +02:00
|
|
|
for (i = 0; i < 10000; i++) {
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
PERF_START(t);
|
|
|
|
PERF_STOP(t);
|
|
|
|
nops[i] = t;
|
2015-07-11 20:32:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
qsort(nops, 10000, sizeof(uint16_t), cmp_nop);
|
|
|
|
for (i = 2500; i < 7500; i++)
|
|
|
|
nop_sum += nops[i];
|
|
|
|
|
|
|
|
return nop_sum / 500;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print benchmark results */
|
|
|
|
static void print_benchs(CheckasmFunc *f)
|
|
|
|
{
|
|
|
|
if (f) {
|
|
|
|
print_benchs(f->child[0]);
|
|
|
|
|
|
|
|
/* Only print functions with at least one assembly version */
|
|
|
|
if (f->versions.cpu || f->versions.next) {
|
|
|
|
CheckasmFuncVersion *v = &f->versions;
|
|
|
|
do {
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
CheckasmPerf *p = &v->perf;
|
|
|
|
if (p->iterations) {
|
|
|
|
int decicycles = (10*p->cycles/p->iterations - state.nop_time) / 4;
|
2015-07-11 20:32:11 +02:00
|
|
|
printf("%s_%s: %d.%d\n", f->name, cpu_suffix(v->cpu), decicycles/10, decicycles%10);
|
|
|
|
}
|
|
|
|
} while ((v = v->next));
|
|
|
|
}
|
|
|
|
|
|
|
|
print_benchs(f->child[1]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ASCIIbetical sort except preserving natural order for numbers */
|
|
|
|
static int cmp_func_names(const char *a, const char *b)
|
|
|
|
{
|
2015-09-26 20:15:35 +02:00
|
|
|
const char *start = a;
|
2015-07-11 20:32:11 +02:00
|
|
|
int ascii_diff, digit_diff;
|
|
|
|
|
2015-09-26 20:15:35 +02:00
|
|
|
for (; !(ascii_diff = *(const unsigned char*)a - *(const unsigned char*)b) && *a; a++, b++);
|
2015-07-11 20:32:11 +02:00
|
|
|
for (; av_isdigit(*a) && av_isdigit(*b); a++, b++);
|
|
|
|
|
2015-09-26 20:15:35 +02:00
|
|
|
if (a > start && av_isdigit(a[-1]) && (digit_diff = av_isdigit(*a) - av_isdigit(*b)))
|
|
|
|
return digit_diff;
|
|
|
|
|
|
|
|
return ascii_diff;
|
2015-07-11 20:32:11 +02:00
|
|
|
}
|
|
|
|
|
2015-09-25 18:56:00 +02:00
|
|
|
/* Perform a tree rotation in the specified direction and return the new root */
|
|
|
|
static CheckasmFunc *rotate_tree(CheckasmFunc *f, int dir)
|
|
|
|
{
|
|
|
|
CheckasmFunc *r = f->child[dir^1];
|
|
|
|
f->child[dir^1] = r->child[dir];
|
|
|
|
r->child[dir] = f;
|
|
|
|
r->color = f->color;
|
|
|
|
f->color = 0;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define is_red(f) ((f) && !(f)->color)
|
|
|
|
|
|
|
|
/* Balance a left-leaning red-black tree at the specified node */
|
|
|
|
static void balance_tree(CheckasmFunc **root)
|
|
|
|
{
|
|
|
|
CheckasmFunc *f = *root;
|
|
|
|
|
|
|
|
if (is_red(f->child[0]) && is_red(f->child[1])) {
|
|
|
|
f->color ^= 1;
|
|
|
|
f->child[0]->color = f->child[1]->color = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_red(f->child[0]) && is_red(f->child[1]))
|
|
|
|
*root = rotate_tree(f, 0); /* Rotate left */
|
|
|
|
else if (is_red(f->child[0]) && is_red(f->child[0]->child[0]))
|
|
|
|
*root = rotate_tree(f, 1); /* Rotate right */
|
|
|
|
}
|
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
/* Get a node with the specified name, creating it if it doesn't exist */
|
2015-09-25 18:56:00 +02:00
|
|
|
static CheckasmFunc *get_func(CheckasmFunc **root, const char *name)
|
2015-07-11 20:32:11 +02:00
|
|
|
{
|
2015-09-25 18:56:00 +02:00
|
|
|
CheckasmFunc *f = *root;
|
2015-07-11 20:32:11 +02:00
|
|
|
|
2015-09-25 18:56:00 +02:00
|
|
|
if (f) {
|
|
|
|
/* Search the tree for a matching node */
|
2015-07-11 20:32:11 +02:00
|
|
|
int cmp = cmp_func_names(name, f->name);
|
2015-09-25 18:56:00 +02:00
|
|
|
if (cmp) {
|
|
|
|
f = get_func(&f->child[cmp > 0], name);
|
2015-07-11 20:32:11 +02:00
|
|
|
|
2015-09-25 18:56:00 +02:00
|
|
|
/* Rebalance the tree on the way up if a new node was inserted */
|
|
|
|
if (!f->versions.func)
|
|
|
|
balance_tree(root);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Allocate and insert a new node into the tree */
|
|
|
|
int name_length = strlen(name);
|
|
|
|
f = *root = checkasm_malloc(sizeof(CheckasmFunc) + name_length);
|
|
|
|
memcpy(f->name, name, name_length + 1);
|
2015-07-11 20:32:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Perform tests and benchmarks for the specified cpu flag if supported by the host */
|
|
|
|
static void check_cpu_flag(const char *name, int flag)
|
|
|
|
{
|
|
|
|
int old_cpu_flag = state.cpu_flag;
|
|
|
|
|
|
|
|
flag |= old_cpu_flag;
|
2015-09-26 15:43:49 +02:00
|
|
|
av_force_cpu_flags(-1);
|
|
|
|
state.cpu_flag = flag & av_get_cpu_flags();
|
|
|
|
av_force_cpu_flags(state.cpu_flag);
|
2015-07-11 20:32:11 +02:00
|
|
|
|
|
|
|
if (!flag || state.cpu_flag != old_cpu_flag) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
state.cpu_flag_name = name;
|
2015-07-24 23:46:20 +02:00
|
|
|
for (i = 0; tests[i].func; i++) {
|
2016-11-04 00:40:26 +02:00
|
|
|
if (state.test_name && strcmp(tests[i].name, state.test_name))
|
|
|
|
continue;
|
2015-07-24 23:46:20 +02:00
|
|
|
state.current_test_name = tests[i].name;
|
|
|
|
tests[i].func();
|
|
|
|
}
|
2015-07-11 20:32:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print the name of the current CPU flag, but only do it once */
|
|
|
|
static void print_cpu_name(void)
|
|
|
|
{
|
|
|
|
if (state.cpu_flag_name) {
|
|
|
|
color_printf(COLOR_YELLOW, "%s:\n", state.cpu_flag_name);
|
|
|
|
state.cpu_flag_name = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
#if CONFIG_LINUX_PERF
|
|
|
|
static int bench_init_linux(void)
|
|
|
|
{
|
|
|
|
struct perf_event_attr attr = {
|
|
|
|
.type = PERF_TYPE_HARDWARE,
|
|
|
|
.size = sizeof(struct perf_event_attr),
|
|
|
|
.config = PERF_COUNT_HW_CPU_CYCLES,
|
|
|
|
.disabled = 1, // start counting only on demand
|
|
|
|
.exclude_kernel = 1,
|
|
|
|
.exclude_hv = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
printf("benchmarking with Linux Perf Monitoring API\n");
|
|
|
|
|
|
|
|
state.sysfd = syscall(__NR_perf_event_open, &attr, 0, -1, -1, 0);
|
|
|
|
if (state.sysfd == -1) {
|
|
|
|
perror("syscall");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int bench_init_ffmpeg(void)
|
|
|
|
{
|
|
|
|
#ifdef AV_READ_TIME
|
|
|
|
printf("benchmarking with native FFmpeg timers\n");
|
|
|
|
return 0;
|
|
|
|
#else
|
|
|
|
fprintf(stderr, "checkasm: --bench is not supported on your system\n");
|
|
|
|
return -1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static int bench_init(void)
|
|
|
|
{
|
|
|
|
#if CONFIG_LINUX_PERF
|
|
|
|
int ret = bench_init_linux();
|
|
|
|
#else
|
|
|
|
int ret = bench_init_ffmpeg();
|
|
|
|
#endif
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
state.nop_time = measure_nop_time();
|
|
|
|
printf("nop: %d.%d\n", state.nop_time/10, state.nop_time%10);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bench_uninit(void)
|
|
|
|
{
|
|
|
|
#if CONFIG_LINUX_PERF
|
|
|
|
if (state.sysfd > 0)
|
|
|
|
close(state.sysfd);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
int main(int argc, char *argv[])
|
|
|
|
{
|
2016-11-04 00:40:26 +02:00
|
|
|
unsigned int seed = av_get_random_seed();
|
2016-09-11 01:14:37 +02:00
|
|
|
int i, ret = 0;
|
2015-07-11 20:32:11 +02:00
|
|
|
|
2015-12-30 23:46:06 +02:00
|
|
|
#if ARCH_ARM && HAVE_ARMV5TE_EXTERNAL
|
|
|
|
if (have_vfp(av_get_cpu_flags()) || have_neon(av_get_cpu_flags()))
|
|
|
|
checkasm_checked_call = checkasm_checked_call_vfp;
|
|
|
|
#endif
|
|
|
|
|
2015-07-24 23:46:20 +02:00
|
|
|
if (!tests[0].func || !cpus[0].flag) {
|
2015-07-11 20:32:11 +02:00
|
|
|
fprintf(stderr, "checkasm: no tests to perform\n");
|
2015-07-17 18:07:57 +02:00
|
|
|
return 0;
|
2015-07-11 20:32:11 +02:00
|
|
|
}
|
|
|
|
|
2016-11-04 00:40:26 +02:00
|
|
|
while (argc > 1) {
|
|
|
|
if (!strncmp(argv[1], "--bench", 7)) {
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
if (bench_init() < 0)
|
|
|
|
return 1;
|
2016-11-04 00:40:26 +02:00
|
|
|
if (argv[1][7] == '=') {
|
|
|
|
state.bench_pattern = argv[1] + 8;
|
|
|
|
state.bench_pattern_len = strlen(state.bench_pattern);
|
|
|
|
} else
|
|
|
|
state.bench_pattern = "";
|
|
|
|
} else if (!strncmp(argv[1], "--test=", 7)) {
|
|
|
|
state.test_name = argv[1] + 7;
|
|
|
|
} else {
|
|
|
|
seed = strtoul(argv[1], NULL, 10);
|
|
|
|
}
|
2015-07-11 20:32:11 +02:00
|
|
|
|
|
|
|
argc--;
|
|
|
|
argv++;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(stderr, "checkasm: using random seed %u\n", seed);
|
|
|
|
av_lfg_init(&checkasm_lfg, seed);
|
|
|
|
|
|
|
|
check_cpu_flag(NULL, 0);
|
|
|
|
for (i = 0; cpus[i].flag; i++)
|
|
|
|
check_cpu_flag(cpus[i].name, cpus[i].flag);
|
|
|
|
|
|
|
|
if (state.num_failed) {
|
|
|
|
fprintf(stderr, "checkasm: %d of %d tests have failed\n", state.num_failed, state.num_checked);
|
|
|
|
ret = 1;
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "checkasm: all %d tests passed\n", state.num_checked);
|
|
|
|
if (state.bench_pattern) {
|
|
|
|
print_benchs(state.funcs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
destroy_func_tree(state.funcs);
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
bench_uninit();
|
2015-07-11 20:32:11 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Decide whether or not the specified function needs to be tested and
|
|
|
|
* allocate/initialize data structures if needed. Returns a pointer to a
|
|
|
|
* reference function if the function should be tested, otherwise NULL */
|
2015-08-16 13:00:21 +02:00
|
|
|
void *checkasm_check_func(void *func, const char *name, ...)
|
2015-07-11 20:32:11 +02:00
|
|
|
{
|
|
|
|
char name_buf[256];
|
2015-08-16 13:00:21 +02:00
|
|
|
void *ref = func;
|
2015-07-11 20:32:11 +02:00
|
|
|
CheckasmFuncVersion *v;
|
|
|
|
int name_length;
|
|
|
|
va_list arg;
|
|
|
|
|
|
|
|
va_start(arg, name);
|
|
|
|
name_length = vsnprintf(name_buf, sizeof(name_buf), name, arg);
|
|
|
|
va_end(arg);
|
|
|
|
|
|
|
|
if (!func || name_length <= 0 || name_length >= sizeof(name_buf))
|
|
|
|
return NULL;
|
|
|
|
|
2015-09-25 18:56:00 +02:00
|
|
|
state.current_func = get_func(&state.funcs, name_buf);
|
|
|
|
state.funcs->color = 1;
|
2015-07-11 20:32:11 +02:00
|
|
|
v = &state.current_func->versions;
|
|
|
|
|
|
|
|
if (v->func) {
|
|
|
|
CheckasmFuncVersion *prev;
|
|
|
|
do {
|
|
|
|
/* Only test functions that haven't already been tested */
|
|
|
|
if (v->func == func)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (v->ok)
|
|
|
|
ref = v->func;
|
|
|
|
|
|
|
|
prev = v;
|
|
|
|
} while ((v = v->next));
|
|
|
|
|
|
|
|
v = prev->next = checkasm_malloc(sizeof(CheckasmFuncVersion));
|
|
|
|
}
|
|
|
|
|
|
|
|
v->func = func;
|
|
|
|
v->ok = 1;
|
|
|
|
v->cpu = state.cpu_flag;
|
|
|
|
state.current_func_ver = v;
|
|
|
|
|
|
|
|
if (state.cpu_flag)
|
|
|
|
state.num_checked++;
|
|
|
|
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Decide whether or not the current function needs to be benchmarked */
|
|
|
|
int checkasm_bench_func(void)
|
|
|
|
{
|
|
|
|
return !state.num_failed && state.bench_pattern &&
|
|
|
|
!strncmp(state.current_func->name, state.bench_pattern, state.bench_pattern_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Indicate that the current test has failed */
|
|
|
|
void checkasm_fail_func(const char *msg, ...)
|
|
|
|
{
|
|
|
|
if (state.current_func_ver->cpu && state.current_func_ver->ok) {
|
|
|
|
va_list arg;
|
|
|
|
|
|
|
|
print_cpu_name();
|
|
|
|
fprintf(stderr, " %s_%s (", state.current_func->name, cpu_suffix(state.current_func_ver->cpu));
|
|
|
|
va_start(arg, msg);
|
|
|
|
vfprintf(stderr, msg, arg);
|
|
|
|
va_end(arg);
|
|
|
|
fprintf(stderr, ")\n");
|
|
|
|
|
|
|
|
state.current_func_ver->ok = 0;
|
|
|
|
state.num_failed++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
/* Get the benchmark context of the current function */
|
|
|
|
CheckasmPerf *checkasm_get_perf_context(void)
|
2015-07-11 20:32:11 +02:00
|
|
|
{
|
checkasm: use perf API on Linux ARM*
On ARM platforms, accessing the PMU registers requires special user
access permissions. Since there is no other way to get accurate timers,
the current implementation of timers in FFmpeg rely on these registers.
Unfortunately, enabling user access to these registers on Linux is not
trivial, and generally involve compiling a random and unreliable github
kernel module, or patching somehow your kernel.
Such module is very unlikely to reach the upstream anytime soon. Quoting
Robin Murphin from ARM:
> Say you do give userspace direct access to the PMU; now run two or more
> programs at once that believe they can use the counters for their own
> "minimal-overhead" profiling. Have fun interpreting those results...
>
> And that's not even getting into the implications of scheduling across
> different CPUs, CPUidle, etc. where the PMU state is completely beyond
> userspace's control. In general, the plan to provide userspace with
> something which might happen to just about work in a few corner cases,
> but is meaningless, misleading or downright broken in all others, is to
> never do so.
As a result, the alternative is to use the Performance Monitoring Linux
API which makes use of these registers internally (assuming the PMU of
your ARM board is supported in the kernel, which is definitely not a
given...).
While the Linux API is obviously cross platform, it does have a
significant overhead which needs to be taken into account. As a result,
that mode is only weakly enabled on ARM platforms exclusively.
Note on the non flexibility of the implementation: the timers (native
FFmpeg vs Linux API) are selected at compilation time to prevent the
need of function calls, which would result in a negative impact on the
cycle counters.
2017-09-01 15:11:18 +02:00
|
|
|
CheckasmPerf *perf = &state.current_func_ver->perf;
|
|
|
|
memset(perf, 0, sizeof(*perf));
|
|
|
|
perf->sysfd = state.sysfd;
|
|
|
|
return perf;
|
2015-07-11 20:32:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Print the outcome of all tests performed since the last time this function was called */
|
|
|
|
void checkasm_report(const char *name, ...)
|
|
|
|
{
|
|
|
|
static int prev_checked, prev_failed, max_length;
|
|
|
|
|
|
|
|
if (state.num_checked > prev_checked) {
|
2015-07-24 23:46:20 +02:00
|
|
|
int pad_length = max_length + 4;
|
|
|
|
va_list arg;
|
2015-07-11 20:32:11 +02:00
|
|
|
|
2015-07-24 23:46:20 +02:00
|
|
|
print_cpu_name();
|
|
|
|
pad_length -= fprintf(stderr, " - %s.", state.current_test_name);
|
|
|
|
va_start(arg, name);
|
|
|
|
pad_length -= vfprintf(stderr, name, arg);
|
|
|
|
va_end(arg);
|
|
|
|
fprintf(stderr, "%*c", FFMAX(pad_length, 0) + 2, '[');
|
2015-07-11 20:32:11 +02:00
|
|
|
|
|
|
|
if (state.num_failed == prev_failed)
|
|
|
|
color_printf(COLOR_GREEN, "OK");
|
|
|
|
else
|
|
|
|
color_printf(COLOR_RED, "FAILED");
|
|
|
|
fprintf(stderr, "]\n");
|
|
|
|
|
|
|
|
prev_checked = state.num_checked;
|
|
|
|
prev_failed = state.num_failed;
|
|
|
|
} else if (!state.cpu_flag) {
|
|
|
|
/* Calculate the amount of padding required to make the output vertically aligned */
|
2015-07-24 23:46:20 +02:00
|
|
|
int length = strlen(state.current_test_name);
|
|
|
|
va_list arg;
|
|
|
|
|
|
|
|
va_start(arg, name);
|
|
|
|
length += vsnprintf(NULL, 0, name, arg);
|
|
|
|
va_end(arg);
|
2015-07-11 20:32:11 +02:00
|
|
|
|
|
|
|
if (length > max_length)
|
|
|
|
max_length = length;
|
|
|
|
}
|
|
|
|
}
|