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

208 lines
9.4KB
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. #include "libavutil/avstring.h"

  29. #include "libavutil/cpu.h"

  30. #include "libavutil/internal.h"

  31. #include "libavutil/lfg.h"

  32. #include "libavutil/timer.h"

  33. 

  34. void checkasm_check_aacpsdsp(void);

  35. void checkasm_check_alacdsp(void);

  36. void checkasm_check_audiodsp(void);

  37. void checkasm_check_blend(void);

  38. void checkasm_check_blockdsp(void);

  39. void checkasm_check_bswapdsp(void);

  40. void checkasm_check_colorspace(void);

  41. void checkasm_check_fixed_dsp(void);

  42. void checkasm_check_flacdsp(void);

  43. void checkasm_check_float_dsp(void);

  44. void checkasm_check_fmtconvert(void);

  45. void checkasm_check_h264dsp(void);

  46. void checkasm_check_h264pred(void);

  47. void checkasm_check_h264qpel(void);

  48. void checkasm_check_hevc_add_res(void);

  49. void checkasm_check_hevc_idct(void);

  50. void checkasm_check_jpeg2000dsp(void);

  51. void checkasm_check_llviddsp(void);

  52. void checkasm_check_pixblockdsp(void);

  53. void checkasm_check_synth_filter(void);

  54. void checkasm_check_v210enc(void);

  55. void checkasm_check_vp8dsp(void);

  56. void checkasm_check_vp9dsp(void);

  57. void checkasm_check_videodsp(void);

  58. 

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

  60. int checkasm_bench_func(void);

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

  62. void checkasm_update_bench(int iterations, uint64_t cycles);

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

  64. 

  65. /* float compare utilities */

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

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

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

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

  70.                          unsigned len);

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

  72.                              unsigned len);

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

  74.                                  unsigned max_ulp, unsigned len);

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

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

  77.                               unsigned len);

  78. 

  79. extern AVLFG checkasm_lfg;

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

  81. 

  82. static av_unused void *func_ref, *func_new;

  83. 

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

  85. 

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

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

  88. 

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

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

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

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

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

  94. 

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

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

  97. 

  98. /* Print the test outcome */

  99. #define report checkasm_report

  100. 

  101. /* Call the reference function */

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

  103. 

  104. #if ARCH_X86 && HAVE_X86ASM

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

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

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

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

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

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

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

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

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

  114. 

  115. #if ARCH_X86_64

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

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

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

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

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

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

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

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

  124.  */

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

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

  127.                               = (void *)checkasm_checked_call;

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

  129.                                     = (void *)checkasm_checked_call_float;

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

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

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

  133.                                              (void *)checkasm_checked_call;

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

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

  136.                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\

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

  138. #elif ARCH_X86_32

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

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

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

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

  143.                                              (void *)checkasm_checked_call;

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

  145. #endif

  146. #elif ARCH_ARM && HAVE_ARMV5TE_EXTERNAL

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

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

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

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

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

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

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

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

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

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

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

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

  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,CLOB,\

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

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

  164. #else

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

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

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

  168. /* Call the function */

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

  170. #endif

  171. 

  172. #ifndef declare_new_emms

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

  174. #endif

  175. #ifndef declare_new_float

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

  177. #endif

  178. 

  179. /* Benchmark the function */

  180. #ifdef AV_READ_TIME

  181. #define bench_new(...)\

  182.     do {\

  183.         if (checkasm_bench_func()) {\

  184.             func_type *tfunc = func_new;\

  185.             uint64_t tsum = 0;\

  186.             int ti, tcount = 0;\

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

  188.                 uint64_t t = AV_READ_TIME();\

  189.                 tfunc(__VA_ARGS__);\

  190.                 tfunc(__VA_ARGS__);\

  191.                 tfunc(__VA_ARGS__);\

  192.                 tfunc(__VA_ARGS__);\

  193.                 t = AV_READ_TIME() - t;\

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

  195.                     tsum += t;\

  196.                     tcount++;\

  197.                 }\

  198.             }\

  199.             emms_c();\

  200.             checkasm_update_bench(tcount, tsum);\

  201.         }\

  202.     } while (0)

  203. #else

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

  205. #endif

  206. 

  207. #endif /* TESTS_CHECKASM_CHECKASM_H */