lua-cpp-s101-integration/profiler.cpp at ver2 · fostfox/lua-cpp-s101-integration · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include "profiler.h"

#include <QFile>
#include <QTextStream>

QString Profiler::m_fileName;

TimeUnit::TimeUnit(const QString &functionName)
    : m_functionName(functionName)
{
    this->start();
}

TimeUnit::~TimeUnit()
{
    this->stop();
    this->writeElapsed();
}

void TimeUnit::start()
{
    m_begin = std::chrono::steady_clock::now();
}

void TimeUnit::stop()
{
    m_end = std::chrono::steady_clock::now();
}

void TimeUnit::writeElapsed()
{
    double elapsedTime = std::chrono::duration_cast<std::chrono::microseconds>(m_end - m_begin).count() / 1e6;

    Profiler &profiler = Profiler::instance();
    profiler.addElapsedTime(m_functionName, elapsedTime);
}


Profiler &Profiler::instance()
{
    static Profiler theSingleInstance;
    return theSingleInstance;
}

TimeUnit Profiler::createTimeUnit(const QString &functionName)
{
    return TimeUnit(functionName);
}

void Profiler::setLogFile(const QString &fileName)
{
    m_fileName = fileName;
}

void Profiler::dumpLog()
{
#ifdef PROFILING_TIME_ENABLE
    if (m_fileName.isEmpty()){
        qFatal("File name not specified");
    }
    QFile logFile(m_fileName);
    if (!logFile.open(QFile::WriteOnly)) {
        qFatal("The file did not open");
    }

    QTextStream out(&logFile);
    for (const auto &funcInf : m_funcTimeInfoMap) {
        out << QString("Function: '%1', total: %2, run count: %3, average: %4\n")
               .arg(funcInf.name())
               .arg(funcInf.totalElapsed())
               .arg(funcInf.runCount())
               .arg(funcInf.averageElapsed());
    }
    logFile.close();
#endif
}

void Profiler::addElapsedTime(const QString &functionName, double time)
{
    if (!m_funcTimeInfoMap.contains(functionName)){
        m_funcTimeInfoMap[functionName] = FunctionTimeInfo(functionName);
    }
    m_funcTimeInfoMap[functionName].addElapsedTime(time);
}


Profiler::FunctionTimeInfo::FunctionTimeInfo(const QString &name)
    :m_name(name)
{
}

void Profiler::FunctionTimeInfo::addElapsedTime(double time)
{
    ++m_runCount;
    m_totalElapsed += time;
}

const QString &Profiler::FunctionTimeInfo::name() const
{
    return m_name;
}

double Profiler::FunctionTimeInfo::averageElapsed() const
{
    return m_totalElapsed / m_runCount;
}

long Profiler::FunctionTimeInfo::runCount() const
{
    return m_runCount;
}

double Profiler::FunctionTimeInfo::totalElapsed() const
{
    return m_totalElapsed;
}