18b101ff59
Now we no longer have to rely on function pointers intentionally declared without specified argument types. This makes it easier to support functions with floating point parameters or return values as well as functions returning 64-bit values on 32-bit architectures. It also avoids having to explicitly cast strides to ptrdiff_t for example.
504 lines
14 KiB
C
504 lines
14 KiB
C
/*
|
|
* Assembly testing and benchmarking tool
|
|
* Copyright (c) 2015 Henrik Gramner
|
|
* Copyright (c) 2008 Loren Merritt
|
|
*
|
|
* This file is part of FFmpeg.
|
|
*
|
|
* FFmpeg is free software; you can redistribute it and/or modify
|
|
* 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.
|
|
*
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
* 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
|
|
* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "checkasm.h"
|
|
#include "libavutil/common.h"
|
|
#include "libavutil/cpu.h"
|
|
#include "libavutil/random_seed.h"
|
|
|
|
#if HAVE_IO_H
|
|
#include <io.h>
|
|
#endif
|
|
|
|
#if HAVE_SETCONSOLETEXTATTRIBUTE
|
|
#include <windows.h>
|
|
#define COLOR_RED FOREGROUND_RED
|
|
#define COLOR_GREEN FOREGROUND_GREEN
|
|
#define COLOR_YELLOW (FOREGROUND_RED|FOREGROUND_GREEN)
|
|
#else
|
|
#define COLOR_RED 1
|
|
#define COLOR_GREEN 2
|
|
#define COLOR_YELLOW 3
|
|
#endif
|
|
|
|
#if HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#if !HAVE_ISATTY
|
|
#define isatty(fd) 1
|
|
#endif
|
|
|
|
/* List of tests to invoke */
|
|
static const struct {
|
|
const char *name;
|
|
void (*func)(void);
|
|
} tests[] = {
|
|
#if CONFIG_BSWAPDSP
|
|
{ "bswapdsp", checkasm_check_bswapdsp },
|
|
#endif
|
|
#if CONFIG_H264PRED
|
|
{ "h264pred", checkasm_check_h264pred },
|
|
#endif
|
|
#if CONFIG_H264QPEL
|
|
{ "h264qpel", checkasm_check_h264qpel },
|
|
#endif
|
|
{ NULL }
|
|
};
|
|
|
|
/* List of cpu flags to check */
|
|
static const struct {
|
|
const char *name;
|
|
const char *suffix;
|
|
int flag;
|
|
} cpus[] = {
|
|
#if ARCH_AARCH64
|
|
{ "ARMV8", "armv8", AV_CPU_FLAG_ARMV8 },
|
|
{ "NEON", "neon", AV_CPU_FLAG_NEON },
|
|
#elif ARCH_ARM
|
|
{ "ARMV5TE", "armv5te", AV_CPU_FLAG_ARMV5TE },
|
|
{ "ARMV6", "armv6", AV_CPU_FLAG_ARMV6 },
|
|
{ "ARMV6T2", "armv6t2", AV_CPU_FLAG_ARMV6T2 },
|
|
{ "VFP", "vfp", AV_CPU_FLAG_VFP },
|
|
{ "VFPV3", "vfp3", AV_CPU_FLAG_VFPV3 },
|
|
{ "NEON", "neon", AV_CPU_FLAG_NEON },
|
|
#elif ARCH_PPC
|
|
{ "ALTIVEC", "altivec", AV_CPU_FLAG_ALTIVEC },
|
|
{ "VSX", "vsx", AV_CPU_FLAG_VSX },
|
|
{ "POWER8", "power8", AV_CPU_FLAG_POWER8 },
|
|
#elif ARCH_X86
|
|
{ "MMX", "mmx", AV_CPU_FLAG_MMX|AV_CPU_FLAG_CMOV },
|
|
{ "MMXEXT", "mmxext", AV_CPU_FLAG_MMXEXT },
|
|
{ "3DNOW", "3dnow", AV_CPU_FLAG_3DNOW },
|
|
{ "3DNOWEXT", "3dnowext", AV_CPU_FLAG_3DNOWEXT },
|
|
{ "SSE", "sse", AV_CPU_FLAG_SSE },
|
|
{ "SSE2", "sse2", AV_CPU_FLAG_SSE2|AV_CPU_FLAG_SSE2SLOW },
|
|
{ "SSE3", "sse3", AV_CPU_FLAG_SSE3|AV_CPU_FLAG_SSE3SLOW },
|
|
{ "SSSE3", "ssse3", AV_CPU_FLAG_SSSE3|AV_CPU_FLAG_ATOM },
|
|
{ "SSE4.1", "sse4", AV_CPU_FLAG_SSE4 },
|
|
{ "SSE4.2", "sse42", AV_CPU_FLAG_SSE42 },
|
|
{ "AVX", "avx", AV_CPU_FLAG_AVX },
|
|
{ "XOP", "xop", AV_CPU_FLAG_XOP },
|
|
{ "FMA3", "fma3", AV_CPU_FLAG_FMA3 },
|
|
{ "FMA4", "fma4", AV_CPU_FLAG_FMA4 },
|
|
{ "AVX2", "avx2", AV_CPU_FLAG_AVX2 },
|
|
#endif
|
|
{ NULL }
|
|
};
|
|
|
|
typedef struct CheckasmFuncVersion {
|
|
struct CheckasmFuncVersion *next;
|
|
void *func;
|
|
int ok;
|
|
int cpu;
|
|
int iterations;
|
|
uint64_t cycles;
|
|
} CheckasmFuncVersion;
|
|
|
|
/* Binary search tree node */
|
|
typedef struct CheckasmFunc {
|
|
struct CheckasmFunc *child[2];
|
|
CheckasmFuncVersion versions;
|
|
char name[1];
|
|
} CheckasmFunc;
|
|
|
|
/* Internal state */
|
|
static struct {
|
|
CheckasmFunc *funcs;
|
|
CheckasmFunc *current_func;
|
|
CheckasmFuncVersion *current_func_ver;
|
|
const char *current_test_name;
|
|
const char *bench_pattern;
|
|
int bench_pattern_len;
|
|
int num_checked;
|
|
int num_failed;
|
|
int nop_time;
|
|
int cpu_flag;
|
|
const char *cpu_flag_name;
|
|
} state;
|
|
|
|
/* PRNG state */
|
|
AVLFG checkasm_lfg;
|
|
|
|
/* Print colored text to stderr if the terminal supports it */
|
|
static void color_printf(int color, const char *fmt, ...)
|
|
{
|
|
static int use_color = -1;
|
|
va_list arg;
|
|
|
|
#if HAVE_SETCONSOLETEXTATTRIBUTE
|
|
static HANDLE con;
|
|
static WORD org_attributes;
|
|
|
|
if (use_color < 0) {
|
|
CONSOLE_SCREEN_BUFFER_INFO con_info;
|
|
con = GetStdHandle(STD_ERROR_HANDLE);
|
|
if (con && con != INVALID_HANDLE_VALUE && GetConsoleScreenBufferInfo(con, &con_info)) {
|
|
org_attributes = con_info.wAttributes;
|
|
use_color = 1;
|
|
} else
|
|
use_color = 0;
|
|
}
|
|
if (use_color)
|
|
SetConsoleTextAttribute(con, (org_attributes & 0xfff0) | (color & 0x0f));
|
|
#else
|
|
if (use_color < 0) {
|
|
const char *term = getenv("TERM");
|
|
use_color = term && strcmp(term, "dumb") && isatty(2);
|
|
}
|
|
if (use_color)
|
|
fprintf(stderr, "\x1b[%d;3%dm", (color & 0x08) >> 3, color & 0x07);
|
|
#endif
|
|
|
|
va_start(arg, fmt);
|
|
vfprintf(stderr, fmt, arg);
|
|
va_end(arg);
|
|
|
|
if (use_color) {
|
|
#if HAVE_SETCONSOLETEXTATTRIBUTE
|
|
SetConsoleTextAttribute(con, org_attributes);
|
|
#else
|
|
fprintf(stderr, "\x1b[0m");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/* Deallocate a tree */
|
|
static void destroy_func_tree(CheckasmFunc *f)
|
|
{
|
|
if (f) {
|
|
CheckasmFuncVersion *v = f->versions.next;
|
|
while (v) {
|
|
CheckasmFuncVersion *next = v->next;
|
|
free(v);
|
|
v = next;
|
|
}
|
|
|
|
destroy_func_tree(f->child[0]);
|
|
destroy_func_tree(f->child[1]);
|
|
free(f);
|
|
}
|
|
}
|
|
|
|
/* Allocate a zero-initialized block, clean up and exit on failure */
|
|
static void *checkasm_malloc(size_t size)
|
|
{
|
|
void *ptr = calloc(1, size);
|
|
if (!ptr) {
|
|
fprintf(stderr, "checkasm: malloc failed\n");
|
|
destroy_func_tree(state.funcs);
|
|
exit(1);
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
/* Get the suffix of the specified cpu flag */
|
|
static const char *cpu_suffix(int cpu)
|
|
{
|
|
int i = FF_ARRAY_ELEMS(cpus);
|
|
|
|
while (--i >= 0)
|
|
if (cpu & cpus[i].flag)
|
|
return cpus[i].suffix;
|
|
|
|
return "c";
|
|
}
|
|
|
|
#ifdef AV_READ_TIME
|
|
static int cmp_nop(const void *a, const void *b)
|
|
{
|
|
return *(const uint16_t*)a - *(const uint16_t*)b;
|
|
}
|
|
|
|
/* Measure the overhead of the timing code (in decicycles) */
|
|
static int measure_nop_time(void)
|
|
{
|
|
uint16_t nops[10000];
|
|
int i, nop_sum = 0;
|
|
|
|
for (i = 0; i < 10000; i++) {
|
|
uint64_t t = AV_READ_TIME();
|
|
nops[i] = AV_READ_TIME() - t;
|
|
}
|
|
|
|
qsort(nops, 10000, sizeof(uint16_t), cmp_nop);
|
|
for (i = 2500; i < 7500; i++)
|
|
nop_sum += nops[i];
|
|
|
|
return nop_sum / 500;
|
|
}
|
|
|
|
/* Print benchmark results */
|
|
static void print_benchs(CheckasmFunc *f)
|
|
{
|
|
if (f) {
|
|
print_benchs(f->child[0]);
|
|
|
|
/* Only print functions with at least one assembly version */
|
|
if (f->versions.cpu || f->versions.next) {
|
|
CheckasmFuncVersion *v = &f->versions;
|
|
do {
|
|
if (v->iterations) {
|
|
int decicycles = (10*v->cycles/v->iterations - state.nop_time) / 4;
|
|
printf("%s_%s: %d.%d\n", f->name, cpu_suffix(v->cpu), decicycles/10, decicycles%10);
|
|
}
|
|
} while ((v = v->next));
|
|
}
|
|
|
|
print_benchs(f->child[1]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* ASCIIbetical sort except preserving natural order for numbers */
|
|
static int cmp_func_names(const char *a, const char *b)
|
|
{
|
|
int ascii_diff, digit_diff;
|
|
|
|
for (; !(ascii_diff = *a - *b) && *a; a++, b++);
|
|
for (; av_isdigit(*a) && av_isdigit(*b); a++, b++);
|
|
|
|
return (digit_diff = av_isdigit(*a) - av_isdigit(*b)) ? digit_diff : ascii_diff;
|
|
}
|
|
|
|
/* Get a node with the specified name, creating it if it doesn't exist */
|
|
static CheckasmFunc *get_func(const char *name, int length)
|
|
{
|
|
CheckasmFunc *f, **f_ptr = &state.funcs;
|
|
|
|
/* Search the tree for a matching node */
|
|
while ((f = *f_ptr)) {
|
|
int cmp = cmp_func_names(name, f->name);
|
|
if (!cmp)
|
|
return f;
|
|
|
|
f_ptr = &f->child[(cmp > 0)];
|
|
}
|
|
|
|
/* Allocate and insert a new node into the tree */
|
|
f = *f_ptr = checkasm_malloc(sizeof(CheckasmFunc) + length);
|
|
memcpy(f->name, name, length+1);
|
|
|
|
return f;
|
|
}
|
|
|
|
/* Perform tests and benchmarks for the specified cpu flag if supported by the host */
|
|
static void check_cpu_flag(const char *name, int flag)
|
|
{
|
|
int old_cpu_flag = state.cpu_flag;
|
|
|
|
flag |= old_cpu_flag;
|
|
av_set_cpu_flags_mask(flag);
|
|
state.cpu_flag = av_get_cpu_flags();
|
|
|
|
if (!flag || state.cpu_flag != old_cpu_flag) {
|
|
int i;
|
|
|
|
state.cpu_flag_name = name;
|
|
for (i = 0; tests[i].func; i++) {
|
|
state.current_test_name = tests[i].name;
|
|
tests[i].func();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Print the name of the current CPU flag, but only do it once */
|
|
static void print_cpu_name(void)
|
|
{
|
|
if (state.cpu_flag_name) {
|
|
color_printf(COLOR_YELLOW, "%s:\n", state.cpu_flag_name);
|
|
state.cpu_flag_name = NULL;
|
|
}
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int i, seed, ret = 0;
|
|
|
|
if (!tests[0].func || !cpus[0].flag) {
|
|
fprintf(stderr, "checkasm: no tests to perform\n");
|
|
return 0;
|
|
}
|
|
|
|
if (argc > 1 && !strncmp(argv[1], "--bench", 7)) {
|
|
#ifndef AV_READ_TIME
|
|
fprintf(stderr, "checkasm: --bench is not supported on your system\n");
|
|
return 1;
|
|
#endif
|
|
if (argv[1][7] == '=') {
|
|
state.bench_pattern = argv[1] + 8;
|
|
state.bench_pattern_len = strlen(state.bench_pattern);
|
|
} else
|
|
state.bench_pattern = "";
|
|
|
|
argc--;
|
|
argv++;
|
|
}
|
|
|
|
seed = (argc > 1) ? atoi(argv[1]) : av_get_random_seed();
|
|
fprintf(stderr, "checkasm: using random seed %u\n", seed);
|
|
av_lfg_init(&checkasm_lfg, seed);
|
|
|
|
check_cpu_flag(NULL, 0);
|
|
for (i = 0; cpus[i].flag; i++)
|
|
check_cpu_flag(cpus[i].name, cpus[i].flag);
|
|
|
|
if (state.num_failed) {
|
|
fprintf(stderr, "checkasm: %d of %d tests have failed\n", state.num_failed, state.num_checked);
|
|
ret = 1;
|
|
} else {
|
|
fprintf(stderr, "checkasm: all %d tests passed\n", state.num_checked);
|
|
#ifdef AV_READ_TIME
|
|
if (state.bench_pattern) {
|
|
state.nop_time = measure_nop_time();
|
|
printf("nop: %d.%d\n", state.nop_time/10, state.nop_time%10);
|
|
print_benchs(state.funcs);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
destroy_func_tree(state.funcs);
|
|
return ret;
|
|
}
|
|
|
|
/* Decide whether or not the specified function needs to be tested and
|
|
* allocate/initialize data structures if needed. Returns a pointer to a
|
|
* reference function if the function should be tested, otherwise NULL */
|
|
void *checkasm_check_func(void *func, const char *name, ...)
|
|
{
|
|
char name_buf[256];
|
|
void *ref = func;
|
|
CheckasmFuncVersion *v;
|
|
int name_length;
|
|
va_list arg;
|
|
|
|
va_start(arg, name);
|
|
name_length = vsnprintf(name_buf, sizeof(name_buf), name, arg);
|
|
va_end(arg);
|
|
|
|
if (!func || name_length <= 0 || name_length >= sizeof(name_buf))
|
|
return NULL;
|
|
|
|
state.current_func = get_func(name_buf, name_length);
|
|
v = &state.current_func->versions;
|
|
|
|
if (v->func) {
|
|
CheckasmFuncVersion *prev;
|
|
do {
|
|
/* Only test functions that haven't already been tested */
|
|
if (v->func == func)
|
|
return NULL;
|
|
|
|
if (v->ok)
|
|
ref = v->func;
|
|
|
|
prev = v;
|
|
} while ((v = v->next));
|
|
|
|
v = prev->next = checkasm_malloc(sizeof(CheckasmFuncVersion));
|
|
}
|
|
|
|
v->func = func;
|
|
v->ok = 1;
|
|
v->cpu = state.cpu_flag;
|
|
state.current_func_ver = v;
|
|
|
|
if (state.cpu_flag)
|
|
state.num_checked++;
|
|
|
|
return ref;
|
|
}
|
|
|
|
/* Decide whether or not the current function needs to be benchmarked */
|
|
int checkasm_bench_func(void)
|
|
{
|
|
return !state.num_failed && state.bench_pattern &&
|
|
!strncmp(state.current_func->name, state.bench_pattern, state.bench_pattern_len);
|
|
}
|
|
|
|
/* Indicate that the current test has failed */
|
|
void checkasm_fail_func(const char *msg, ...)
|
|
{
|
|
if (state.current_func_ver->cpu && state.current_func_ver->ok) {
|
|
va_list arg;
|
|
|
|
print_cpu_name();
|
|
fprintf(stderr, " %s_%s (", state.current_func->name, cpu_suffix(state.current_func_ver->cpu));
|
|
va_start(arg, msg);
|
|
vfprintf(stderr, msg, arg);
|
|
va_end(arg);
|
|
fprintf(stderr, ")\n");
|
|
|
|
state.current_func_ver->ok = 0;
|
|
state.num_failed++;
|
|
}
|
|
}
|
|
|
|
/* Update benchmark results of the current function */
|
|
void checkasm_update_bench(int iterations, uint64_t cycles)
|
|
{
|
|
state.current_func_ver->iterations += iterations;
|
|
state.current_func_ver->cycles += cycles;
|
|
}
|
|
|
|
/* Print the outcome of all tests performed since the last time this function was called */
|
|
void checkasm_report(const char *name, ...)
|
|
{
|
|
static int prev_checked, prev_failed, max_length;
|
|
|
|
if (state.num_checked > prev_checked) {
|
|
int pad_length = max_length + 4;
|
|
va_list arg;
|
|
|
|
print_cpu_name();
|
|
pad_length -= fprintf(stderr, " - %s.", state.current_test_name);
|
|
va_start(arg, name);
|
|
pad_length -= vfprintf(stderr, name, arg);
|
|
va_end(arg);
|
|
fprintf(stderr, "%*c", FFMAX(pad_length, 0) + 2, '[');
|
|
|
|
if (state.num_failed == prev_failed)
|
|
color_printf(COLOR_GREEN, "OK");
|
|
else
|
|
color_printf(COLOR_RED, "FAILED");
|
|
fprintf(stderr, "]\n");
|
|
|
|
prev_checked = state.num_checked;
|
|
prev_failed = state.num_failed;
|
|
} else if (!state.cpu_flag) {
|
|
/* Calculate the amount of padding required to make the output vertically aligned */
|
|
int length = strlen(state.current_test_name);
|
|
va_list arg;
|
|
|
|
va_start(arg, name);
|
|
length += vsnprintf(NULL, 0, name, arg);
|
|
va_end(arg);
|
|
|
|
if (length > max_length)
|
|
max_length = length;
|
|
}
|
|
}
|