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.
90265 Commits
32 Branches
959MB
Tree: 80798e3857
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '80798e3857'
${ noResults }
FFmpeg/tests/checkasm/checkasm.h

254 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_alacdsp(void);

  44. void checkasm_check_audiodsp(void);

  45. void checkasm_check_blend(void);

  46. void checkasm_check_blockdsp(void);

  47. void checkasm_check_bswapdsp(void);

  48. void checkasm_check_colorspace(void);

  49. void checkasm_check_exrdsp(void);

  50. void checkasm_check_fixed_dsp(void);

  51. void checkasm_check_flacdsp(void);

  52. void checkasm_check_float_dsp(void);

  53. void checkasm_check_fmtconvert(void);

  54. void checkasm_check_g722dsp(void);

  55. void checkasm_check_h264dsp(void);

  56. void checkasm_check_h264pred(void);

  57. void checkasm_check_h264qpel(void);

  58. void checkasm_check_hevc_add_res(void);

  59. void checkasm_check_hevc_idct(void);

  60. void checkasm_check_hevc_sao(void);

  61. void checkasm_check_huffyuvdsp(void);

  62. void checkasm_check_jpeg2000dsp(void);

  63. void checkasm_check_llviddsp(void);

  64. void checkasm_check_llviddspenc(void);

  65. void checkasm_check_pixblockdsp(void);

  66. void checkasm_check_sbrdsp(void);

  67. void checkasm_check_synth_filter(void);

  68. void checkasm_check_utvideodsp(void);

  69. void checkasm_check_v210enc(void);

  70. void checkasm_check_vf_hflip(void);

  71. void checkasm_check_vf_threshold(void);

  72. void checkasm_check_vp8dsp(void);

  73. void checkasm_check_vp9dsp(void);

  74. void checkasm_check_videodsp(void);

  75. 

  76. struct CheckasmPerf;

  77. 

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

  79. int checkasm_bench_func(void);

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

  81. struct CheckasmPerf *checkasm_get_perf_context(void);

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

  83. 

  84. /* float compare utilities */

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

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

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

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

  89.                          unsigned len);

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

  91.                              unsigned len);

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

  93.                                  unsigned max_ulp, unsigned len);

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

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

  96.                               unsigned len);

  97. 

  98. extern AVLFG checkasm_lfg;

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

  100. 

  101. static av_unused void *func_ref, *func_new;

  102. 

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

  104. 

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

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

  107. 

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

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

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

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

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

  113. 

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

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

  116. 

  117. /* Print the test outcome */

  118. #define report checkasm_report

  119. 

  120. /* Call the reference function */

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

  122. 

  123. #if ARCH_X86 && HAVE_X86ASM

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

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

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

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

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

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

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

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

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

  133. 

  134. #if ARCH_X86_64

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

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

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

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

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

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

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

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

  143.  */

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

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

  146.                               = (void *)checkasm_checked_call;

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

  148.                                     = (void *)checkasm_checked_call_float;

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

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

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

  152.                                              (void *)checkasm_checked_call;

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

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

  155.                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\

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

  157. #elif ARCH_X86_32

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

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

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

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

  162.                                              (void *)checkasm_checked_call;

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

  164. #endif

  165. #elif ARCH_ARM && HAVE_ARMV5TE_EXTERNAL

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

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

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

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

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

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

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

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

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

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

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

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

  178.                               = (void *)checkasm_checked_call;

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

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

  181.                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\

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

  183. #else

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

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

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

  187. /* Call the function */

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

  189. #endif

  190. 

  191. #ifndef declare_new_emms

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

  193. #endif

  194. #ifndef declare_new_float

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

  196. #endif

  197. 

  198. typedef struct CheckasmPerf {

  199.     int sysfd;

  200.     uint64_t cycles;

  201.     int iterations;

  202. } CheckasmPerf;

  203. 

  204. #if defined(AV_READ_TIME) || CONFIG_LINUX_PERF

  205. 

  206. #if CONFIG_LINUX_PERF

  207. #define PERF_START(t) do {                              \

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

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

  210. } while (0)

  211. #define PERF_STOP(t) do {                               \

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

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

  214. } while (0)

  215. #else

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

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

  218. #endif

  219. 

  220. /* Benchmark the function */

  221. #define bench_new(...)\

  222.     do {\

  223.         if (checkasm_bench_func()) {\

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

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

  226.             func_type *tfunc = func_new;\

  227.             uint64_t tsum = 0;\

  228.             int ti, tcount = 0;\

  229.             uint64_t t = 0; \

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

  231.                 PERF_START(t);\

  232.                 tfunc(__VA_ARGS__);\

  233.                 tfunc(__VA_ARGS__);\

  234.                 tfunc(__VA_ARGS__);\

  235.                 tfunc(__VA_ARGS__);\

  236.                 PERF_STOP(t);\

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

  238.                     tsum += t;\

  239.                     tcount++;\

  240.                 }\

  241.             }\

  242.             emms_c();\

  243.             perf->cycles += t;\

  244.             perf->iterations++;\

  245.         }\

  246.     } while (0)

  247. #else

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

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

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

  251. #endif

  252. 

  253. #endif /* TESTS_CHECKASM_CHECKASM_H */