blob: 27c98890944e99b73fc404daa605cf2bd99690e6 (
plain)
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/****************************************************************************
**
** Copyright (C) 2021 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtQml module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:COMM$
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** $QT_END_LICENSE$
**
**
**
**
**
**
**
**
**
**
**
**
**
**
**
**
**
**
**
****************************************************************************/
#include "qqmlabstractprofileradapter_p.h"
QT_BEGIN_NAMESPACE
/*!
* \internal
* \class QQmlAbstractProfilerAdapter
* \inmodule QtQml
* Abstract base class for all adapters between profilers and the QQmlProfilerService. Adapters have
* to retrieve profiler-specific data and convert it to the format sent over the wire. Adapters must
* live in the QDebugServer thread but the actual profilers can live in different threads. The
* recommended way to deal with this is passing the profiling data through a signal/slot connection.
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::dataRequested()
* Signals that data has been requested by the \c QQmlProfilerService. This signal should be
* connected to a slot in the profiler and the profiler should then transfer its currently available
* profiling data to the adapter as soon as possible.
*/
/*!
* \internal
* \fn qint64 QQmlAbstractProfilerAdapter::sendMessages(qint64 until, QList<QByteArray> &messages)
* Append the messages up to the timestamp \a until, chronologically sorted, to \a messages. Keep
* track of the messages already sent and with each subsequent call to this method start with the
* first one not yet sent. Messages that have been sent can be deleted. When new data from the
* profiler arrives the information about the last sent message must be reset. Return the timestamp
* of the next message after \a until or \c -1 if there is no such message.
* The profiler service keeps a list of adapters, sorted by time of next message and keeps querying
* the first one to send messages up to the time of the second one. Like that we get chronologically
* sorted messages and can occasionally post the messages to exploit parallelism and save memory.
*/
/*!
* \internal
* Emits either \c profilingEnabled(quint64) or \c profilingEnabledWhileWaiting(quint64), depending
* on \c waiting. If the profiler's thread is waiting for an initial start signal, we can emit the
* signal over a Qt::DirectConnection to avoid the delay of the event loop. The \a features are
* passed on to the signal.
*/
void QQmlAbstractProfilerAdapter::startProfiling(quint64 features)
{
if (waiting)
emit profilingEnabledWhileWaiting(features);
else
emit profilingEnabled(features);
featuresEnabled = features;
}
/*!
* \internal
* Emits either \c profilingDisabled() or \c profilingDisabledWhileWaiting(), depending on
* \c waiting. If the profiler's thread is waiting for an initial start signal, we can emit the
* signal over a Qt::DirectConnection to avoid the delay of the event loop. This should trigger
* the profiler to report its collected data and subsequently delete it.
*/
void QQmlAbstractProfilerAdapter::stopProfiling() {
if (waiting)
emit profilingDisabledWhileWaiting();
else
emit profilingDisabled();
featuresEnabled = 0;
}
/*!
* \internal
* \fn bool QQmlAbstractProfilerAdapter::isRunning() const
* Returns if the profiler is currently running. The profiler is considered to be running after
* \c startProfiling(quint64) has been called until \c stopProfiling() is called. That is
* independent of \c waiting. The profiler may be running and waiting at the same time.
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::profilingDisabled()
* This signal is emitted if \c stopProfiling() is called while the profiler is not considered to
* be waiting. The profiler is expected to handle the signal asynchronously.
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::profilingDisabledWhileWaiting()
* This signal is emitted if \c stopProfiling() is called while the profiler is considered to be
* waiting. In many cases this signal can be connected with a Qt::DirectConnection.
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::profilingEnabled(quint64 features)
* This signal is emitted if \c startProfiling(quint64) is called while the profiler is not
* considered to be waiting. The profiler is expected to handle the signal asynchronously. The
* \a features are passed on from \c startProfiling(quint64).
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::profilingEnabledWhileWaiting(quint64 features)
* This signal is emitted if \c startProfiling(quint64) is called while the profiler is considered
* to be waiting. In many cases this signal can be connected with a Qt::DirectConnection. By
* starting the profiler synchronously when the QML engine starts instead of waiting for the first
* iteration of the event loop the engine startup can be profiled. The \a features are passed on
* from \c startProfiling(quint64).
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::referenceTimeKnown(const QElapsedTimer &timer)
* This signal is used to synchronize the profiler's timer to the QQmlProfilerservice's. The
* profiler is expected to save \a timer and use it for timestamps on its data.
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::synchronize(const QElapsedTimer &timer)
* Synchronize the profiler to \a timer. This emits \c referenceTimeKnown().
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::reportData()
* Make the profiler report its current data without stopping the collection. The same (and
* additional) data can later be requested again with \c stopProfiling() or \c reportData().
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::startWaiting()
* Consider the profiler to be waiting from now on. While the profiler is waiting it can be directly
* accessed even if it is in a different thread. This method should only be called if it is actually
* safe to do so.
*/
/*!
* \internal
* \fn void QQmlAbstractProfilerAdapter::stopWaiting()
* Consider the profiler not to be waiting anymore. If it lives in a different threads any requests
* for it have to be done via a queued connection then.
*/
QT_END_NAMESPACE
#include "moc_qqmlabstractprofileradapter_p.cpp"
|
