tracktion_Benchmark.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
#pragma once
 
#include "../../tracktion_graph/utilities/tracktion_PerformanceMeasurement.h"
 
namespace tracktion { inline namespace engine
{
 
//==============================================================================
//==============================================================================
struct BenchmarkDescription
{
    size_t hash = 0;            
    std::string category;       
    std::string name;           
    std::string description;    
    std::string platform { juce::SystemStats::getOperatingSystemName().toStdString() }; 
};
 
inline BenchmarkDescription createBenchmarkDescription (std::string category, std::string name, std::string description)
{
    return { std::hash<std::string>{} (name + description),
             category, name, description };
}
 
//==============================================================================
struct BenchmarkResult
{
    BenchmarkDescription description;   
    double totalSeconds = 0.0, meanSeconds = 0.0, minSeconds = 0.0, maxSeconds = 0.0, varianceSeconds = 0.0;
    uint64_t totalCycles = 0, meanCycles = 0, minCycles = 0, maxCycles = 0;
    double varianceCycles = 0.0;
    juce::Time date { juce::Time::getCurrentTime() };
};
 
inline BenchmarkResult createBenchmarkResult (BenchmarkDescription description,
                                              const tracktion::graph::PerformanceMeasurement::Statistics& stats)
{
    return { description,
             stats.totalSeconds, stats.meanSeconds, stats.minimumSeconds, stats.maximumSeconds, stats.getVarianceSeconds(),
             stats.totalCycles, (uint64_t) stats.meanCycles, stats.minimumCycles, stats.maximumCycles, stats.getVarianceCycles() };
}
 
//==============================================================================
class Benchmark
{
public:
    Benchmark (BenchmarkDescription desc)
        : description (std::move (desc))
    {
    }
 
    void start()
    {
        measurement.start();
    }
 
    void stop()
    {
        measurement.stop();
    }
 
    BenchmarkResult getResult() const
    {
        return createBenchmarkResult (description, measurement.getStatistics());
    }
 
private:
    BenchmarkDescription description;
    tracktion::graph::PerformanceMeasurement measurement { {}, -1, false };
};
 
//==============================================================================
class BenchmarkList
{
public:
    BenchmarkList() = default;
 
    void addResult (BenchmarkResult r)
    {
        std::lock_guard lock (mutex);
        results.emplace_back (std::move (r));
    }
 
    std::vector<BenchmarkResult> getResults() const
    {
        std::lock_guard lock (mutex);
        return results;
    }
 
    void clear()
    {
        std::lock_guard lock (mutex);
        return results.clear();
    }
 
    static BenchmarkList& getInstance()
    {
        static BenchmarkList list;
        return list;
    }
 
private:
    mutable std::mutex mutex;
    std::vector<BenchmarkResult> results;
};
 
//==============================================================================
struct ScopedBenchmark
{
    ScopedBenchmark (BenchmarkDescription desc)
        : benchmark (std::move (desc))
    {
        benchmark.start();
    }
 
    ~ScopedBenchmark()
    {
        benchmark.stop();
        BenchmarkList::getInstance().addResult (benchmark.getResult());
    }
 
private:
    Benchmark benchmark;
};
 
//==============================================================================
struct ScopedMeasurement
{
    ScopedMeasurement (Benchmark& bm)
        : benchmark (bm)
    {
        benchmark.start();
    }
 
    ~ScopedMeasurement()
    {
        benchmark.stop();
    }
 
private:
    Benchmark& benchmark;
};
 
}} // namespace tracktion { inline namespace engine