test.h

Go to the documentation of this file.

/*
 * Copyright © 2025, Niklas Haas
 * Copyright © 2018, VideoLAN and dav1d authors
 * Copyright © 2018, Two Orioles, LLC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 
#ifndef CHECKASM_TEST_H
#define CHECKASM_TEST_H
 
#include <stdint.h>
 
#include "checkasm/attributes.h"
#include "checkasm/checkasm.h"
#include "checkasm/perf.h"
#include "checkasm/platform.h"

#define checkasm_check_func(func, ...)                                                   \
    (checkasm_key_ref                                                                    \
     = checkasm_check_key((checkasm_key_new = (CheckasmKey) (func)), __VA_ARGS__))

CHECKASM_API CheckasmKey checkasm_check_key(CheckasmKey key, const char *name, ...)
    CHECKASM_PRINTF(2, 3);

CHECKASM_API void checkasm_set_func_variant(const char *id, ...) CHECKASM_PRINTF(1, 2);

CHECKASM_API int checkasm_fail_func(const char *msg, ...) CHECKASM_PRINTF(1, 2);

#define checkasm_fail() checkasm_fail_func("%s:%d", __FILE__, __LINE__)

CHECKASM_API void checkasm_report(const char *name, ...) CHECKASM_PRINTF(1, 2);

#define checkasm_declare(ret, ...)                                                       \
    checkasm_declare_impl(ret, __VA_ARGS__);                                             \
    typedef ret func_type(__VA_ARGS__);                                                  \
    (void) ((func_type *) NULL)

#ifndef checkasm_declare_emms
  #define checkasm_declare_emms(cpu_flags, ret, ...) checkasm_declare(ret, __VA_ARGS__)
#endif

#define checkasm_call(func, ...)                                                         \
    (checkasm_set_signal_handler_state(1), (func) (__VA_ARGS__));                        \
    checkasm_clear_cpu_state();                                                          \
    checkasm_set_signal_handler_state(0)

#ifndef checkasm_call_checked
  #define checkasm_call_checked(func, ...)                                               \
      (checkasm_set_signal_handler_state(1),                                             \
       checkasm_push_stack_guard((uintptr_t[16]) { 0, 0 }),                              \
       ((func_type *) (func))(__VA_ARGS__));                                             \
      checkasm_pop_stack_guard();                                                        \
      checkasm_set_signal_handler_state(0)
#endif

CHECKASM_API int checkasm_should_fail(CheckasmCpu cpu_flags);

static CheckasmKey checkasm_key_ref;

static CheckasmKey checkasm_key_new;

#define checkasm_func_ref ((func_type *) checkasm_key_ref)

#define checkasm_func_new ((func_type *) checkasm_key_new)

#define checkasm_call_ref(...) checkasm_call(checkasm_func_ref, __VA_ARGS__)

#define checkasm_call_new(...) checkasm_call_checked(checkasm_func_new, __VA_ARGS__)

#define checkasm_bench(func, ...)                                                        \
    do {                                                                                 \
        if (checkasm_bench_func()) {                                                     \
            func_type *const bench_func = (func);                                        \
            checkasm_set_signal_handler_state(1);                                        \
            for (int truns; (truns = checkasm_bench_runs());) {                          \
                uint64_t time;                                                           \
                CHECKASM_PERF_BENCH(truns, time, __VA_ARGS__);                           \
                checkasm_clear_cpu_state();                                              \
                checkasm_bench_update(truns, time);                                      \
            }                                                                            \
            checkasm_set_signal_handler_state(0);                                        \
            checkasm_bench_finish();                                                     \
        } else {                                                                         \
            const int tidx = 0;                                                          \
            (void) tidx;                                                                 \
            checkasm_call_checked(func, __VA_ARGS__);                                    \
        }                                                                                \
    } while (0)

#define checkasm_bench_new(...) checkasm_bench(checkasm_func_new, __VA_ARGS__)

#define checkasm_alternate(a, b) ((tidx & 1) ? (b) : (a))

#define fail              checkasm_fail
#define report            checkasm_report
#define check_func        checkasm_check_func
#define check_key         checkasm_check_key
#define func_ref          checkasm_func_ref
#define func_new          checkasm_func_new
#define call_ref          checkasm_call_ref
#define call_new          checkasm_call_new
#define bench_new         checkasm_bench_new
#define alternate         checkasm_alternate
#define declare_func      checkasm_declare
#define declare_func_emms checkasm_declare_emms


CHECKASM_API void checkasm_set_signal_handler_state(int enabled);

CHECKASM_API void checkasm_push_stack_guard(uintptr_t guard[2]);
CHECKASM_API void checkasm_pop_stack_guard(void);

#ifndef checkasm_clear_cpu_state
  #define checkasm_clear_cpu_state()                                                     \
      do {                                                                               \
      } while (0)
#endif
 
typedef struct CheckasmPerf {
    uint64_t (*start)(void);

    uint64_t (*stop)(uint64_t start_time);

    const char *name;

    const char *unit;
 
#ifdef CHECKASM_PERF_ASM
    int asm_usable;
#endif
} CheckasmPerf;
 
#define CHECKASM_PERF_CALL4(...)                                                         \
    do {                                                                                 \
        int tidx = 0;                                                                    \
        bench_func(__VA_ARGS__);                                                         \
        tidx = 1;                                                                        \
        bench_func(__VA_ARGS__);                                                         \
        tidx = 2;                                                                        \
        bench_func(__VA_ARGS__);                                                         \
        tidx = 3;                                                                        \
        bench_func(__VA_ARGS__);                                                         \
        (void) tidx;                                                                     \
    } while (0)
 
#define CHECKASM_PERF_CALL16(...)                                                        \
    do {                                                                                 \
        CHECKASM_PERF_CALL4(__VA_ARGS__);                                                \
        CHECKASM_PERF_CALL4(__VA_ARGS__);                                                \
        CHECKASM_PERF_CALL4(__VA_ARGS__);                                                \
        CHECKASM_PERF_CALL4(__VA_ARGS__);                                                \
    } while (0)
 
/* Naive loop; used when perf.start/stop() is expected to be slow or imprecise, or when
 * we have no ASM cycle counters, or when the number of iterations is low */
#define CHECKASM_PERF_BENCH_SIMPLE(count, time, ...)                                     \
    do {                                                                                 \
        time = perf.start();                                                             \
        for (int tidx = 0; tidx < count; tidx++)                                         \
            bench_func(__VA_ARGS__);                                                     \
        time = perf.stop(time);                                                          \
    } while (0)
 
/* Unrolled loop with inline outlier rejection; used when we have asm cycle counters */
#define CHECKASM_PERF_BENCH_ASM(total_count, time, ...)                                  \
    do {                                                                                 \
        int      tcount_trim = 0;                                                        \
        uint64_t tsum_trim   = 0;                                                        \
        for (int titer = 0; titer < total_count; titer += 32) {                          \
            uint64_t t = CHECKASM_PERF_ASM();                                            \
            CHECKASM_PERF_CALL16(__VA_ARGS__);                                           \
            CHECKASM_PERF_CALL16(__VA_ARGS__);                                           \
            t = CHECKASM_PERF_ASM() - t;                                                 \
            if (t * tcount_trim <= tsum_trim * 4 && (titer > 0 || total_count < 1000)) { \
                tsum_trim += t;                                                          \
                tcount_trim++;                                                           \
            }                                                                            \
        }                                                                                \
        time        = tsum_trim;                                                         \
        total_count = tcount_trim << 5;                                                  \
    } while (0)
 
/* Select the best benchmarking method at runtime */
CHECKASM_API const CheckasmPerf *checkasm_get_perf(void);
 
#ifdef CHECKASM_PERF_ASM
  #ifndef CHECKASM_PERF_ASM_USABLE
    #define CHECKASM_PERF_ASM_USABLE perf.asm_usable
  #endif
  #define CHECKASM_PERF_BENCH(count, time, ...)                                          \
      do {                                                                               \
          const CheckasmPerf perf = *checkasm_get_perf();                                \
          if (CHECKASM_PERF_ASM_USABLE && count >= 128) {                                \
              CHECKASM_PERF_BENCH_ASM(count, time, __VA_ARGS__);                         \
          } else {                                                                       \
              CHECKASM_PERF_BENCH_SIMPLE(count, time, __VA_ARGS__);                      \
          }                                                                              \
      } while (0)
#else /* !CHECKASM_PERF_ASM */
  #define CHECKASM_PERF_BENCH(count, time, ...)                                          \
      do {                                                                               \
          const CheckasmPerf perf = *checkasm_get_perf();                                \
          CHECKASM_PERF_BENCH_SIMPLE(count, time, __VA_ARGS__);                          \
      } while (0)
#endif

CHECKASM_API int checkasm_bench_func(void);

CHECKASM_API int checkasm_bench_runs(void);

CHECKASM_API void checkasm_bench_update(int iterations, uint64_t cycles);

CHECKASM_API void checkasm_bench_finish(void);

static inline void checkasm_unused(void)
{
    (void) checkasm_key_ref;
    (void) checkasm_key_new;
}
 /* internal */
 
#endif /* CHECKASM_TEST_H */