benchmark.h

Go to the documentation of this file.

#ifndef DBALLE_CORE_BENCHMARK_H
#define DBALLE_CORE_BENCHMARK_H

#include <cstdio>
#include <dballe/file.h>
#include <dballe/message.h>
#include <functional>
#include <memory>
#include <string>
#include <sys/resource.h>
#include <sys/time.h>
#include <time.h>
#include <vector>

namespace dballe {
namespace benchmark {

struct Benchmark;

struct Task
{
    Task() {}
    Task(const Task&) = delete;
    Task(Task&&)      = delete;
    virtual ~Task() {}
    Task& operator=(const Task&) = delete;
    Task& operator=(Task&&)      = delete;

    virtual const char* name() const = 0;

    virtual void setup() {}

    virtual void run_once() = 0;

    virtual void teardown() {}
};

struct Progress;

struct Timeit
{
    std::string task_name;
    unsigned repetitions = 1;
    struct timespec time_at_start;
    struct timespec time_at_end;
    struct rusage res_at_start;
    struct rusage res_at_end;

    void run(Progress& progress, Task& task);
};

struct Throughput
{
    std::string task_name;
    double run_time    = 0.5;
    unsigned times_run = 0;

    void run(Progress& progress, Task& task);
};

struct Progress
{
    virtual ~Progress() {}

    virtual void start_timeit(const Timeit& t) = 0;
    virtual void end_timeit(const Timeit& t)   = 0;

    virtual void start_throughput(const Throughput& t) = 0;
    virtual void end_throughput(const Throughput& t)   = 0;

    virtual void test_failed(const Task& t, std::exception& e) = 0;
};

struct BasicProgress : Progress
{
    FILE* out;
    FILE* err;

    BasicProgress(FILE* out = stdout, FILE* err = stderr);

    void start_timeit(const Timeit& t) override;
    void end_timeit(const Timeit& t) override;

    void start_throughput(const Throughput& t) override;
    void end_throughput(const Throughput& t) override;

    void test_failed(const Task& t, std::exception& e) override;
};

struct Benchmark
{
    std::shared_ptr<Progress> progress;

    std::vector<Timeit> timeit_tasks;

    std::vector<Throughput> throughput_tasks;

    Benchmark();
    virtual ~Benchmark();

    void timeit(Task& task, unsigned repetitions = 1);

    void throughput(Task& task, double run_time = 0.5);

    void print_timings();
};

struct Messages
    : public std::vector<std::vector<std::shared_ptr<dballe::Message>>>
{
    void load(const std::string& pathname,
              dballe::Encoding encoding = dballe::Encoding::BUFR,
              const char* codec_options = "accurate");

    // Copy the first \a size messages, change their datetime, and append them
    // to the vector
    void duplicate(size_t size, const Datetime& datetime);
};

struct Whitelist : protected std::vector<std::string>
{
    Whitelist(int argc, const char* argv[]);

    bool has(const std::string& val);
};

} // namespace benchmark
} // namespace dballe

#endif