////  PerfStat.h//  libraries/shared/src////  Created by Brad Hefta-Gaub on 3/29/13.//  Copyright 2013 High Fidelity, Inc.////  Poor-man's performance stats collector class. Useful for collecting timing//  details from various portions of the code.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html// #ifndef hifi_PerfStat_h#define hifi_PerfStat_h #include <stdint.h>#include "SharedUtil.h"#include "SimpleMovingAverage.h" #include <atomic>#include <cstring>#include <string>#include <map> using AtomicUIntStat = std::atomic<uintmax_t>; class PerformanceWarning {private:    quint64 _start;    const char* _message;    bool _renderWarningsOn;    bool _alwaysDisplay;    AtomicUIntStat* _runningTotal;    AtomicUIntStat* _totalCalls;    static bool _suppressShortTimings;public:     PerformanceWarning(bool renderWarnings, const char* message, bool alwaysDisplay = false,                       AtomicUIntStat* runningTotal = NULL, AtomicUIntStat* totalCalls = NULL) :        _start(usecTimestampNow()),        _message(message),        _renderWarningsOn(renderWarnings),        _alwaysDisplay(alwaysDisplay),        _runningTotal(runningTotal),        _totalCalls(totalCalls) { }     quint64 elapsed() const { return (usecTimestampNow() - _start); };     ~PerformanceWarning();     static void setSuppressShortTimings(bool suppressShortTimings) { _suppressShortTimings = suppressShortTimings; }}; class PerformanceTimerRecord {public:    PerformanceTimerRecord() : _runningTotal(0), _lastTotal(0), _numAccumulations(0), _numTallies(0), _expiry(0) {}     void accumulateResult(const quint64& elapsed) { _runningTotal += elapsed; ++_numAccumulations; }    void tallyResult(const quint64& now);    bool isStale(const quint64& now) const { return now > _expiry; }    quint64 getAverage() const { return (_numTallies == 0) ? 0 : _runningTotal / _numTallies; }    quint64 getMovingAverage() const { return (_numTallies == 0) ? 0 : _movingAverage.getAverage(); }    quint64 getCount() const { return _numTallies; } private:    quint64 _runningTotal;    quint64 _lastTotal;    quint64 _numAccumulations;    quint64 _numTallies;    quint64 _expiry;    SimpleMovingAverage _movingAverage;}; class PerformanceTimer {public:     PerformanceTimer(const QString& name);    ~PerformanceTimer();     static bool isActive();    static void setActive(bool active);     static QString getContextName();    static void addTimerRecord(const QString& fullName, quint64 elapsedUsec);    static QMap<QString, PerformanceTimerRecord> getAllTimerRecords();    static void tallyAllTimerRecords();    static void dumpAllTimerRecords(); private:    quint64 _start = 0;    QString _name;    static std::atomic<bool> _isActive;     static std::mutex _mutex;  // used to guard multi-threaded access to _fullNames and _records    static QHash<QThread*, QString> _fullNames;    static QMap<QString, PerformanceTimerRecord> _records;}; // uncomment WANT_DETAILED_PERFORMANCE_TIMERS definition to enable performance timers in high-frequency contexts//#define WANT_DETAILED_PERFORMANCE_TIMERS#ifdef WANT_DETAILED_PERFORMANCE_TIMERS    #define DETAILED_PERFORMANCE_TIMER(name) PerformanceTimer detailedPerformanceTimer(name);#else // WANT_DETAILED_PERFORMANCE_TIMERS    #define DETAILED_PERFORMANCE_TIMER(name) ; // no-op#endif // WANT_DETAILED_PERFORMANCE_TIMERS #endif // hifi_PerfStat_h