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.
|
|
|
|
*/
|
|
|
|
|
2016-01-29 04:25:13 +02:00
|
|
|
#ifndef TESTS_CHECKASM_CHECKASM_H
|
|
|
|
#define TESTS_CHECKASM_CHECKASM_H
|
2015-07-11 20:32:11 +02:00
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include "config.h"
|
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
|
|
|
|
#include <unistd.h> // read(3)
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <asm/unistd.h>
|
|
|
|
#include <linux/perf_event.h>
|
2021-07-20 19:09:22 +02:00
|
|
|
#elif CONFIG_MACOS_KPERF
|
|
|
|
#include "libavutil/macos_kperf.h"
|
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
|
|
|
#endif
|
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
#include "libavutil/avstring.h"
|
2015-12-11 15:06:38 +02:00
|
|
|
#include "libavutil/cpu.h"
|
2023-09-01 00:23:35 +02:00
|
|
|
#include "libavutil/emms.h"
|
2016-06-21 13:00:01 +02:00
|
|
|
#include "libavutil/internal.h"
|
2015-07-11 20:32:11 +02:00
|
|
|
#include "libavutil/lfg.h"
|
|
|
|
#include "libavutil/timer.h"
|
|
|
|
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
#ifdef _WIN32
|
|
|
|
#include <windows.h>
|
|
|
|
#if ARCH_X86_32
|
|
|
|
#include <setjmp.h>
|
|
|
|
typedef jmp_buf checkasm_context;
|
|
|
|
#define checkasm_save_context() checkasm_handle_signal(setjmp(checkasm_context_buf))
|
|
|
|
#define checkasm_load_context(s) longjmp(checkasm_context_buf, s)
|
|
|
|
#elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
|
|
|
|
/* setjmp/longjmp on Windows on architectures using SEH (all except x86_32)
|
|
|
|
* will try to use SEH to unwind the stack, which doesn't work for assembly
|
|
|
|
* functions without unwind information. */
|
|
|
|
typedef struct { CONTEXT c; int status; } checkasm_context;
|
|
|
|
#define checkasm_save_context() \
|
|
|
|
(checkasm_context_buf.status = 0, \
|
|
|
|
RtlCaptureContext(&checkasm_context_buf.c), \
|
|
|
|
checkasm_handle_signal(checkasm_context_buf.status))
|
|
|
|
#define checkasm_load_context(s) \
|
|
|
|
(checkasm_context_buf.status = s, \
|
|
|
|
RtlRestoreContext(&checkasm_context_buf.c, NULL))
|
|
|
|
#else
|
|
|
|
#define checkasm_context void*
|
|
|
|
#define checkasm_save_context() 0
|
|
|
|
#define checkasm_load_context() do {} while (0)
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
#include <setjmp.h>
|
|
|
|
typedef sigjmp_buf checkasm_context;
|
|
|
|
#define checkasm_save_context() checkasm_handle_signal(sigsetjmp(checkasm_context_buf, 1))
|
|
|
|
#define checkasm_load_context(s) siglongjmp(checkasm_context_buf, s)
|
|
|
|
#endif
|
|
|
|
|
2023-11-28 08:08:12 +02:00
|
|
|
void checkasm_check_aacencdsp(void);
|
2017-06-02 10:06:08 +02:00
|
|
|
void checkasm_check_aacpsdsp(void);
|
2023-11-22 08:57:29 +02:00
|
|
|
void checkasm_check_ac3dsp(void);
|
2019-01-03 01:54:34 +02:00
|
|
|
void checkasm_check_afir(void);
|
2015-10-07 01:25:49 +02:00
|
|
|
void checkasm_check_alacdsp(void);
|
2016-08-09 18:10:26 +02:00
|
|
|
void checkasm_check_audiodsp(void);
|
2021-04-10 03:53:38 +02:00
|
|
|
void checkasm_check_av_tx(void);
|
2016-02-10 11:07:40 +02:00
|
|
|
void checkasm_check_blend(void);
|
2016-08-08 21:58:17 +02:00
|
|
|
void checkasm_check_blockdsp(void);
|
2015-07-16 00:10:28 +02:00
|
|
|
void checkasm_check_bswapdsp(void);
|
2016-04-06 20:09:08 +02:00
|
|
|
void checkasm_check_colorspace(void);
|
2017-09-17 23:48:02 +02:00
|
|
|
void checkasm_check_exrdsp(void);
|
2024-05-06 19:18:39 +02:00
|
|
|
void checkasm_check_fdctdsp(void);
|
2017-04-11 22:12:21 +02:00
|
|
|
void checkasm_check_fixed_dsp(void);
|
2015-09-17 20:22:25 +02:00
|
|
|
void checkasm_check_flacdsp(void);
|
2017-04-11 22:16:56 +02:00
|
|
|
void checkasm_check_float_dsp(void);
|
2015-12-08 17:24:57 +02:00
|
|
|
void checkasm_check_fmtconvert(void);
|
2017-07-05 21:34:00 +02:00
|
|
|
void checkasm_check_g722dsp(void);
|
2024-05-18 20:43:37 +02:00
|
|
|
void checkasm_check_h263dsp(void);
|
2023-05-18 16:18:16 +02:00
|
|
|
void checkasm_check_h264chroma(void);
|
2016-06-11 13:17:37 +02:00
|
|
|
void checkasm_check_h264dsp(void);
|
2015-07-11 20:32:11 +02:00
|
|
|
void checkasm_check_h264pred(void);
|
2015-07-13 23:11:25 +02:00
|
|
|
void checkasm_check_h264qpel(void);
|
2016-10-11 10:44:19 +02:00
|
|
|
void checkasm_check_hevc_add_res(void);
|
2023-03-21 19:44:03 +02:00
|
|
|
void checkasm_check_hevc_deblock(void);
|
2016-07-21 16:32:50 +02:00
|
|
|
void checkasm_check_hevc_idct(void);
|
2021-08-05 10:26:48 +02:00
|
|
|
void checkasm_check_hevc_pel(void);
|
2018-03-07 06:42:30 +02:00
|
|
|
void checkasm_check_hevc_sao(void);
|
2017-11-21 10:09:42 +02:00
|
|
|
void checkasm_check_huffyuvdsp(void);
|
2022-03-31 19:23:44 +02:00
|
|
|
void checkasm_check_idctdsp(void);
|
2015-09-18 04:53:37 +02:00
|
|
|
void checkasm_check_jpeg2000dsp(void);
|
2023-11-12 21:45:24 +02:00
|
|
|
void checkasm_check_llauddsp(void);
|
2024-05-28 21:56:34 +02:00
|
|
|
void checkasm_check_lls(void);
|
2017-03-22 17:29:44 +02:00
|
|
|
void checkasm_check_llviddsp(void);
|
2018-01-14 15:23:42 +02:00
|
|
|
void checkasm_check_llviddspenc(void);
|
2022-09-19 23:48:53 +02:00
|
|
|
void checkasm_check_lpc(void);
|
2022-06-26 22:58:09 +02:00
|
|
|
void checkasm_check_motion(void);
|
2018-05-06 10:57:23 +02:00
|
|
|
void checkasm_check_nlmeans(void);
|
2019-08-15 12:42:19 +02:00
|
|
|
void checkasm_check_opusdsp(void);
|
2015-11-01 13:31:22 +02:00
|
|
|
void checkasm_check_pixblockdsp(void);
|
2017-06-09 11:34:12 +02:00
|
|
|
void checkasm_check_sbrdsp(void);
|
2024-01-31 13:00:23 +02:00
|
|
|
void checkasm_check_rv34dsp(void);
|
2024-04-30 06:43:57 +02:00
|
|
|
void checkasm_check_rv40dsp(void);
|
2023-12-29 07:09:21 +02:00
|
|
|
void checkasm_check_svq1enc(void);
|
2015-12-08 00:38:46 +02:00
|
|
|
void checkasm_check_synth_filter(void);
|
2021-11-24 23:15:20 +02:00
|
|
|
void checkasm_check_sw_gbrp(void);
|
2024-06-11 14:28:55 +02:00
|
|
|
void checkasm_check_sw_range_convert(void);
|
2018-03-24 21:19:00 +02:00
|
|
|
void checkasm_check_sw_rgb(void);
|
2020-05-13 17:02:53 +02:00
|
|
|
void checkasm_check_sw_scale(void);
|
2023-12-18 16:39:13 +02:00
|
|
|
void checkasm_check_takdsp(void);
|
2017-11-21 09:31:12 +02:00
|
|
|
void checkasm_check_utvideodsp(void);
|
2019-03-04 20:50:35 +02:00
|
|
|
void checkasm_check_v210dec(void);
|
2015-09-06 01:06:12 +02:00
|
|
|
void checkasm_check_v210enc(void);
|
2022-03-31 19:23:42 +02:00
|
|
|
void checkasm_check_vc1dsp(void);
|
2023-02-20 21:55:08 +02:00
|
|
|
void checkasm_check_vf_bwdif(void);
|
2019-09-18 09:05:33 +02:00
|
|
|
void checkasm_check_vf_eq(void);
|
2019-06-04 10:34:08 +02:00
|
|
|
void checkasm_check_vf_gblur(void);
|
2017-12-11 12:26:44 +02:00
|
|
|
void checkasm_check_vf_hflip(void);
|
2017-12-03 17:56:25 +02:00
|
|
|
void checkasm_check_vf_threshold(void);
|
2022-11-04 10:29:25 +02:00
|
|
|
void checkasm_check_vf_sobel(void);
|
2016-06-13 22:00:51 +02:00
|
|
|
void checkasm_check_vp8dsp(void);
|
2015-09-15 22:41:29 +02:00
|
|
|
void checkasm_check_vp9dsp(void);
|
2016-01-17 23:22:26 +02:00
|
|
|
void checkasm_check_videodsp(void);
|
2022-09-19 18:56:34 +02:00
|
|
|
void checkasm_check_vorbisdsp(void);
|
2024-05-13 14:31:04 +02:00
|
|
|
void checkasm_check_vvc_alf(void);
|
2024-01-23 20:17:09 +02:00
|
|
|
void checkasm_check_vvc_mc(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
|
|
|
struct CheckasmPerf;
|
|
|
|
|
2015-08-16 13:00:21 +02:00
|
|
|
void *checkasm_check_func(void *func, const char *name, ...) av_printf_format(2, 3);
|
2015-07-11 20:32:11 +02:00
|
|
|
int checkasm_bench_func(void);
|
|
|
|
void checkasm_fail_func(const char *msg, ...) av_printf_format(1, 2);
|
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
|
|
|
struct CheckasmPerf *checkasm_get_perf_context(void);
|
2015-07-11 20:32:11 +02:00
|
|
|
void checkasm_report(const char *name, ...) av_printf_format(1, 2);
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
void checkasm_set_signal_handler_state(int enabled);
|
|
|
|
int checkasm_handle_signal(int s);
|
|
|
|
extern checkasm_context checkasm_context_buf;
|
2015-07-11 20:32:11 +02:00
|
|
|
|
2015-12-07 17:14:46 +02:00
|
|
|
/* float compare utilities */
|
|
|
|
int float_near_ulp(float a, float b, unsigned max_ulp);
|
|
|
|
int float_near_abs_eps(float a, float b, float eps);
|
|
|
|
int float_near_abs_eps_ulp(float a, float b, float eps, unsigned max_ulp);
|
|
|
|
int float_near_ulp_array(const float *a, const float *b, unsigned max_ulp,
|
|
|
|
unsigned len);
|
|
|
|
int float_near_abs_eps_array(const float *a, const float *b, float eps,
|
|
|
|
unsigned len);
|
|
|
|
int float_near_abs_eps_array_ulp(const float *a, const float *b, float eps,
|
|
|
|
unsigned max_ulp, unsigned len);
|
2017-04-11 22:16:56 +02:00
|
|
|
int double_near_abs_eps(double a, double b, double eps);
|
|
|
|
int double_near_abs_eps_array(const double *a, const double *b, double eps,
|
|
|
|
unsigned len);
|
2015-12-07 17:14:46 +02:00
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
extern AVLFG checkasm_lfg;
|
|
|
|
#define rnd() av_lfg_get(&checkasm_lfg)
|
|
|
|
|
2015-08-16 13:00:21 +02:00
|
|
|
static av_unused void *func_ref, *func_new;
|
2015-07-11 20:32:11 +02:00
|
|
|
|
2024-05-13 15:04:31 +02:00
|
|
|
extern uint64_t bench_runs;
|
2015-07-11 20:32:11 +02:00
|
|
|
|
|
|
|
/* Decide whether or not the specified function needs to be tested */
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
#define check_func(func, ...) (checkasm_save_context(), func_ref = checkasm_check_func((func_new = func), __VA_ARGS__))
|
2015-08-16 13:00:21 +02:00
|
|
|
|
|
|
|
/* Declare the function prototype. The first argument is the return value, the remaining
|
|
|
|
* arguments are the function parameters. Naming parameters is optional. */
|
|
|
|
#define declare_func(ret, ...) declare_new(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
|
2017-06-01 23:50:49 +02:00
|
|
|
#define declare_func_float(ret, ...) declare_new_float(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
|
2015-12-11 15:06:38 +02:00
|
|
|
#define declare_func_emms(cpu_flags, ret, ...) declare_new_emms(cpu_flags, ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
|
2015-07-11 20:32:11 +02:00
|
|
|
|
|
|
|
/* Indicate that the current test has failed */
|
|
|
|
#define fail() checkasm_fail_func("%s:%d", av_basename(__FILE__), __LINE__)
|
|
|
|
|
|
|
|
/* Print the test outcome */
|
2015-07-24 23:46:20 +02:00
|
|
|
#define report checkasm_report
|
2015-07-11 20:32:11 +02:00
|
|
|
|
|
|
|
/* Call the reference function */
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
#define call_ref(...)\
|
|
|
|
(checkasm_set_signal_handler_state(1),\
|
|
|
|
((func_type *)func_ref)(__VA_ARGS__));\
|
|
|
|
checkasm_set_signal_handler_state(0)
|
2015-07-11 20:32:11 +02:00
|
|
|
|
2016-10-08 16:18:33 +02:00
|
|
|
#if ARCH_X86 && HAVE_X86ASM
|
2015-12-11 15:06:38 +02:00
|
|
|
/* Verifies that clobbered callee-saved registers are properly saved and restored
|
|
|
|
* and that either no MMX registers are touched or emms is issued */
|
2015-08-16 13:00:21 +02:00
|
|
|
void checkasm_checked_call(void *func, ...);
|
2015-12-11 15:06:38 +02:00
|
|
|
/* Verifies that clobbered callee-saved registers are properly saved and restored
|
|
|
|
* and issues emms for asm functions which are not required to do so */
|
|
|
|
void checkasm_checked_call_emms(void *func, ...);
|
2017-06-01 23:50:49 +02:00
|
|
|
/* Verifies that clobbered callee-saved registers are properly saved and restored
|
|
|
|
* but doesn't issue emms. Meant for dsp functions returning float or double */
|
|
|
|
void checkasm_checked_call_float(void *func, ...);
|
2015-07-11 20:32:11 +02:00
|
|
|
|
2015-08-16 13:00:21 +02:00
|
|
|
#if ARCH_X86_64
|
2015-07-11 20:32:11 +02:00
|
|
|
/* Evil hack: detect incorrect assumptions that 32-bit ints are zero-extended to 64-bit.
|
|
|
|
* This is done by clobbering the stack with junk around the stack pointer and calling the
|
2015-08-16 13:00:21 +02:00
|
|
|
* assembly function through checked_call() with added dummy arguments which forces all
|
2015-07-11 20:32:11 +02:00
|
|
|
* real arguments to be passed on the stack and not in registers. For 32-bit arguments the
|
|
|
|
* upper half of the 64-bit register locations on the stack will now contain junk which will
|
|
|
|
* cause misbehaving functions to either produce incorrect output or segfault. Note that
|
|
|
|
* even though this works extremely well in practice, it's technically not guaranteed
|
|
|
|
* and false negatives is theoretically possible, but there can never be any false positives.
|
|
|
|
*/
|
|
|
|
void checkasm_stack_clobber(uint64_t clobber, ...);
|
2015-08-16 13:00:21 +02:00
|
|
|
#define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\
|
|
|
|
= (void *)checkasm_checked_call;
|
2017-06-01 23:50:49 +02:00
|
|
|
#define declare_new_float(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\
|
|
|
|
= (void *)checkasm_checked_call_float;
|
2015-12-11 15:06:38 +02:00
|
|
|
#define declare_new_emms(cpu_flags, ret, ...) \
|
|
|
|
ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__) = \
|
|
|
|
((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms : \
|
|
|
|
(void *)checkasm_checked_call;
|
2015-07-11 20:32:11 +02:00
|
|
|
#define CLOB (UINT64_C(0xdeadbeefdeadbeef))
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
#define call_new(...) (checkasm_set_signal_handler_state(1),\
|
|
|
|
checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
|
2015-07-11 20:32:11 +02:00
|
|
|
CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
checked_call(func_new, 0, 0, 0, 0, 0, __VA_ARGS__));\
|
|
|
|
checkasm_set_signal_handler_state(0)
|
2015-08-16 13:00:21 +02:00
|
|
|
#elif ARCH_X86_32
|
|
|
|
#define declare_new(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call;
|
2017-06-01 23:50:49 +02:00
|
|
|
#define declare_new_float(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call_float;
|
2015-12-11 15:06:38 +02:00
|
|
|
#define declare_new_emms(cpu_flags, ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = \
|
|
|
|
((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms : \
|
|
|
|
(void *)checkasm_checked_call;
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
#define call_new(...)\
|
|
|
|
(checkasm_set_signal_handler_state(1),\
|
|
|
|
checked_call(func_new, __VA_ARGS__));\
|
|
|
|
checkasm_set_signal_handler_state(0)
|
2015-08-16 13:00:21 +02:00
|
|
|
#endif
|
2015-12-30 23:46:06 +02:00
|
|
|
#elif ARCH_ARM && HAVE_ARMV5TE_EXTERNAL
|
|
|
|
/* Use a dummy argument, to offset the real parameters by 2, not only 1.
|
|
|
|
* This makes sure that potential 8-byte-alignment of parameters is kept the same
|
|
|
|
* even when the extra parameters have been removed. */
|
|
|
|
void checkasm_checked_call_vfp(void *func, int dummy, ...);
|
|
|
|
void checkasm_checked_call_novfp(void *func, int dummy, ...);
|
|
|
|
extern void (*checkasm_checked_call)(void *func, int dummy, ...);
|
2020-05-13 20:09:08 +02:00
|
|
|
#define declare_new(ret, ...) ret (*checked_call)(void *, int dummy, __VA_ARGS__, \
|
|
|
|
int, int, int, int, int, int, int, int, \
|
|
|
|
int, int, int, int, int, int, int) = (void *)checkasm_checked_call;
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
#define call_new(...) \
|
|
|
|
(checkasm_set_signal_handler_state(1),\
|
|
|
|
checked_call(func_new, 0, __VA_ARGS__, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0));\
|
|
|
|
checkasm_set_signal_handler_state(0)
|
2015-12-31 12:20:37 +02:00
|
|
|
#elif ARCH_AARCH64 && !defined(__APPLE__)
|
2016-09-30 10:39:22 +02:00
|
|
|
void checkasm_stack_clobber(uint64_t clobber, ...);
|
2015-12-31 12:20:37 +02:00
|
|
|
void checkasm_checked_call(void *func, ...);
|
2020-05-13 13:11:39 +02:00
|
|
|
#define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, int, int, __VA_ARGS__,\
|
|
|
|
int, int, int, int, int, int, int, int,\
|
|
|
|
int, int, int, int, int, int, int)\
|
2016-09-30 11:06:49 +02:00
|
|
|
= (void *)checkasm_checked_call;
|
2016-09-30 10:39:22 +02:00
|
|
|
#define CLOB (UINT64_C(0xdeadbeefdeadbeef))
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
#define call_new(...) (checkasm_set_signal_handler_state(1),\
|
|
|
|
checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
|
2016-09-30 10:39:22 +02:00
|
|
|
CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
|
2020-05-13 13:11:39 +02:00
|
|
|
checked_call(func_new, 0, 0, 0, 0, 0, 0, 0, __VA_ARGS__,\
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0));\
|
|
|
|
checkasm_set_signal_handler_state(0)
|
2022-10-06 21:15:41 +02:00
|
|
|
#elif ARCH_RISCV
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
void checkasm_set_function(void *);
|
2022-10-06 21:15:41 +02:00
|
|
|
void *checkasm_get_wrapper(void);
|
|
|
|
|
2023-12-05 17:54:26 +02:00
|
|
|
#if HAVE_RV && (__riscv_xlen == 64) && defined (__riscv_d)
|
2022-10-06 21:15:41 +02:00
|
|
|
#define declare_new(ret, ...) \
|
|
|
|
ret (*checked_call)(__VA_ARGS__) = checkasm_get_wrapper();
|
|
|
|
#define call_new(...) \
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
(checkasm_set_signal_handler_state(1),\
|
|
|
|
checkasm_set_function(func_new), checked_call(__VA_ARGS__));\
|
|
|
|
checkasm_set_signal_handler_state(0)
|
2023-12-05 17:54:26 +02:00
|
|
|
#else
|
|
|
|
#define declare_new(ret, ...)
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
#define call_new(...)\
|
|
|
|
(checkasm_set_signal_handler_state(1),\
|
|
|
|
((func_type *)func_new)(__VA_ARGS__));\
|
|
|
|
checkasm_set_signal_handler_state(0)
|
2022-10-06 21:15:41 +02:00
|
|
|
#endif
|
2015-07-11 20:32:11 +02:00
|
|
|
#else
|
2015-08-16 13:00:21 +02:00
|
|
|
#define declare_new(ret, ...)
|
2017-06-01 23:50:49 +02:00
|
|
|
#define declare_new_float(ret, ...)
|
2015-12-11 15:06:38 +02:00
|
|
|
#define declare_new_emms(cpu_flags, ret, ...)
|
2015-08-16 13:00:21 +02:00
|
|
|
/* Call the function */
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
#define call_new(...)\
|
|
|
|
(checkasm_set_signal_handler_state(1),\
|
|
|
|
((func_type *)func_new)(__VA_ARGS__));\
|
|
|
|
checkasm_set_signal_handler_state(0)
|
2015-07-11 20:32:11 +02:00
|
|
|
#endif
|
|
|
|
|
2015-12-30 23:46:06 +02:00
|
|
|
#ifndef declare_new_emms
|
|
|
|
#define declare_new_emms(cpu_flags, ret, ...) declare_new(ret, __VA_ARGS__)
|
|
|
|
#endif
|
2017-06-01 23:50:49 +02:00
|
|
|
#ifndef declare_new_float
|
|
|
|
#define declare_new_float(ret, ...) declare_new(ret, __VA_ARGS__)
|
|
|
|
#endif
|
2015-12-30 23:46:06 +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
|
|
|
typedef struct CheckasmPerf {
|
|
|
|
int sysfd;
|
|
|
|
uint64_t cycles;
|
|
|
|
int iterations;
|
|
|
|
} CheckasmPerf;
|
|
|
|
|
2021-07-20 19:09:22 +02:00
|
|
|
#if defined(AV_READ_TIME) || CONFIG_LINUX_PERF || CONFIG_MACOS_KPERF
|
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
|
|
|
|
#define PERF_START(t) do { \
|
|
|
|
ioctl(sysfd, PERF_EVENT_IOC_RESET, 0); \
|
|
|
|
ioctl(sysfd, PERF_EVENT_IOC_ENABLE, 0); \
|
|
|
|
} while (0)
|
|
|
|
#define PERF_STOP(t) do { \
|
2022-05-25 09:27:37 +02:00
|
|
|
int ret; \
|
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
|
|
|
ioctl(sysfd, PERF_EVENT_IOC_DISABLE, 0); \
|
2022-05-25 09:27:37 +02:00
|
|
|
ret = read(sysfd, &t, sizeof(t)); \
|
|
|
|
(void)ret; \
|
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
|
|
|
} while (0)
|
2021-07-20 19:09:22 +02:00
|
|
|
#elif CONFIG_MACOS_KPERF
|
|
|
|
#define PERF_START(t) t = ff_kperf_cycles()
|
|
|
|
#define PERF_STOP(t) t = ff_kperf_cycles() - t
|
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
|
|
|
#else
|
|
|
|
#define PERF_START(t) t = AV_READ_TIME()
|
|
|
|
#define PERF_STOP(t) t = AV_READ_TIME() - t
|
|
|
|
#endif
|
|
|
|
|
2015-07-11 20:32:11 +02:00
|
|
|
/* Benchmark the function */
|
|
|
|
#define bench_new(...)\
|
|
|
|
do {\
|
|
|
|
if (checkasm_bench_func()) {\
|
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
|
|
|
struct CheckasmPerf *perf = checkasm_get_perf_context();\
|
|
|
|
av_unused const int sysfd = perf->sysfd;\
|
2015-08-16 13:00:21 +02:00
|
|
|
func_type *tfunc = func_new;\
|
2015-07-11 20:32:11 +02:00
|
|
|
uint64_t tsum = 0;\
|
2024-05-13 15:04:31 +02:00
|
|
|
uint64_t ti, tcount = 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
|
|
|
uint64_t t = 0; \
|
2024-05-13 15:04:31 +02:00
|
|
|
const uint64_t truns = bench_runs;\
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
checkasm_set_signal_handler_state(1);\
|
2024-05-13 15:04:31 +02:00
|
|
|
for (ti = 0; ti < truns; ti++) {\
|
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);\
|
2015-07-11 20:32:11 +02:00
|
|
|
tfunc(__VA_ARGS__);\
|
|
|
|
tfunc(__VA_ARGS__);\
|
|
|
|
tfunc(__VA_ARGS__);\
|
|
|
|
tfunc(__VA_ARGS__);\
|
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_STOP(t);\
|
2015-07-11 20:32:11 +02:00
|
|
|
if (t*tcount <= tsum*4 && ti > 0) {\
|
|
|
|
tsum += t;\
|
|
|
|
tcount++;\
|
|
|
|
}\
|
|
|
|
}\
|
2016-06-21 13:00:01 +02:00
|
|
|
emms_c();\
|
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->cycles += t;\
|
|
|
|
perf->iterations++;\
|
checkasm: Generalize crash handling
This replaces the riscv specific handling from
7212466e735aa187d82f51dadbce957fe3da77f0 (which essentially is
reverted), with a different implementation of the same (plus a bit
more), based on the corresponding feature in dav1d's checkasm,
supporting both Unix and Windows.
See in particular the dav1d commits
0b6ee30eab2400e4f85b735ad29a68a842c34e21,
0421f787ea592fd2cc74c887f20b8dc31393788b,
8501a4b20135f93a4c3b426468e2240e872949c5 and
d23e87f7aee26ddcf5f7a2e185112031477599a7, authored by Henrik Gramner.
The overall approach compared to the existing implementation for
riscv is the same; set up a signal handler, store the state with
sigsetjmp, jump out of the crashing function with siglongjmp.
The main difference is in what happens when the signal handler
is invoked. In the previous implementation, it would resume from
right before calling the crashing function, and then skip that call
based on the setjmp return value.
In the imported implementation from dav1d, we return to right before
the check_func() call, which will skip testing the current function
(as the pointer is the same as it was before).
Other differences are:
- Support for other signal handling mechanisms (Windows
AddVectoredExceptionHandler)
- Using RtlCaptureContext/RtlRestoreContext instead of setjmp/longjmp
on Windows with SEH
- Only catching signals once per function - if more than one
signal is delivered before signal handling is reenabled, any
signal is handled as it would without our handler
- Not using an arch specific signal handler written in assembly
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-12-14 14:57:36 +02:00
|
|
|
checkasm_set_signal_handler_state(0);\
|
2015-07-11 20:32:11 +02:00
|
|
|
}\
|
|
|
|
} while (0)
|
|
|
|
#else
|
2015-07-16 04:02:51 +02:00
|
|
|
#define bench_new(...) while(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
|
|
|
#define PERF_START(t) while(0)
|
|
|
|
#define PERF_STOP(t) while(0)
|
2015-07-11 20:32:11 +02:00
|
|
|
#endif
|
|
|
|
|
2019-06-20 22:38:06 +02:00
|
|
|
#define DECL_CHECKASM_CHECK_FUNC(type) \
|
2023-12-16 00:33:59 +02:00
|
|
|
int checkasm_check_##type(const char *file, int line, \
|
|
|
|
const type *buf1, ptrdiff_t stride1, \
|
|
|
|
const type *buf2, ptrdiff_t stride2, \
|
|
|
|
int w, int h, const char *name)
|
2019-06-20 22:38:06 +02:00
|
|
|
|
|
|
|
DECL_CHECKASM_CHECK_FUNC(uint8_t);
|
|
|
|
DECL_CHECKASM_CHECK_FUNC(uint16_t);
|
2022-10-26 17:51:36 +02:00
|
|
|
DECL_CHECKASM_CHECK_FUNC(uint32_t);
|
2019-06-20 22:38:06 +02:00
|
|
|
DECL_CHECKASM_CHECK_FUNC(int16_t);
|
|
|
|
DECL_CHECKASM_CHECK_FUNC(int32_t);
|
|
|
|
|
|
|
|
#define PASTE(a,b) a ## b
|
|
|
|
#define CONCAT(a,b) PASTE(a,b)
|
|
|
|
|
|
|
|
#define checkasm_check(prefix, ...) CONCAT(checkasm_check_, prefix)(__FILE__, __LINE__, __VA_ARGS__)
|
|
|
|
|
2016-02-16 19:12:28 +02:00
|
|
|
#endif /* TESTS_CHECKASM_CHECKASM_H */
|