profiler.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
 
#include <hilti/rt/configuration.h>
#include <hilti/rt/global-state.h>
#include <hilti/rt/profiler-state.h>
 
namespace hilti::rt {
 
class Profiler;
 
namespace profiler {
 
std::optional<Profiler> start(std::string_view name, std::optional<uint64_t> volume = std::nullopt);
void stop(std::optional<Profiler>& p, std::optional<uint64_t> volume = std::nullopt);
 
namespace detail {
 
// Internal initialization function, called from library's `init()` when
// profiling has been requested.
extern void init();
 
// Internal shutdown function, called from library's `done()`. Produces a final
// profiling report.
extern void done();
 
} // namespace detail
} // namespace profiler
 
class Profiler {
public:
    Profiler() = default;
 
    Profiler(const Profiler& other) = delete;
    Profiler(Profiler&& other) = default;
 
    ~Profiler() { record(snapshot()); }
 
    Profiler& operator=(const Profiler& other) = delete;
    Profiler& operator=(Profiler&& other) = default;
 
    void record(const profiler::Measurement& end);
 
    operator bool() const { return ! _name.empty(); }
 
    static profiler::Measurement snapshot(std::optional<uint64_t> volume = std::nullopt);
 
protected:
    Profiler(std::string_view name, std::optional<uint64_t> volume) : _name(name), _start(snapshot(volume)) {
        _register();
    }
 
private:
    friend std::optional<Profiler> profiler::start(std::string_view name, std::optional<uint64_t> volume);
    friend void profiler::detail::done();
 
    void _register() const;
 
    std::string _name;            // Name of block to profile; empty is not active.
    profiler::Measurement _start; // Initial measurement at construction time.
};
 
namespace profiler {
inline std::optional<Profiler> start(std::string_view name, std::optional<uint64_t> volume) {
    if ( ::hilti::rt::detail::unsafeGlobalState()->profiling_enabled )
        return Profiler(name, volume);
    else
        return {};
}
 
inline void stop(std::optional<Profiler>& p, std::optional<uint64_t> volume) {
    if ( p )
        p->record(Profiler::snapshot(volume));
}
 
std::optional<Measurement> get(const std::string& name);
 
extern void report();
 
} // namespace profiler
} // namespace hilti::rt