benchmark.h

Go to the documentation of this file.

#ifndef WREPORT_BENCHMARK_H
#define WREPORT_BENCHMARK_H
 
#include <string>
#include <vector>
#include <functional>
#include <cstdio>
 
namespace wreport {
namespace benchmark {
 
struct Benchmark;
 
struct Task
{
    // Unmanaged pointer to the benchmark we belong to
    Benchmark* parent;
    // Name of this task
    std::string name;
    // Number of time this task has run
    unsigned run_count = 0;
    // Total user time
    clock_t utime = 0;
    // Total system time
    clock_t stime = 0;
 
    Task(Benchmark* parent, const std::string& name);
 
    // Run the given function and collect timings for it
    void collect(std::function<void()> f);
};
 
 
struct Progress
{
    virtual ~Progress() {}
 
    virtual void start_benchmark(const Benchmark& b) = 0;
    virtual void end_benchmark(const Benchmark& b) = 0;
    virtual void start_iteration(const Benchmark& b, unsigned cur, unsigned total) = 0;
    virtual void end_iteration(const Benchmark& b, unsigned cur, unsigned total) = 0;
    virtual void test_failed(const Benchmark& b, std::exception& e) = 0;
};
 
 
struct BasicProgress : Progress
{
    FILE* out;
    FILE* err;
 
    BasicProgress(FILE* out=stdout, FILE* err=stderr);
 
    void start_benchmark(const Benchmark& b) override;
    void start_iteration(const Benchmark& b, unsigned cur, unsigned total) override;
    void end_iteration(const Benchmark& b, unsigned cur, unsigned total) override;
    void end_benchmark(const Benchmark& b) override;
    void test_failed(const Benchmark& b, std::exception& e) override;
};
 
 
struct Benchmark
{
    // Name of this benchmark
    std::string name;
    // Number of repetitions
    unsigned repetitions = 10;
    // Unmanaged pointers to the tasks in this benchmark
    std::vector<Task*> tasks;
    // Main task, collecting timings for the toplevel run
    Task task_main;
 
    Benchmark(const std::string& name);
    virtual ~Benchmark();
 
    virtual void setup_main() {}
 
    virtual void teardown_main() {}
 
    virtual void setup_iteration() {}
 
    virtual void teardown_iteration() {}
 
    void run(Progress& progress);
 
    void print_timings();
 
    virtual void main() = 0;
};
 
struct Registry
{
    std::vector<Benchmark*> benchmarks;
 
    void add(Benchmark* b);
 
    static Registry& get();
 
    static void basic_run(int argc, const char* argv[]);
};
 
}
}
 
#endif