benchmark.cpp

#include <iostream>
#include <iomanip>
#include <pico/divider.h>
#include "fpm/fixed.hpp"
// from https://github.com/JoelFilho/EMB
#include "emb.hpp"
#include "smartdevice/Debug.hpp"

#pragma GCC optimize("O3")

#define DECL_BENCH(suffix, conversion, count) \
template<typename State> \
void benchmark_conv_ ## suffix(State &s) { \
    for (auto _: s) { \
        for (int i = 0; i < count; i++) \
            emb::dontOptimize(conversion(i)); \
    } \
} \
template<typename State> \
void benchmark_div_ ## suffix(State &s) { \
    for (auto _: s) { \
        for (int i = 0; i < count; i++) \
            emb::dontOptimize(1/conversion(i)); \
    } \
} \
template<typename State> \
void benchmark_mul_ ## suffix(State &s) { \
    for (auto _: s) {                         \
    static auto s = conversion(5454.13249); \
        for (int i = 0; i < count; i++) \
            emb::dontOptimize(conversion(i)*s); \
    } \
} \
template<typename State> \
void benchmark_add_ ## suffix(State &s) { \
    for (auto _: s) {                         \
    static auto s = conversion(5454.13249); \
        for (int i = 0; i < count; i++)       \
            emb::dontOptimize(conversion(i)+s); \
    } \
}
#define RUN_BENCH(suffix) \
    EMB_MAKE_BENCHMARK(benchmarker, benchmark_conv_ ## suffix); \
    EMB_MAKE_BENCHMARK(benchmarker, benchmark_div_ ## suffix);  \
    EMB_MAKE_BENCHMARK(benchmarker, benchmark_mul_ ## suffix);  \
    EMB_MAKE_BENCHMARK(benchmarker, benchmark_add_ ## suffix);

typedef fpm::fixed<int16_t, int32_t, 8> fixed_8_8;

DECL_BENCH(i8, int8_t, 10000)
DECL_BENCH(i16, int16_t, 10000)
DECL_BENCH(i32, int32_t, 10000)
DECL_BENCH(i64, int64_t, 10000)
DECL_BENCH(f, float, 1000)
DECL_BENCH(d, double, 1000)
DECL_BENCH(fgg, fpm::fixed_16_16::from_raw_value, 10000)
DECL_BENCH(f88, fixed_8_8::from_raw_value, 10000)

template<typename State>
void benchmark_hdiv_i32(State &s) {
    for (auto _: s) {
        for (int i = 0; i < 10000; i++)
            emb::dontOptimize(div_s32s32(1, int32_t(i)));
    }
}
template<typename State>
void benchmark_hdiv_i64(State &s) {
    for (auto _: s) {
        for (int i = 0; i < 10000; i++)
            emb::dontOptimize(div_s64s64(1, i));
    }
}
template<typename State>
void benchmark_uhdiv_i32(State &s) {
    for (auto _: s) {
        for (int i = 0; i < 10000; i++)
            emb::dontOptimize(hw_divider_s32_quotient_inlined(1, int32_t(i)));
    }
}

struct Reporter {
    template<typename Accumulator>
    static void report(const char *name, size_t iterations, Accumulator mean, Accumulator sd) {
        std::cout << std::setw(20)
                  << name << '\t'
                  << iterations << '\t'
                  << mean << "us\t"
                  << sd << "us\n";
    }
};

struct cpu_timer {
    static int64_t now() {
        return time_us_64();
    }
};

using Benchmarker = emb::Benchmarker<cpu_timer>;

[[noreturn]] int main() {
    Debug::init();
    sleep_ms(3000);
    std::cout << "Benchmarking...\n";
    Benchmarker benchmarker(1000);
    EMB_MAKE_BENCHMARK(benchmarker, benchmark_hdiv_i32)
    EMB_MAKE_BENCHMARK(benchmarker, benchmark_hdiv_i64)
    EMB_MAKE_BENCHMARK(benchmarker, benchmark_uhdiv_i32)
    RUN_BENCH(i8)
    RUN_BENCH(i16)
    RUN_BENCH(i32)
    RUN_BENCH(i64)
    RUN_BENCH(f)
    RUN_BENCH(d)
    RUN_BENCH(fgg)
    RUN_BENCH(f88)
    benchmarker.runBenchmarks<Reporter>();
    std::cout << "Done :D\n";
}

results-rp2040.csv