tracktion_PerformanceMeasurement.h

Go to the documentation of this file.

 /*==============================================================================
 
  Copyright 2016 by Tracktion Corporation.
  For more information visit www.tracktion.com
 
 ==============================================================================*/
 
#pragma once
 
#include <string>
#include <chrono>
#include <iostream>
 
#ifdef __APPLE__
 #include <sys/kdebug_signpost.h>
 #include <os/signpost.h>
#endif
 
#include "../../tracktion_core/utilities/tracktion_CPU.h"
 
namespace tracktion { inline namespace graph
{
 
//==============================================================================
//==============================================================================
struct ScopedSignpost
{
    ScopedSignpost (uint32_t signpostIndex)
        : index (signpostIndex)
    {
        (void) index;
       #ifdef __APPLE__
        #pragma clang diagnostic push
        #pragma clang diagnostic ignored "-Wdeprecated"
        kdebug_signpost_start (index, 0, 0, 0, 0);
        #pragma clang diagnostic pop
       #endif
    }
 
    ~ScopedSignpost()
    {
       #ifdef __APPLE__
        #pragma clang diagnostic push
        #pragma clang diagnostic ignored "-Wdeprecated"
        kdebug_signpost_end (index, 0, 0, 0, 0);
        #pragma clang diagnostic pop
       #endif
    }
 
private:
    //==============================================================================
    const uint32_t index;
};
 
 
#ifdef __APPLE__
//==============================================================================
//==============================================================================
struct NamedSignpost
{
    NamedSignpost (const char* nameToUse)
        : name (nameToUse)
    {
       #ifdef __APPLE__
        if (__builtin_available (macOS 10.14, *))
            os_signpost_interval_begin (getLog(), id, "", "%s", name);
       #endif
    }
 
    ~NamedSignpost()
    {
       #ifdef __APPLE__
        if (__builtin_available (macOS 10.14, *))
            os_signpost_interval_end (getLog(), id, "", "%s", name);
       #endif
    }
 
private:
    [[ maybe_unused ]] const char* name;
   #ifdef __APPLE__
    const os_signpost_id_t id  { generateID() };
 
    static os_log_t getLog()
    {
        static os_log_t log;
 
        if (__builtin_available (macOS 10.14, *))
            if (log == nullptr)
                log = os_log_create ("", OS_LOG_CATEGORY_POINTS_OF_INTEREST);
 
        return log;
    }
 
    static os_signpost_id_t generateID()
    {
        if (__builtin_available (macOS 10.14, *))
            return os_signpost_id_generate (getLog());
 
        return {};
    }
   #endif
};
#endif //__APPLE__
 
 
//==============================================================================
//==============================================================================
class PerformanceMeasurement
{
public:
    //==============================================================================
    PerformanceMeasurement (std::string counterName,
                            int runsPerPrintout = 100,
                            bool printOnDestruction = true);
 
    ~PerformanceMeasurement();
 
    //==============================================================================
    void start() noexcept;
 
    bool stop();
 
    void printStatistics();
 
    struct Statistics
    {
        Statistics() noexcept = default;
 
        void clear() noexcept;
        double getVarianceSeconds() const;
        double getVarianceCycles() const;
        std::string toString (const std::string& name) const;
 
        void addResult (double secondsElapsed, uint64_t cyclesElapsed) noexcept;
 
        double meanSeconds      = 0.0;
        double m2Seconds        = 0.0;
        double maximumSeconds   = 0.0;
        double minimumSeconds   = 0.0;
        double totalSeconds     = 0.0;
 
        double meanCycles       = 0.0;
        double m2Cycles         = 0.0;
        uint64_t maximumCycles  = 0;
        uint64_t minimumCycles  = 0;
        uint64_t totalCycles    = 0;
 
        int64_t numRuns = 0;
    };
 
    std::string getName() const;
 
    Statistics getStatistics() const;
 
    Statistics getStatisticsAndReset();
 
private:
    //==============================================================================
    Statistics stats;
    std::string name;
    int64_t runsPerPrint;
    bool printOnDestruction;
    std::chrono::time_point<std::chrono::high_resolution_clock> startTime;
    uint64_t startCycles;
};
 
//==============================================================================
//==============================================================================
class ScopedPerformanceMeasurement
{
public:
    ScopedPerformanceMeasurement (PerformanceMeasurement& pm)
        : performanceMeasurement (pm)
    {
        performanceMeasurement.start();
    }
 
    ~ScopedPerformanceMeasurement()
    {
        performanceMeasurement.stop();
    }
 
    PerformanceMeasurement& performanceMeasurement;
};
 
 
//==============================================================================
//        _        _           _  _
//     __| |  ___ | |_   __ _ (_)| | ___
//    / _` | / _ \| __| / _` || || |/ __|
//   | (_| ||  __/| |_ | (_| || || |\__ \ _  _  _
//    \__,_| \___| \__| \__,_||_||_||___/(_)(_)(_)
//
//   Code beyond this point is implementation detail...
//
//==============================================================================
 
inline PerformanceMeasurement::PerformanceMeasurement (std::string name_, int runsPerPrintout, bool shouldPrintOnDestruction)
    : name (std::move (name_)), runsPerPrint (runsPerPrintout), printOnDestruction (shouldPrintOnDestruction)
{
}
 
inline PerformanceMeasurement::~PerformanceMeasurement()
{
    if (printOnDestruction && stats.numRuns > 0)
        printStatistics();
}
 
inline void PerformanceMeasurement::Statistics::clear() noexcept
{
    meanSeconds = m2Seconds = maximumSeconds = minimumSeconds = totalSeconds = 0;
    meanCycles = m2Cycles = 0.0;
    maximumCycles = minimumCycles = totalCycles = 0;
    numRuns = 0;
}
 
inline void PerformanceMeasurement::Statistics::addResult (double secondsElapsed, uint64_t cyclesElapsed) noexcept
{
    if (numRuns == 0)
    {
        maximumSeconds = secondsElapsed;
        minimumSeconds = secondsElapsed;
 
        maximumCycles = cyclesElapsed;
        minimumCycles = cyclesElapsed;
    }
    else
    {
        maximumSeconds = std::max (maximumSeconds, secondsElapsed);
        minimumSeconds = std::min (minimumSeconds, secondsElapsed);
 
        maximumCycles = std::max (maximumCycles, cyclesElapsed);
        minimumCycles = std::min (minimumCycles, cyclesElapsed);
    }
 
    ++numRuns;
    totalSeconds += secondsElapsed;
    totalCycles += cyclesElapsed;
 
    // Seconds
    {
        const double delta = secondsElapsed - meanSeconds;
        meanSeconds += delta / (double) numRuns;
        const double delta2 = secondsElapsed - meanSeconds;
        m2Seconds += delta * delta2;
    }
 
    // Cycles
    {
        const auto delta = cyclesElapsed - meanCycles;
        meanCycles += delta / (double) numRuns;
        const double delta2 = cyclesElapsed - meanCycles;
        m2Cycles += delta * delta2;
    }
}
 
inline double PerformanceMeasurement::Statistics::getVarianceSeconds() const
{
    return numRuns > 0 ? (m2Seconds / (double) numRuns) : 0.0;
}
 
inline double PerformanceMeasurement::Statistics::getVarianceCycles() const
{
    return numRuns > 0 ? (m2Cycles / (double) numRuns) : 0.0;
}
 
inline std::string PerformanceMeasurement::Statistics::toString (const std::string& perfName) const
{
    auto timeToString = [] (double secs)
    {
        return std::to_string ((int64_t) (secs * (secs < 0.01 ? 1000000.0 : 1000.0) + 0.5))
                + (secs < 0.01 ? " us" : " ms");
    };
 
    std::string s = "Performance count for \"" + perfName + "\" over " + std::to_string (numRuns) + " run(s)\n"
                    + "\t Seconds: Mean = " + timeToString (meanSeconds)
                    + ", min = "            + timeToString (minimumSeconds)
                    + ", max = "            + timeToString (maximumSeconds)
                    + ", SD = "             + timeToString (std::sqrt (getVarianceSeconds()))
                    + ", total = "          + timeToString (totalSeconds) + "\n"
                    + "\t Cycles: Mean = "  + std::to_string (meanCycles)
                    + ", min = "            + std::to_string (minimumCycles)
                    + ", max = "            + std::to_string (maximumCycles)
                    + ", SD = "             + std::to_string (std::sqrt (getVarianceCycles()))
                    + ", total = "          + std::to_string (totalCycles) + "\n";
 
    return s;
}
 
inline void PerformanceMeasurement::start() noexcept
{
    startTime = std::chrono::high_resolution_clock::now();
    startCycles = rdtsc();
}
 
inline bool PerformanceMeasurement::stop()
{
    const auto elapsedSeconds = std::chrono::high_resolution_clock::now() - startTime;
    const auto elapsedCycles = rdtsc() - startCycles;
    stats.addResult (std::chrono::duration<double, std::ratio<1, 1>> (elapsedSeconds).count(),
                     elapsedCycles);
 
    if (runsPerPrint < 0)
        return false;
 
    if (stats.numRuns < runsPerPrint)
        return false;
 
    printStatistics();
    return true;
}
 
inline void PerformanceMeasurement::printStatistics()
{
    const auto desc = getStatisticsAndReset().toString (name);
    std::cout << (desc);
}
 
inline std::string PerformanceMeasurement::getName() const
{
    return name;
}
 
inline PerformanceMeasurement::Statistics PerformanceMeasurement::getStatistics() const
{
    return stats;
}
 
inline PerformanceMeasurement::Statistics PerformanceMeasurement::getStatisticsAndReset()
{
    Statistics s (stats);
    stats.clear();
 
    return s;
}
 
}}