kis_latency_tracker.h

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2017 Bernhard Liebl <poke1024@gmx.de>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#ifndef KRITA_KIS_SCALAR_TRACKER_H
#define KRITA_KIS_SCALAR_TRACKER_H
 
#include "kis_shared.h"
#include <kritaglobal_export.h>
 
#include <QQueue>
#include <QElapsedTimer>
#include <QDebug>
 
#include <boost/heap/fibonacci_heap.hpp>
 
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/rolling_mean.hpp>
#include <boost/accumulators/statistics/rolling_variance.hpp>
 
template<typename T>
class KisRollingMax {
public:
    KisRollingMax(int windowSize) : m_windowSize(windowSize) {
    }
 
    void push(T value) {
        while (m_samples.size() > m_windowSize) {
            m_values.erase(m_samples.dequeue());
        }
 
        m_samples.enqueue(m_values.push(value));
    }
 
    T max() const {
        if (m_values.empty()) {
            throw std::runtime_error("no values to get max of");
        } else {
            return m_values.top();
        }
    }
 
private:
    const int m_windowSize;
 
    typedef boost::heap::fibonacci_heap<T> heap_type;
 
    QQueue<typename heap_type::handle_type> m_samples;
    heap_type m_values;
};
 
template<typename T>
class KisScalarTracker : public KisShared {
public:
    KisScalarTracker(const QString &name, int windowSize = 500) :
        m_name(name),
        m_windowSize(windowSize),
        m_addCount(0),
        m_max(windowSize),
        m_acc(boost::accumulators::tag::rolling_window::window_size = windowSize)
    {
        m_printTimer.start();
    }
 
    virtual ~KisScalarTracker() {
    }
 
    virtual void push(T value) {
        m_max.push(value);
        m_acc(value);
        m_addCount++;
 
        if (m_addCount >= m_windowSize || m_printTimer.elapsed() >= 1000) {
            m_printTimer.restart();
            QString s = format(boost::accumulators::rolling_mean(m_acc),
                  boost::accumulators::rolling_variance(m_acc),
                  m_max.max());
            print(s);
            m_addCount = 0;
        }
 
    }
 
protected:
    virtual void print(const QString &message) {
        qInfo() << qUtf8Printable(message);
    }
 
    virtual QString format(qint64 mean, qint64 variance, qint64 max) {
        return QString("%1: mean %2 ms, var %3, max %4 ms").arg(m_name).arg(mean).arg(variance).arg(max);
    }
 
private:
    const QString m_name;
    const int m_windowSize;
    int m_addCount;
 
    QElapsedTimer m_printTimer;
 
    KisRollingMax<T> m_max;
 
    // see https://svn.boost.org/trac10/ticket/11437
    typedef boost::accumulators::stats<
        boost::accumulators::tag::lazy_rolling_mean,
        boost::accumulators::tag::rolling_variance> stats;
 
    boost::accumulators::accumulator_set<T, stats> m_acc;
};
 
class KRITAGLOBAL_EXPORT KisLatencyTracker : public KisScalarTracker<qint64> {
public:
    KisLatencyTracker(int windowSize = 500);
 
    virtual void push(qint64 timestamp) override;
 
protected:
    virtual qint64 currentTimestamp() const = 0;
};
 
#endif //KRITA_KIS_SCALAR_TRACKER_H