Profiler.h

Go to the documentation of this file.

#pragma once
 
 
#include "io/Logger.h"
#include "objects/wrappers/Optional.h"
#include "system/Platform.h"
#include "system/Timer.h"
#include <atomic>
#include <map>
#include <thread>
 
NAMESPACE_SPH_BEGIN
 
struct ScopedTimer {
private:
    StoppableTimer impl;
    std::string name;
 
    using OnScopeEnds = std::function<void(const std::string&, const uint64_t)>;
    OnScopeEnds callback;
 
public:
    ScopedTimer(const std::string& name, const OnScopeEnds& callback)
        : name(name)
        , callback(callback) {}
 
    ~ScopedTimer() {
        callback(name, impl.elapsed(TimerUnit::MICROSECOND));
    }
 
    void stop() {
        impl.stop();
    }
 
    void resume() {
        impl.resume();
    }
 
    void next(const std::string& newName) {
        callback(name, impl.elapsed(TimerUnit::MICROSECOND));
        impl.restart();
        name = newName;
    }
};
 
#ifdef SPH_PROFILE
#define MEASURE_SCOPE(name)                                                                                  \
    ScopedTimer __timer("", [](const std::string&, const uint64_t time) {                                    \
        StdOutLogger logger;                                                                                 \
        logger.write(name, " took ", time / 1000, " ms");                                                    \
    });
#define MEASURE(name, what)                                                                                  \
    {                                                                                                        \
        MEASURE_SCOPE(name);                                                                                 \
        what;                                                                                                \
    }
#else
#define MEASURE_SCOPE(name)
#define MEASURE(name, what) what
#endif
 
#ifdef SPH_PROFILE
 
struct ScopeStatistics {
    std::string name;
 
    uint64_t totalTime;
 
    Float relativeTime;
 
    Float cpuUsage;
};
 
 
class Profiler : public Noncopyable {
private:
    static AutoPtr<Profiler> instance;
 
    struct ScopeRecord {
        std::atomic<uint64_t> duration{ 0 };
 
        Float cpuUsage = 0._f;
 
        Size weight = 0;
    };
 
    // map of profiled scopes, its key being a string = name of the scope
    std::map<std::string, ScopeRecord> records;
 
    struct {
        std::string currentScope;
        std::thread thread;
    } cpuUsage;
 
    std::atomic_bool quitting{ false };
 
public:
    Profiler() {
        cpuUsage.thread = std::thread([this] {
            while (!quitting) {
                const Optional<Float> usage = getCpuUsage();
                if (usage && !cpuUsage.currentScope.empty()) {
                    ScopeRecord& scope = records[cpuUsage.currentScope];
                    scope.cpuUsage = (scope.cpuUsage * scope.weight + usage.value()) / (scope.weight + 1);
                    scope.weight++;
                }
                std::this_thread::sleep_for(std::chrono::milliseconds(20));
            }
        });
    }
 
    ~Profiler() {
        quitting = true;
        cpuUsage.thread.join();
    }
 
    static Profiler& getInstance() {
        if (!instance) {
            instance = makeAuto<Profiler>();
        }
        return *instance;
    }
 
    ScopedTimer makeScopedTimer(const std::string& name) {
        cpuUsage.currentScope = name;
        return ScopedTimer(name, [this](const std::string& n, const uint64_t elapsed) { //
            records[n].duration += elapsed;
        });
    }
 
    Array<ScopeStatistics> getStatistics() const;
 
    void printStatistics(ILogger& logger) const;
 
    void clear() {
        records.clear();
    }
};
 
#define PROFILE_SCOPE(name)                                                                                  \
    Profiler& __instance = Profiler::getInstance();                                                          \
    ScopedTimer __scopedTimer = __instance.makeScopedTimer(name);
#define PROFILE(name, what)                                                                                  \
    {                                                                                                        \
        PROFILE_SCOPE(name);                                                                                 \
        what;                                                                                                \
    }
#else
#define PROFILE_SCOPE(name)
#define PROFILE(name, what) what
#endif
 
NAMESPACE_SPH_END