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

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

  35. void checkasm_check_audiodsp(void);

  36. void checkasm_check_blend(void);

  37. void checkasm_check_blockdsp(void);

  38. void checkasm_check_bswapdsp(void);

  39. void checkasm_check_colorspace(void);

  40. void checkasm_check_fixed_dsp(void);

  41. void checkasm_check_flacdsp(void);

  42. void checkasm_check_float_dsp(void);

  43. void checkasm_check_fmtconvert(void);

  44. void checkasm_check_h264dsp(void);

  45. void checkasm_check_h264pred(void);

  46. void checkasm_check_h264qpel(void);

  47. void checkasm_check_hevc_add_res(void);

  48. void checkasm_check_hevc_idct(void);

  49. void checkasm_check_jpeg2000dsp(void);

  50. void checkasm_check_llviddsp(void);

  51. void checkasm_check_pixblockdsp(void);

  52. void checkasm_check_synth_filter(void);

  53. void checkasm_check_v210enc(void);

  54. void checkasm_check_vp8dsp(void);

  55. void checkasm_check_vp9dsp(void);

  56. void checkasm_check_videodsp(void);

  57. 

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

  59. int checkasm_bench_func(void);

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

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

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

  63. 

  64. /* float compare utilities */

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

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

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

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

  69.                          unsigned len);

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

  71.                              unsigned len);

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

  73.                                  unsigned max_ulp, unsigned len);

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

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

  76.                               unsigned len);

  77. 

  78. extern AVLFG checkasm_lfg;

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

  80. 

  81. static av_unused void *func_ref, *func_new;

  82. 

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

  84. 

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

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

  87. 

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

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

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

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

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

  93. 

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

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

  96. 

  97. /* Print the test outcome */

  98. #define report checkasm_report

  99. 

  100. /* Call the reference function */

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

  102. 

  103. #if ARCH_X86 && HAVE_YASM

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

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

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

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

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

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

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

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

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

  113. 

  114. #if ARCH_X86_64

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

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

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

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

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

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

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

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

  123.  */

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

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

  126.                               = (void *)checkasm_checked_call;

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

  128.                                     = (void *)checkasm_checked_call_float;

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

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

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

  132.                                              (void *)checkasm_checked_call;

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

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

  135.                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\

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

  137. #elif ARCH_X86_32

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

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

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

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

  142.                                              (void *)checkasm_checked_call;

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

  144. #endif

  145. #elif ARCH_ARM && HAVE_ARMV5TE_EXTERNAL

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

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

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

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

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

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

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

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

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

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

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

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

  158.                               = (void *)checkasm_checked_call;

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

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

  161.                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\

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

  163. #else

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

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

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

  167. /* Call the function */

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

  169. #endif

  170. 

  171. #ifndef declare_new_emms

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

  173. #endif

  174. #ifndef declare_new_float

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

  176. #endif

  177. 

  178. /* Benchmark the function */

  179. #ifdef AV_READ_TIME

  180. #define bench_new(...)\

  181.     do {\

  182.         if (checkasm_bench_func()) {\

  183.             func_type *tfunc = func_new;\

  184.             uint64_t tsum = 0;\

  185.             int ti, tcount = 0;\

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

  187.                 uint64_t t = AV_READ_TIME();\

  188.                 tfunc(__VA_ARGS__);\

  189.                 tfunc(__VA_ARGS__);\

  190.                 tfunc(__VA_ARGS__);\

  191.                 tfunc(__VA_ARGS__);\

  192.                 t = AV_READ_TIME() - t;\

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

  194.                     tsum += t;\

  195.                     tcount++;\

  196.                 }\

  197.             }\

  198.             emms_c();\

  199.             checkasm_update_bench(tcount, tsum);\

  200.         }\

  201.     } while (0)

  202. #else

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

  204. #endif

  205. 

  206. #endif /* TESTS_CHECKASM_CHECKASM_H */