falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
96764 Commits
32 Branches
283MB
Tree: 96840e47de
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '96840e47de'
${ noResults }
FFmpeg/tests/checkasm/checkasm.h

261 lines
11KB
Raw Blame History 

  1. /*

  2.  * Assembly testing and benchmarking tool

  3.  * Copyright (c) 2015 Henrik Gramner

  4.  * Copyright (c) 2008 Loren Merritt

  5.  *

  6.  * This file is part of FFmpeg.

  7.  *

  8.  * FFmpeg is free software; you can redistribute it and/or modify

  9.  * it under the terms of the GNU General Public License as published by

  10.  * the Free Software Foundation; either version 2 of the License, or

  11.  * (at your option) any later version.

  12.  *

  13.  * FFmpeg is distributed in the hope that it will be useful,

  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  16.  * GNU General Public License for more details.

  17.  *

  18.  * You should have received a copy of the GNU General Public License along

  19.  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,

  20.  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  21.  */

  22. 

  23. #ifndef TESTS_CHECKASM_CHECKASM_H

  24. #define TESTS_CHECKASM_CHECKASM_H

  25. 

  26. #include <stdint.h>

  27. #include "config.h"

  28. 

  29. #if CONFIG_LINUX_PERF

  30. #include <unistd.h> // read(3)

  31. #include <sys/ioctl.h>

  32. #include <asm/unistd.h>

  33. #include <linux/perf_event.h>

  34. #endif

  35. 

  36. #include "libavutil/avstring.h"

  37. #include "libavutil/cpu.h"

  38. #include "libavutil/internal.h"

  39. #include "libavutil/lfg.h"

  40. #include "libavutil/timer.h"

  41. 

  42. void checkasm_check_aacpsdsp(void);

  43. void checkasm_check_afir(void);

  44. void checkasm_check_alacdsp(void);

  45. void checkasm_check_audiodsp(void);

  46. void checkasm_check_blend(void);

  47. void checkasm_check_blockdsp(void);

  48. void checkasm_check_bswapdsp(void);

  49. void checkasm_check_colorspace(void);

  50. void checkasm_check_exrdsp(void);

  51. void checkasm_check_fixed_dsp(void);

  52. void checkasm_check_flacdsp(void);

  53. void checkasm_check_float_dsp(void);

  54. void checkasm_check_fmtconvert(void);

  55. void checkasm_check_g722dsp(void);

  56. void checkasm_check_h264dsp(void);

  57. void checkasm_check_h264pred(void);

  58. void checkasm_check_h264qpel(void);

  59. void checkasm_check_hevc_add_res(void);

  60. void checkasm_check_hevc_idct(void);

  61. void checkasm_check_hevc_sao(void);

  62. void checkasm_check_huffyuvdsp(void);

  63. void checkasm_check_jpeg2000dsp(void);

  64. void checkasm_check_llviddsp(void);

  65. void checkasm_check_llviddspenc(void);

  66. void checkasm_check_nlmeans(void);

  67. void checkasm_check_opusdsp(void);

  68. void checkasm_check_pixblockdsp(void);

  69. void checkasm_check_sbrdsp(void);

  70. void checkasm_check_synth_filter(void);

  71. void checkasm_check_sw_rgb(void);

  72. void checkasm_check_utvideodsp(void);

  73. void checkasm_check_v210dec(void);

  74. void checkasm_check_v210enc(void);

  75. void checkasm_check_vf_eq(void);

  76. void checkasm_check_vf_gblur(void);

  77. void checkasm_check_vf_hflip(void);

  78. void checkasm_check_vf_threshold(void);

  79. void checkasm_check_vp8dsp(void);

  80. void checkasm_check_vp9dsp(void);

  81. void checkasm_check_videodsp(void);

  82. 

  83. struct CheckasmPerf;

  84. 

  85. void *checkasm_check_func(void *func, const char *name, ...) av_printf_format(2, 3);

  86. int checkasm_bench_func(void);

  87. void checkasm_fail_func(const char *msg, ...) av_printf_format(1, 2);

  88. struct CheckasmPerf *checkasm_get_perf_context(void);

  89. void checkasm_report(const char *name, ...) av_printf_format(1, 2);

  90. 

  91. /* float compare utilities */

  92. int float_near_ulp(float a, float b, unsigned max_ulp);

  93. int float_near_abs_eps(float a, float b, float eps);

  94. int float_near_abs_eps_ulp(float a, float b, float eps, unsigned max_ulp);

  95. int float_near_ulp_array(const float *a, const float *b, unsigned max_ulp,

  96.                          unsigned len);

  97. int float_near_abs_eps_array(const float *a, const float *b, float eps,

  98.                              unsigned len);

  99. int float_near_abs_eps_array_ulp(const float *a, const float *b, float eps,

  100.                                  unsigned max_ulp, unsigned len);

  101. int double_near_abs_eps(double a, double b, double eps);

  102. int double_near_abs_eps_array(const double *a, const double *b, double eps,

  103.                               unsigned len);

  104. 

  105. extern AVLFG checkasm_lfg;

  106. #define rnd() av_lfg_get(&checkasm_lfg)

  107. 

  108. static av_unused void *func_ref, *func_new;

  109. 

  110. #define BENCH_RUNS 1000 /* Trade-off between accuracy and speed */

  111. 

  112. /* Decide whether or not the specified function needs to be tested */

  113. #define check_func(func, ...) (func_ref = checkasm_check_func((func_new = func), __VA_ARGS__))

  114. 

  115. /* Declare the function prototype. The first argument is the return value, the remaining

  116.  * arguments are the function parameters. Naming parameters is optional. */

  117. #define declare_func(ret, ...) declare_new(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)

  118. #define declare_func_float(ret, ...) declare_new_float(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)

  119. #define declare_func_emms(cpu_flags, ret, ...) declare_new_emms(cpu_flags, ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)

  120. 

  121. /* Indicate that the current test has failed */

  122. #define fail() checkasm_fail_func("%s:%d", av_basename(__FILE__), __LINE__)

  123. 

  124. /* Print the test outcome */

  125. #define report checkasm_report

  126. 

  127. /* Call the reference function */

  128. #define call_ref(...) ((func_type *)func_ref)(__VA_ARGS__)

  129. 

  130. #if ARCH_X86 && HAVE_X86ASM

  131. /* Verifies that clobbered callee-saved registers are properly saved and restored

  132.  * and that either no MMX registers are touched or emms is issued */

  133. void checkasm_checked_call(void *func, ...);

  134. /* Verifies that clobbered callee-saved registers are properly saved and restored

  135.  * and issues emms for asm functions which are not required to do so */

  136. void checkasm_checked_call_emms(void *func, ...);

  137. /* Verifies that clobbered callee-saved registers are properly saved and restored

  138.  * but doesn't issue emms. Meant for dsp functions returning float or double */

  139. void checkasm_checked_call_float(void *func, ...);

  140. 

  141. #if ARCH_X86_64

  142. /* Evil hack: detect incorrect assumptions that 32-bit ints are zero-extended to 64-bit.

  143.  * This is done by clobbering the stack with junk around the stack pointer and calling the

  144.  * assembly function through checked_call() with added dummy arguments which forces all

  145.  * real arguments to be passed on the stack and not in registers. For 32-bit arguments the

  146.  * upper half of the 64-bit register locations on the stack will now contain junk which will

  147.  * cause misbehaving functions to either produce incorrect output or segfault. Note that

  148.  * even though this works extremely well in practice, it's technically not guaranteed

  149.  * and false negatives is theoretically possible, but there can never be any false positives.

  150.  */

  151. void checkasm_stack_clobber(uint64_t clobber, ...);

  152. #define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\

  153.                               = (void *)checkasm_checked_call;

  154. #define declare_new_float(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\

  155.                                     = (void *)checkasm_checked_call_float;

  156. #define declare_new_emms(cpu_flags, ret, ...) \

  157.     ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__) = \

  158.         ((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms : \

  159.                                              (void *)checkasm_checked_call;

  160. #define CLOB (UINT64_C(0xdeadbeefdeadbeef))

  161. #define call_new(...) (checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\

  162.                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\

  163.                       checked_call(func_new, 0, 0, 0, 0, 0, __VA_ARGS__))

  164. #elif ARCH_X86_32

  165. #define declare_new(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call;

  166. #define declare_new_float(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call_float;

  167. #define declare_new_emms(cpu_flags, ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = \

  168.         ((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms :        \

  169.                                              (void *)checkasm_checked_call;

  170. #define call_new(...) checked_call(func_new, __VA_ARGS__)

  171. #endif

  172. #elif ARCH_ARM && HAVE_ARMV5TE_EXTERNAL

  173. /* Use a dummy argument, to offset the real parameters by 2, not only 1.

  174.  * This makes sure that potential 8-byte-alignment of parameters is kept the same

  175.  * even when the extra parameters have been removed. */

  176. void checkasm_checked_call_vfp(void *func, int dummy, ...);

  177. void checkasm_checked_call_novfp(void *func, int dummy, ...);

  178. extern void (*checkasm_checked_call)(void *func, int dummy, ...);

  179. #define declare_new(ret, ...) ret (*checked_call)(void *, int dummy, __VA_ARGS__) = (void *)checkasm_checked_call;

  180. #define call_new(...) checked_call(func_new, 0, __VA_ARGS__)

  181. #elif ARCH_AARCH64 && !defined(__APPLE__)

  182. void checkasm_stack_clobber(uint64_t clobber, ...);

  183. void checkasm_checked_call(void *func, ...);

  184. #define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, int, int, __VA_ARGS__)\

  185.                               = (void *)checkasm_checked_call;

  186. #define CLOB (UINT64_C(0xdeadbeefdeadbeef))

  187. #define call_new(...) (checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\

  188.                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\

  189.                       checked_call(func_new, 0, 0, 0, 0, 0, 0, 0, __VA_ARGS__))

  190. #else

  191. #define declare_new(ret, ...)

  192. #define declare_new_float(ret, ...)

  193. #define declare_new_emms(cpu_flags, ret, ...)

  194. /* Call the function */

  195. #define call_new(...) ((func_type *)func_new)(__VA_ARGS__)

  196. #endif

  197. 

  198. #ifndef declare_new_emms

  199. #define declare_new_emms(cpu_flags, ret, ...) declare_new(ret, __VA_ARGS__)

  200. #endif

  201. #ifndef declare_new_float

  202. #define declare_new_float(ret, ...) declare_new(ret, __VA_ARGS__)

  203. #endif

  204. 

  205. typedef struct CheckasmPerf {

  206.     int sysfd;

  207.     uint64_t cycles;

  208.     int iterations;

  209. } CheckasmPerf;

  210. 

  211. #if defined(AV_READ_TIME) || CONFIG_LINUX_PERF

  212. 

  213. #if CONFIG_LINUX_PERF

  214. #define PERF_START(t) do {                              \

  215.     ioctl(sysfd, PERF_EVENT_IOC_RESET, 0);              \

  216.     ioctl(sysfd, PERF_EVENT_IOC_ENABLE, 0);             \

  217. } while (0)

  218. #define PERF_STOP(t) do {                               \

  219.     ioctl(sysfd, PERF_EVENT_IOC_DISABLE, 0);            \

  220.     read(sysfd, &t, sizeof(t));                         \

  221. } while (0)

  222. #else

  223. #define PERF_START(t) t = AV_READ_TIME()

  224. #define PERF_STOP(t)  t = AV_READ_TIME() - t

  225. #endif

  226. 

  227. /* Benchmark the function */

  228. #define bench_new(...)\

  229.     do {\

  230.         if (checkasm_bench_func()) {\

  231.             struct CheckasmPerf *perf = checkasm_get_perf_context();\

  232.             av_unused const int sysfd = perf->sysfd;\

  233.             func_type *tfunc = func_new;\

  234.             uint64_t tsum = 0;\

  235.             int ti, tcount = 0;\

  236.             uint64_t t = 0; \

  237.             for (ti = 0; ti < BENCH_RUNS; ti++) {\

  238.                 PERF_START(t);\

  239.                 tfunc(__VA_ARGS__);\

  240.                 tfunc(__VA_ARGS__);\

  241.                 tfunc(__VA_ARGS__);\

  242.                 tfunc(__VA_ARGS__);\

  243.                 PERF_STOP(t);\

  244.                 if (t*tcount <= tsum*4 && ti > 0) {\

  245.                     tsum += t;\

  246.                     tcount++;\

  247.                 }\

  248.             }\

  249.             emms_c();\

  250.             perf->cycles += t;\

  251.             perf->iterations++;\

  252.         }\

  253.     } while (0)

  254. #else

  255. #define bench_new(...) while(0)

  256. #define PERF_START(t)  while(0)

  257. #define PERF_STOP(t)   while(0)

  258. #endif

  259. 

  260. #endif /* TESTS_CHECKASM_CHECKASM_H */