benchmark.h

Go to the documentation of this file.

/*
 * Copyright (c) 2025 Måns Ansgariusson <mansgariusson@gmail.com>
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#ifndef ZTEST_BENCHMARK_H
#define ZTEST_BENCHMARK_H
#include <stdint.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif

/*
 * Identifier builders for the linker-visible symbols that the ZTEST_BENCHMARK*()
 * macros generate. Use when defining a symbol or when taking its reference.
 */
#define Z_ZTEST_BENCHMARK_SUITE_NODE(suite)         z_ztest_benchmark_suite_##suite
#define Z_ZTEST_BENCHMARK_NODE(suite, bench)        z_ztest_benchmark_##suite##_##bench
#define Z_ZTEST_BENCHMARK_TIMED_NODE(suite, bench)  z_ztest_benchmark_timed_##suite##_##bench
#define Z_ZTEST_BENCHMARK_MANUAL_NODE(suite, bench) z_ztest_benchmark_manual_##suite##_##bench
#define Z_ZTEST_BENCHMARK_FN(suite, bench)          z_ztest_benchmark_##suite##_##bench##_fn
 
typedef void (*ztest_benchmark_fn_t)(void);
struct ztest_benchmark_suite {
        const char *name;
        ztest_benchmark_fn_t setup;
        ztest_benchmark_fn_t teardown;
};
 
struct ztest_extreme_value {
        uint64_t value;
        uint64_t sample;
};
 
struct ztest_benchmark_stats {
        double m2;
        double mean;
        uint64_t total;
        uint64_t samples;
        struct ztest_extreme_value min;
        struct ztest_extreme_value max;
        /* First iteration, measured before the steady state is reached. */
        uint64_t cold;
};
 
struct ztest_benchmark {
        const char *name;
        size_t iterations;
        ztest_benchmark_fn_t setup;
        ztest_benchmark_fn_t run;
        ztest_benchmark_fn_t teardown;
        struct ztest_benchmark_stats stats;
        const struct ztest_benchmark_suite *suite;
};
 
struct ztest_benchmark_manual {
        const char *name;
        size_t iterations;
        ztest_benchmark_fn_t setup;
        ztest_benchmark_fn_t run;
        ztest_benchmark_fn_t teardown;
        struct ztest_benchmark_stats stats;
        const struct ztest_benchmark_suite *suite;
};
 
struct ztest_benchmark_timed_stats {
        uint64_t iterations;
        uint64_t duration_cycles;
};
 
struct ztest_benchmark_timed {
        size_t duration_ms;
        const char *name;
        ztest_benchmark_fn_t setup;
        ztest_benchmark_fn_t run;
        ztest_benchmark_fn_t teardown;
        const struct ztest_benchmark_suite *suite;
        struct ztest_benchmark_timed_stats stats;
};
 
void benchmark_main(void);


#define ZTEST_BENCHMARK_SUITE(suite, setup_fn, teardown_fn)                             \
        static const STRUCT_SECTION_ITERABLE(ztest_benchmark_suite,                     \
                                             Z_ZTEST_BENCHMARK_SUITE_NODE(suite)) =     \
        {                                                                               \
                .name = #suite,                                                         \
                .setup = setup_fn,                                                      \
                .teardown = teardown_fn,                                                \
        }

#define ZTEST_BENCHMARK(suite_name, benchmark, samples, setup_fn, teardown_fn)                  \
        static __noinline void Z_ZTEST_BENCHMARK_FN(suite_name, benchmark)(void);               \
        static const STRUCT_SECTION_ITERABLE(ztest_benchmark,                                   \
                                             Z_ZTEST_BENCHMARK_NODE(suite_name, benchmark)) =   \
        {                                                                                       \
                .name = #benchmark,                                                             \
                .iterations = samples,                                                          \
                .setup = setup_fn,                                                              \
                .run = Z_ZTEST_BENCHMARK_FN(suite_name, benchmark),                             \
                .teardown = teardown_fn,                                                        \
                .suite = &Z_ZTEST_BENCHMARK_SUITE_NODE(suite_name),                             \
        };                                                                                      \
        static __noinline void Z_ZTEST_BENCHMARK_FN(suite_name, benchmark)(void)
 

#define ZTEST_BENCHMARK_TIMED(testsuite, benchmark, duration, setup_fn, teardown_fn)            \
        static __noinline void Z_ZTEST_BENCHMARK_FN(testsuite, benchmark)(void);                \
        static const STRUCT_SECTION_ITERABLE(ztest_benchmark_timed,                             \
                                        Z_ZTEST_BENCHMARK_TIMED_NODE(testsuite, benchmark)) =   \
        {                                                                                       \
                .duration_ms = duration,                                                        \
                .name = #benchmark,                                                             \
                .setup = setup_fn,                                                              \
                .run = Z_ZTEST_BENCHMARK_FN(testsuite, benchmark),                              \
                .teardown = teardown_fn,                                                        \
                .suite = &Z_ZTEST_BENCHMARK_SUITE_NODE(testsuite),                              \
        };                                                                                      \
        static __noinline void Z_ZTEST_BENCHMARK_FN(testsuite, benchmark)(void)

#define ZTEST_BENCHMARK_MANUAL(suite_name, benchmark, samples, setup_fn, teardown_fn)           \
        static __noinline void Z_ZTEST_BENCHMARK_FN(suite_name, benchmark)(void);               \
        static STRUCT_SECTION_ITERABLE(ztest_benchmark_manual,                                  \
                                       Z_ZTEST_BENCHMARK_MANUAL_NODE(suite_name, benchmark)) =  \
        {                                                                                       \
                .name = #benchmark,                                                             \
                .iterations = samples,                                                          \
                .setup = setup_fn,                                                              \
                .run = Z_ZTEST_BENCHMARK_FN(suite_name, benchmark),                             \
                .teardown = teardown_fn,                                                        \
                .suite = &Z_ZTEST_BENCHMARK_SUITE_NODE(suite_name),                             \
        };                                                                                      \
        static __noinline void Z_ZTEST_BENCHMARK_FN(suite_name, benchmark)(void)

void ztest_benchmark_start(void);

void ztest_benchmark_end(void);

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZTEST_BENCHMARK_H */