Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
qqmlabstractprofileradapter.cpp
Go to the documentation of this file.
1// Copyright (C) 2016 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qqmlabstractprofileradapter_p.h"
5
6QT_BEGIN_NAMESPACE
7
8/*!
9 * \internal
10 * \class QQmlAbstractProfilerAdapter
11 * \inmodule QtQml
12 * Abstract base class for all adapters between profilers and the QQmlProfilerService. Adapters have
13 * to retrieve profiler-specific data and convert it to the format sent over the wire. Adapters must
14 * live in the QDebugServer thread but the actual profilers can live in different threads. The
15 * recommended way to deal with this is passing the profiling data through a signal/slot connection.
16 */
17
18/*!
19 * \internal
20 * \fn void QQmlAbstractProfilerAdapter::dataRequested()
21 * Signals that data has been requested by the \c QQmlProfilerService. This signal should be
22 * connected to a slot in the profiler and the profiler should then transfer its currently available
23 * profiling data to the adapter as soon as possible.
24 */
25
26/*!
27 * \internal
28 * \fn qint64 QQmlAbstractProfilerAdapter::sendMessages(qint64 until, QList<QByteArray> &messages)
29 * Append the messages up to the timestamp \a until, chronologically sorted, to \a messages. Keep
30 * track of the messages already sent and with each subsequent call to this method start with the
31 * first one not yet sent. Messages that have been sent can be deleted. When new data from the
32 * profiler arrives the information about the last sent message must be reset. Return the timestamp
33 * of the next message after \a until or \c -1 if there is no such message.
34 * The profiler service keeps a list of adapters, sorted by time of next message and keeps querying
35 * the first one to send messages up to the time of the second one. Like that we get chronologically
36 * sorted messages and can occasionally post the messages to exploit parallelism and save memory.
37 */
38
39/*!
40 * \internal
41 * Emits either \c profilingEnabled(quint64) or \c profilingEnabledWhileWaiting(quint64), depending
42 * on \c waiting. If the profiler's thread is waiting for an initial start signal, we can emit the
43 * signal over a Qt::DirectConnection to avoid the delay of the event loop. The \a features are
44 * passed on to the signal.
45 */
46void QQmlAbstractProfilerAdapter::startProfiling(quint64 features)
47{
48 if (waiting)
49 emit profilingEnabledWhileWaiting(features);
50 else
51 emit profilingEnabled(features);
52 featuresEnabled = features;
53}
54
55/*!
56 * \internal
57 * Emits either \c profilingDisabled() or \c profilingDisabledWhileWaiting(), depending on
58 * \c waiting. If the profiler's thread is waiting for an initial start signal, we can emit the
59 * signal over a Qt::DirectConnection to avoid the delay of the event loop. This should trigger
60 * the profiler to report its collected data and subsequently delete it.
61 */
62void QQmlAbstractProfilerAdapter::stopProfiling() {
63 if (waiting)
64 emit profilingDisabledWhileWaiting();
65 else
66 emit profilingDisabled();
67 featuresEnabled = 0;
68}
69
70/*!
71 * \internal
72 * \fn bool QQmlAbstractProfilerAdapter::isRunning() const
73 * Returns if the profiler is currently running. The profiler is considered to be running after
74 * \c startProfiling(quint64) has been called until \c stopProfiling() is called. That is
75 * independent of \c waiting. The profiler may be running and waiting at the same time.
76 */
77
78/*!
79 * \internal
80 * \fn void QQmlAbstractProfilerAdapter::profilingDisabled()
81 * This signal is emitted if \c stopProfiling() is called while the profiler is not considered to
82 * be waiting. The profiler is expected to handle the signal asynchronously.
83 */
84
85/*!
86 * \internal
87 * \fn void QQmlAbstractProfilerAdapter::profilingDisabledWhileWaiting()
88 * This signal is emitted if \c stopProfiling() is called while the profiler is considered to be
89 * waiting. In many cases this signal can be connected with a Qt::DirectConnection.
90 */
91
92/*!
93 * \internal
94 * \fn void QQmlAbstractProfilerAdapter::profilingEnabled(quint64 features)
95 * This signal is emitted if \c startProfiling(quint64) is called while the profiler is not
96 * considered to be waiting. The profiler is expected to handle the signal asynchronously. The
97 * \a features are passed on from \c startProfiling(quint64).
98 */
99
100/*!
101 * \internal
102 * \fn void QQmlAbstractProfilerAdapter::profilingEnabledWhileWaiting(quint64 features)
103 * This signal is emitted if \c startProfiling(quint64) is called while the profiler is considered
104 * to be waiting. In many cases this signal can be connected with a Qt::DirectConnection. By
105 * starting the profiler synchronously when the QML engine starts instead of waiting for the first
106 * iteration of the event loop the engine startup can be profiled. The \a features are passed on
107 * from \c startProfiling(quint64).
108 */
109
110/*!
111 * \internal
112 * \fn void QQmlAbstractProfilerAdapter::referenceTimeKnown(const QElapsedTimer &timer)
113 * This signal is used to synchronize the profiler's timer to the QQmlProfilerservice's. The
114 * profiler is expected to save \a timer and use it for timestamps on its data.
115 */
116
117/*!
118 * \internal
119 * \fn void QQmlAbstractProfilerAdapter::synchronize(const QElapsedTimer &timer)
120 * Synchronize the profiler to \a timer. This emits \c referenceTimeKnown().
121 */
122
123/*!
124 * \internal
125 * \fn void QQmlAbstractProfilerAdapter::reportData()
126 * Make the profiler report its current data without stopping the collection. The same (and
127 * additional) data can later be requested again with \c stopProfiling() or \c reportData().
128 */
129
130/*!
131 * \internal
132 * \fn void QQmlAbstractProfilerAdapter::startWaiting()
133 * Consider the profiler to be waiting from now on. While the profiler is waiting it can be directly
134 * accessed even if it is in a different thread. This method should only be called if it is actually
135 * safe to do so.
136 */
137
138/*!
139 * \internal
140 * \fn void QQmlAbstractProfilerAdapter::stopWaiting()
141 * Consider the profiler not to be waiting anymore. If it lives in a different threads any requests
142 * for it have to be done via a queued connection then.
143 */
144
145QT_END_NAMESPACE
146
147#include "moc_qqmlabstractprofileradapter_p.cpp"