2015-07-11 18:32:11 +00:00
|
|
|
/*
|
|
|
|
* Assembly testing and benchmarking tool
|
|
|
|
* Copyright (c) 2015 Henrik Gramner
|
|
|
|
* Copyright (c) 2008 Loren Merritt
|
|
|
|
*
|
2015-07-12 19:00:50 +00:00
|
|
|
* This file is part of FFmpeg.
|
2015-07-11 18:32:11 +00:00
|
|
|
*
|
2015-07-12 19:00:50 +00:00
|
|
|
* FFmpeg is free software; you can redistribute it and/or modify
|
2015-07-11 18:32:11 +00: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 19:00:50 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2015-07-11 18:32:11 +00: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 19:00:50 +00:00
|
|
|
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
|
2015-07-11 18:32:11 +00:00
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2016-01-29 02:25:13 +00:00
|
|
|
#ifndef TESTS_CHECKASM_CHECKASM_H
|
|
|
|
#define TESTS_CHECKASM_CHECKASM_H
|
2015-07-11 18:32:11 +00:00
|
|
|
|
2023-07-12 19:48:53 +00:00
|
|
|
#include <setjmp.h>
|
2015-07-11 18:32:11 +00: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 13:11:18 +00: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 17:09:22 +00: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 13:11:18 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-11 18:32:11 +00:00
|
|
|
#include "libavutil/avstring.h"
|
2015-12-11 13:06:38 +00:00
|
|
|
#include "libavutil/cpu.h"
|
2023-08-31 22:23:35 +00:00
|
|
|
#include "libavutil/emms.h"
|
2016-06-21 11:00:01 +00:00
|
|
|
#include "libavutil/internal.h"
|
2015-07-11 18:32:11 +00:00
|
|
|
#include "libavutil/lfg.h"
|
|
|
|
#include "libavutil/timer.h"
|
|
|
|
|
2017-06-02 08:06:08 +00:00
|
|
|
void checkasm_check_aacpsdsp(void);
|
2023-11-22 06:57:29 +00:00
|
|
|
void checkasm_check_ac3dsp(void);
|
2019-01-02 23:54:34 +00:00
|
|
|
void checkasm_check_afir(void);
|
2015-10-06 23:25:49 +00:00
|
|
|
void checkasm_check_alacdsp(void);
|
2016-08-09 16:10:26 +00:00
|
|
|
void checkasm_check_audiodsp(void);
|
2021-04-10 01:53:38 +00:00
|
|
|
void checkasm_check_av_tx(void);
|
2016-02-10 09:07:40 +00:00
|
|
|
void checkasm_check_blend(void);
|
2016-08-08 19:58:17 +00:00
|
|
|
void checkasm_check_blockdsp(void);
|
2015-07-15 22:10:28 +00:00
|
|
|
void checkasm_check_bswapdsp(void);
|
2016-04-06 18:09:08 +00:00
|
|
|
void checkasm_check_colorspace(void);
|
2017-09-17 21:48:02 +00:00
|
|
|
void checkasm_check_exrdsp(void);
|
2017-04-11 20:12:21 +00:00
|
|
|
void checkasm_check_fixed_dsp(void);
|
2015-09-17 18:22:25 +00:00
|
|
|
void checkasm_check_flacdsp(void);
|
2017-04-11 20:16:56 +00:00
|
|
|
void checkasm_check_float_dsp(void);
|
2015-12-08 15:24:57 +00:00
|
|
|
void checkasm_check_fmtconvert(void);
|
2017-07-05 19:34:00 +00:00
|
|
|
void checkasm_check_g722dsp(void);
|
2023-05-18 14:18:16 +00:00
|
|
|
void checkasm_check_h264chroma(void);
|
2016-06-11 11:17:37 +00:00
|
|
|
void checkasm_check_h264dsp(void);
|
2015-07-11 18:32:11 +00:00
|
|
|
void checkasm_check_h264pred(void);
|
2015-07-13 21:11:25 +00:00
|
|
|
void checkasm_check_h264qpel(void);
|
2016-10-11 08:44:19 +00:00
|
|
|
void checkasm_check_hevc_add_res(void);
|
2023-03-21 17:44:03 +00:00
|
|
|
void checkasm_check_hevc_deblock(void);
|
2016-07-21 14:32:50 +00:00
|
|
|
void checkasm_check_hevc_idct(void);
|
2021-08-05 08:26:48 +00:00
|
|
|
void checkasm_check_hevc_pel(void);
|
2018-03-07 04:42:30 +00:00
|
|
|
void checkasm_check_hevc_sao(void);
|
2017-11-21 08:09:42 +00:00
|
|
|
void checkasm_check_huffyuvdsp(void);
|
2022-03-31 17:23:44 +00:00
|
|
|
void checkasm_check_idctdsp(void);
|
2015-09-18 02:53:37 +00:00
|
|
|
void checkasm_check_jpeg2000dsp(void);
|
2023-11-12 19:45:24 +00:00
|
|
|
void checkasm_check_llauddsp(void);
|
2017-03-22 15:29:44 +00:00
|
|
|
void checkasm_check_llviddsp(void);
|
2018-01-14 13:23:42 +00:00
|
|
|
void checkasm_check_llviddspenc(void);
|
2022-09-19 21:48:53 +00:00
|
|
|
void checkasm_check_lpc(void);
|
2022-06-26 20:58:09 +00:00
|
|
|
void checkasm_check_motion(void);
|
2018-05-06 08:57:23 +00:00
|
|
|
void checkasm_check_nlmeans(void);
|
2019-08-15 10:42:19 +00:00
|
|
|
void checkasm_check_opusdsp(void);
|
2015-11-01 11:31:22 +00:00
|
|
|
void checkasm_check_pixblockdsp(void);
|
2017-06-09 09:34:12 +00:00
|
|
|
void checkasm_check_sbrdsp(void);
|
2015-12-07 22:38:46 +00:00
|
|
|
void checkasm_check_synth_filter(void);
|
2021-11-24 21:15:20 +00:00
|
|
|
void checkasm_check_sw_gbrp(void);
|
2018-03-24 19:19:00 +00:00
|
|
|
void checkasm_check_sw_rgb(void);
|
2020-05-13 15:02:53 +00:00
|
|
|
void checkasm_check_sw_scale(void);
|
2017-11-21 07:31:12 +00:00
|
|
|
void checkasm_check_utvideodsp(void);
|
2019-03-04 18:50:35 +00:00
|
|
|
void checkasm_check_v210dec(void);
|
2015-09-05 23:06:12 +00:00
|
|
|
void checkasm_check_v210enc(void);
|
2022-03-31 17:23:42 +00:00
|
|
|
void checkasm_check_vc1dsp(void);
|
2023-02-20 19:55:08 +00:00
|
|
|
void checkasm_check_vf_bwdif(void);
|
2019-09-18 07:05:33 +00:00
|
|
|
void checkasm_check_vf_eq(void);
|
2019-06-04 08:34:08 +00:00
|
|
|
void checkasm_check_vf_gblur(void);
|
2017-12-11 10:26:44 +00:00
|
|
|
void checkasm_check_vf_hflip(void);
|
2017-12-03 15:56:25 +00:00
|
|
|
void checkasm_check_vf_threshold(void);
|
2022-11-04 08:29:25 +00:00
|
|
|
void checkasm_check_vf_sobel(void);
|
2016-06-13 20:00:51 +00:00
|
|
|
void checkasm_check_vp8dsp(void);
|
2015-09-15 20:41:29 +00:00
|
|
|
void checkasm_check_vp9dsp(void);
|
2016-01-17 21:22:26 +00:00
|
|
|
void checkasm_check_videodsp(void);
|
2022-09-19 16:56:34 +00:00
|
|
|
void checkasm_check_vorbisdsp(void);
|
2015-07-11 18:32:11 +00: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 13:11:18 +00:00
|
|
|
struct CheckasmPerf;
|
|
|
|
|
2015-08-16 11:00:21 +00:00
|
|
|
void *checkasm_check_func(void *func, const char *name, ...) av_printf_format(2, 3);
|
2015-07-11 18:32:11 +00:00
|
|
|
int checkasm_bench_func(void);
|
|
|
|
void checkasm_fail_func(const char *msg, ...) av_printf_format(1, 2);
|
2023-11-16 15:45:02 +00:00
|
|
|
void checkasm_fail_signal(int signum);
|
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 13:11:18 +00:00
|
|
|
struct CheckasmPerf *checkasm_get_perf_context(void);
|
2015-07-11 18:32:11 +00:00
|
|
|
void checkasm_report(const char *name, ...) av_printf_format(1, 2);
|
|
|
|
|
2015-12-07 15:14:46 +00: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 20:16:56 +00: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 15:14:46 +00:00
|
|
|
|
2015-07-11 18:32:11 +00:00
|
|
|
extern AVLFG checkasm_lfg;
|
|
|
|
#define rnd() av_lfg_get(&checkasm_lfg)
|
|
|
|
|
2015-08-16 11:00:21 +00:00
|
|
|
static av_unused void *func_ref, *func_new;
|
2015-07-11 18:32:11 +00:00
|
|
|
|
|
|
|
#define BENCH_RUNS 1000 /* Trade-off between accuracy and speed */
|
|
|
|
|
|
|
|
/* Decide whether or not the specified function needs to be tested */
|
2015-08-16 11:00:21 +00:00
|
|
|
#define check_func(func, ...) (func_ref = checkasm_check_func((func_new = func), __VA_ARGS__))
|
|
|
|
|
|
|
|
/* 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 21:50:49 +00:00
|
|
|
#define declare_func_float(ret, ...) declare_new_float(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
|
2015-12-11 13:06:38 +00: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 18:32:11 +00: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 21:46:20 +00:00
|
|
|
#define report checkasm_report
|
2015-07-11 18:32:11 +00:00
|
|
|
|
|
|
|
/* Call the reference function */
|
2015-08-16 11:00:21 +00:00
|
|
|
#define call_ref(...) ((func_type *)func_ref)(__VA_ARGS__)
|
2015-07-11 18:32:11 +00:00
|
|
|
|
2016-10-08 14:18:33 +00:00
|
|
|
#if ARCH_X86 && HAVE_X86ASM
|
2015-12-11 13:06:38 +00: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 11:00:21 +00:00
|
|
|
void checkasm_checked_call(void *func, ...);
|
2015-12-11 13:06:38 +00: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 21:50:49 +00: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 18:32:11 +00:00
|
|
|
|
2015-08-16 11:00:21 +00:00
|
|
|
#if ARCH_X86_64
|
2015-07-11 18:32:11 +00: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 11:00:21 +00:00
|
|
|
* assembly function through checked_call() with added dummy arguments which forces all
|
2015-07-11 18:32:11 +00: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 11:00:21 +00:00
|
|
|
#define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\
|
|
|
|
= (void *)checkasm_checked_call;
|
2017-06-01 21:50:49 +00: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 13:06:38 +00: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 18:32:11 +00:00
|
|
|
#define CLOB (UINT64_C(0xdeadbeefdeadbeef))
|
|
|
|
#define call_new(...) (checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
|
|
|
|
CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
|
2015-08-16 11:00:21 +00:00
|
|
|
checked_call(func_new, 0, 0, 0, 0, 0, __VA_ARGS__))
|
|
|
|
#elif ARCH_X86_32
|
|
|
|
#define declare_new(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call;
|
2017-06-01 21:50:49 +00:00
|
|
|
#define declare_new_float(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call_float;
|
2015-12-11 13:06:38 +00: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;
|
2015-08-16 11:00:21 +00:00
|
|
|
#define call_new(...) checked_call(func_new, __VA_ARGS__)
|
|
|
|
#endif
|
2015-12-30 21:46:06 +00: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 18:09:08 +00: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;
|
|
|
|
#define call_new(...) checked_call(func_new, 0, __VA_ARGS__, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0)
|
2015-12-31 10:20:37 +00:00
|
|
|
#elif ARCH_AARCH64 && !defined(__APPLE__)
|
2016-09-30 08:39:22 +00:00
|
|
|
void checkasm_stack_clobber(uint64_t clobber, ...);
|
2015-12-31 10:20:37 +00:00
|
|
|
void checkasm_checked_call(void *func, ...);
|
2020-05-13 11:11:39 +00: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 09:06:49 +00:00
|
|
|
= (void *)checkasm_checked_call;
|
2016-09-30 08:39:22 +00:00
|
|
|
#define CLOB (UINT64_C(0xdeadbeefdeadbeef))
|
|
|
|
#define call_new(...) (checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
|
|
|
|
CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
|
2020-05-13 11:11:39 +00:00
|
|
|
checked_call(func_new, 0, 0, 0, 0, 0, 0, 0, __VA_ARGS__,\
|
|
|
|
7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0))
|
2022-10-06 19:15:41 +00:00
|
|
|
#elif ARCH_RISCV
|
2023-07-12 19:48:53 +00:00
|
|
|
void checkasm_set_function(void *, sigjmp_buf);
|
2022-10-06 19:15:41 +00:00
|
|
|
void *checkasm_get_wrapper(void);
|
2023-07-12 19:48:53 +00:00
|
|
|
void checkasm_handle_signal(int signum);
|
2022-10-06 19:15:41 +00:00
|
|
|
|
|
|
|
#if (__riscv_xlen == 64) && defined (__riscv_d)
|
|
|
|
#define declare_new(ret, ...) \
|
2023-07-12 19:48:53 +00:00
|
|
|
int checked_call_signum = 0; \
|
|
|
|
sigjmp_buf checked_call_jb; \
|
2022-10-06 19:15:41 +00:00
|
|
|
ret (*checked_call)(__VA_ARGS__) = checkasm_get_wrapper();
|
|
|
|
#define call_new(...) \
|
2023-07-12 19:48:53 +00:00
|
|
|
(checkasm_set_function(func_new, checked_call_jb), \
|
|
|
|
(checked_call_signum = sigsetjmp(checked_call_jb, 1)) == 0 \
|
|
|
|
? checked_call(__VA_ARGS__) \
|
|
|
|
: (checkasm_fail_signal(checked_call_signum), 0))
|
2022-10-06 19:15:41 +00:00
|
|
|
#endif
|
2015-07-11 18:32:11 +00:00
|
|
|
#else
|
2015-08-16 11:00:21 +00:00
|
|
|
#define declare_new(ret, ...)
|
2017-06-01 21:50:49 +00:00
|
|
|
#define declare_new_float(ret, ...)
|
2015-12-11 13:06:38 +00:00
|
|
|
#define declare_new_emms(cpu_flags, ret, ...)
|
2015-08-16 11:00:21 +00:00
|
|
|
/* Call the function */
|
|
|
|
#define call_new(...) ((func_type *)func_new)(__VA_ARGS__)
|
2015-07-11 18:32:11 +00:00
|
|
|
#endif
|
|
|
|
|
2015-12-30 21:46:06 +00:00
|
|
|
#ifndef declare_new_emms
|
|
|
|
#define declare_new_emms(cpu_flags, ret, ...) declare_new(ret, __VA_ARGS__)
|
|
|
|
#endif
|
2017-06-01 21:50:49 +00:00
|
|
|
#ifndef declare_new_float
|
|
|
|
#define declare_new_float(ret, ...) declare_new(ret, __VA_ARGS__)
|
|
|
|
#endif
|
2015-12-30 21:46:06 +00: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 13:11:18 +00:00
|
|
|
typedef struct CheckasmPerf {
|
|
|
|
int sysfd;
|
|
|
|
uint64_t cycles;
|
|
|
|
int iterations;
|
|
|
|
} CheckasmPerf;
|
|
|
|
|
2021-07-20 17:09:22 +00: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 13:11:18 +00: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 07:27:37 +00: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 13:11:18 +00:00
|
|
|
ioctl(sysfd, PERF_EVENT_IOC_DISABLE, 0); \
|
2022-05-25 07:27:37 +00: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 13:11:18 +00:00
|
|
|
} while (0)
|
2021-07-20 17:09:22 +00: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 13:11:18 +00:00
|
|
|
#else
|
|
|
|
#define PERF_START(t) t = AV_READ_TIME()
|
|
|
|
#define PERF_STOP(t) t = AV_READ_TIME() - t
|
|
|
|
#endif
|
|
|
|
|
2015-07-11 18:32:11 +00: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 13:11:18 +00:00
|
|
|
struct CheckasmPerf *perf = checkasm_get_perf_context();\
|
|
|
|
av_unused const int sysfd = perf->sysfd;\
|
2015-08-16 11:00:21 +00:00
|
|
|
func_type *tfunc = func_new;\
|
2015-07-11 18:32:11 +00:00
|
|
|
uint64_t tsum = 0;\
|
|
|
|
int 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 13:11:18 +00:00
|
|
|
uint64_t t = 0; \
|
2015-07-11 18:32:11 +00:00
|
|
|
for (ti = 0; ti < BENCH_RUNS; 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 13:11:18 +00:00
|
|
|
PERF_START(t);\
|
2015-07-11 18:32:11 +00: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 13:11:18 +00:00
|
|
|
PERF_STOP(t);\
|
2015-07-11 18:32:11 +00:00
|
|
|
if (t*tcount <= tsum*4 && ti > 0) {\
|
|
|
|
tsum += t;\
|
|
|
|
tcount++;\
|
|
|
|
}\
|
|
|
|
}\
|
2016-06-21 11:00:01 +00: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 13:11:18 +00:00
|
|
|
perf->cycles += t;\
|
|
|
|
perf->iterations++;\
|
2015-07-11 18:32:11 +00:00
|
|
|
}\
|
|
|
|
} while (0)
|
|
|
|
#else
|
2015-07-16 02:02:51 +00: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 13:11:18 +00:00
|
|
|
#define PERF_START(t) while(0)
|
|
|
|
#define PERF_STOP(t) while(0)
|
2015-07-11 18:32:11 +00:00
|
|
|
#endif
|
|
|
|
|
2019-06-20 20:38:06 +00:00
|
|
|
#define DECL_CHECKASM_CHECK_FUNC(type) \
|
|
|
|
int checkasm_check_##type(const char *const file, const int line, \
|
|
|
|
const type *const buf1, const ptrdiff_t stride1, \
|
|
|
|
const type *const buf2, const ptrdiff_t stride2, \
|
|
|
|
const int w, const int h, const char *const name)
|
|
|
|
|
|
|
|
DECL_CHECKASM_CHECK_FUNC(uint8_t);
|
|
|
|
DECL_CHECKASM_CHECK_FUNC(uint16_t);
|
2022-10-26 15:51:36 +00:00
|
|
|
DECL_CHECKASM_CHECK_FUNC(uint32_t);
|
2019-06-20 20:38:06 +00: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 17:12:28 +00:00
|
|
|
#endif /* TESTS_CHECKASM_CHECKASM_H */
|