diff options
25 files changed, 2561 insertions, 1263 deletions
diff --git a/src/qml/debugger/qqmlprofilerdefinitions_p.h b/src/qml/debugger/qqmlprofilerdefinitions_p.h index 91d0376837..f84a2c44e2 100644 --- a/src/qml/debugger/qqmlprofilerdefinitions_p.h +++ b/src/qml/debugger/qqmlprofilerdefinitions_p.h @@ -69,6 +69,7 @@ struct QQmlProfilerDefinitions { PixmapCacheEvent, SceneGraphFrame, MemoryAllocation, + DebugMessage, MaximumMessage }; @@ -161,6 +162,26 @@ struct QQmlProfilerDefinitions { MaximumInputEventType }; + + static ProfileFeature featureFromRangeType(RangeType range) + { + switch (range) { + case Painting: + return ProfilePainting; + case Compiling: + return ProfileCompiling; + case Creating: + return ProfileCreating; + case Binding: + return ProfileBinding; + case HandlingSignal: + return ProfileHandlingSignal; + case Javascript: + return ProfileJavaScript; + default: + return MaximumProfileFeature; + } + } }; QT_END_NAMESPACE diff --git a/src/qmldebug/qmldebug.pro b/src/qmldebug/qmldebug.pro index e5f6de3314..2539414d8f 100644 --- a/src/qmldebug/qmldebug.pro +++ b/src/qmldebug/qmldebug.pro @@ -7,15 +7,25 @@ load(qt_module) SOURCES += \ qqmldebugclient.cpp \ qqmldebugconnection.cpp \ + qqmldebugmessageclient.cpp \ qqmlenginecontrolclient.cpp \ - qqmlprofilerclient.cpp + qqmlprofilerclient.cpp \ + qqmlprofilerevent.cpp \ + qqmlprofilereventlocation.cpp \ + qqmlprofilereventtype.cpp \ + qqmlprofilertypedevent.cpp HEADERS += \ qqmldebugclient_p.h \ qqmldebugclient_p_p.h \ qqmldebugconnection_p.h \ + qqmldebugmessageclient_p.h \ qqmlenginecontrolclient_p.h \ qqmlenginecontrolclient_p_p.h \ - qqmleventlocation_p.h \ qqmlprofilerclient_p.h \ - qqmlprofilerclient_p_p.h + qqmlprofilerclient_p_p.h \ + qqmlprofilerevent_p.h \ + qqmlprofilereventlocation_p.h \ + qqmlprofilereventreceiver_p.h \ + qqmlprofilereventtype_p.h \ + qqmlprofilertypedevent_p.h diff --git a/src/qmldebug/qqmldebugmessageclient.cpp b/src/qmldebug/qqmldebugmessageclient.cpp new file mode 100644 index 0000000000..a03c1f8af2 --- /dev/null +++ b/src/qmldebug/qqmldebugmessageclient.cpp @@ -0,0 +1,95 @@ +/**************************************************************************** +** +** Copyright (C) 2017 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qqmldebugmessageclient_p.h" + +#include <QtCore/qdatastream.h> + +QT_BEGIN_NAMESPACE + +/*! + \class QQmlDebugMessageClient + \internal + + \brief Client for the debug message service + + The QQmlDebugMessageClient receives debug messages routed through the QML + debug connection via QDebugMessageService. + */ + +QQmlDebugMessageClient::QQmlDebugMessageClient(QQmlDebugConnection *client) + : QQmlDebugClient(QLatin1String("DebugMessages"), client) +{ +} + +void QQmlDebugMessageClient::stateChanged(State state) +{ + emit newState(state); +} + +void QQmlDebugMessageClient::messageReceived(const QByteArray &data) +{ + QDataStream ds(data); + QByteArray command; + ds >> command; + + if (command == "MESSAGE") { + int type; + int line; + QByteArray debugMessage; + QByteArray file; + QByteArray function; + ds >> type >> debugMessage >> file >> line >> function; + QQmlDebugContextInfo info; + info.line = line; + info.file = QString::fromUtf8(file); + info.function = QString::fromUtf8(function); + info.timestamp = -1; + if (!ds.atEnd()) { + QByteArray category; + ds >> category; + info.category = QString::fromUtf8(category); + if (!ds.atEnd()) + ds >> info.timestamp; + } + emit message(QtMsgType(type), QString::fromUtf8(debugMessage), info); + } +} + +QT_END_NAMESPACE diff --git a/src/qmldebug/qqmldebugmessageclient_p.h b/src/qmldebug/qqmldebugmessageclient_p.h new file mode 100644 index 0000000000..75c70044e4 --- /dev/null +++ b/src/qmldebug/qqmldebugmessageclient_p.h @@ -0,0 +1,87 @@ +/**************************************************************************** +** +** Copyright (C) 2017 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQMLDEBUGMESSAGECLIENT_P_H +#define QQMLDEBUGMESSAGECLIENT_P_H + +#include "qqmldebugclient_p.h" + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +QT_BEGIN_NAMESPACE + +struct QQmlDebugContextInfo +{ + int line; + QString file; + QString function; + QString category; + qint64 timestamp; +}; + +class QQmlDebugMessageClient : public QQmlDebugClient +{ + Q_OBJECT + +public: + explicit QQmlDebugMessageClient(QQmlDebugConnection *client); + + virtual void stateChanged(State state) override; + virtual void messageReceived(const QByteArray &) override; + +signals: + void newState(QQmlDebugClient::State); + void message(QtMsgType, const QString &, const QQmlDebugContextInfo &); + +private: + Q_DISABLE_COPY(QQmlDebugMessageClient) +}; + +QT_END_NAMESPACE + +#endif // QQMLDEBUGMESSAGECLIENT_P_H diff --git a/src/qmldebug/qqmlprofilerclient.cpp b/src/qmldebug/qqmlprofilerclient.cpp index 3676bd933c..dca564cd76 100644 --- a/src/qmldebug/qqmlprofilerclient.cpp +++ b/src/qmldebug/qqmlprofilerclient.cpp @@ -43,337 +43,296 @@ QT_BEGIN_NAMESPACE -QQmlProfilerClient::QQmlProfilerClient(QQmlDebugConnection *connection) : - QQmlDebugClient(*(new QQmlProfilerClientPrivate(connection))) +int QQmlProfilerClientPrivate::resolveType(const QQmlProfilerTypedEvent &event) { -} + int typeIndex = -1; + if (event.serverTypeId != 0) { + QHash<qint64, int>::ConstIterator it = serverTypeIds.constFind(event.serverTypeId); -QQmlProfilerClient::QQmlProfilerClient(QQmlProfilerClientPrivate &dd) : - QQmlDebugClient(dd) -{ + if (it != serverTypeIds.constEnd()) { + typeIndex = it.value(); + } else { + typeIndex = eventReceiver->numLoadedEventTypes(); + eventReceiver->addEventType(event.type); + serverTypeIds[event.serverTypeId] = typeIndex; + } + } else { + QHash<QQmlProfilerEventType, int>::ConstIterator it = eventTypeIds.constFind(event.type); + + if (it != eventTypeIds.constEnd()) { + typeIndex = it.value(); + } else { + typeIndex = eventReceiver->numLoadedEventTypes(); + eventReceiver->addEventType(event.type); + eventTypeIds[event.type] = typeIndex; + } + } + return typeIndex; } -QQmlProfilerClientPrivate::QQmlProfilerClientPrivate(QQmlDebugConnection *connection) : - QQmlDebugClientPrivate(QQmlProfilerService::s_key, connection), - features(std::numeric_limits<quint64>::max()) +int QQmlProfilerClientPrivate::resolveStackTop() { + if (rangesInProgress.isEmpty()) + return -1; + + QQmlProfilerTypedEvent &typedEvent = rangesInProgress.top(); + int typeIndex = typedEvent.event.typeIndex(); + if (typeIndex >= 0) + return typeIndex; + + typeIndex = resolveType(typedEvent); + typedEvent.event.setTypeIndex(typeIndex); + while (!pendingMessages.isEmpty() + && pendingMessages.head().timestamp() < typedEvent.event.timestamp()) { + forwardEvents(pendingMessages.dequeue()); + } + forwardEvents(typedEvent.event); + return typeIndex; } -void QQmlProfilerClient::setFeatures(quint64 features) +void QQmlProfilerClientPrivate::forwardEvents(const QQmlProfilerEvent &last) { - Q_D(QQmlProfilerClient); - d->features = features; + while (!pendingDebugMessages.isEmpty() + && pendingDebugMessages.front().timestamp() <= last.timestamp()) { + eventReceiver->addEvent(pendingDebugMessages.dequeue()); + } + eventReceiver->addEvent(last); } -void QQmlProfilerClient::sendRecordingStatus(bool record, int engineId, quint32 flushInterval) +void QQmlProfilerClientPrivate::processCurrentEvent() { - Q_D(const QQmlProfilerClient); - - QPacket stream(d->connection->currentDataStreamVersion()); - stream << record << engineId << d->features << flushInterval << true; - sendMessage(stream.data()); + // RangeData and RangeLocation always apply to the range on the top of the stack. Furthermore, + // all ranges are perfectly nested. This is why we can defer the type resolution until either + // the range ends or a child range starts. With only the information in RangeStart we wouldn't + // be able to uniquely identify the event type. + Message rangeStage = currentEvent.type.rangeType() == MaximumRangeType ? + currentEvent.type.message() : currentEvent.event.rangeStage(); + switch (rangeStage) { + case RangeStart: + resolveStackTop(); + rangesInProgress.push(currentEvent); + break; + case RangeEnd: { + int typeIndex = resolveStackTop(); + if (typeIndex == -1) + break; + currentEvent.event.setTypeIndex(typeIndex); + while (!pendingMessages.isEmpty()) + forwardEvents(pendingMessages.dequeue()); + forwardEvents(currentEvent.event); + rangesInProgress.pop(); + break; + } + case RangeData: + if (!rangesInProgress.isEmpty()) + rangesInProgress.top().type.setData(currentEvent.type.data()); + break; + case RangeLocation: + if (!rangesInProgress.isEmpty()) + rangesInProgress.top().type.setLocation(currentEvent.type.location()); + break; + case DebugMessage: + currentEvent.event.setTypeIndex(resolveType(currentEvent)); + pendingDebugMessages.enqueue(currentEvent.event); + break; + default: { + int typeIndex = resolveType(currentEvent); + currentEvent.event.setTypeIndex(typeIndex); + if (rangesInProgress.isEmpty()) + eventReceiver->addEvent(currentEvent.event); + else + pendingMessages.enqueue(currentEvent.event); + break; + } + } } -void QQmlProfilerClient::traceStarted(qint64 time, int engineId) +void QQmlProfilerClientPrivate::sendRecordingStatus(int engineId) { - Q_UNUSED(time); - Q_UNUSED(engineId); + Q_Q(QQmlProfilerClient); + QPacket stream(connection->currentDataStreamVersion()); + stream << recording << engineId; // engineId -1 is OK. It means "all of them" + if (recording) { + stream << requestedFeatures << flushInterval; + stream << true; // yes, we support type IDs + } + q->sendMessage(stream.data()); } -void QQmlProfilerClient::traceFinished(qint64 time, int engineId) +QQmlProfilerClient::QQmlProfilerClient(QQmlDebugConnection *connection, + QQmlProfilerEventReceiver *eventReceiver, + quint64 features) + : QQmlDebugClient(*(new QQmlProfilerClientPrivate(connection, eventReceiver))) { - Q_UNUSED(time); - Q_UNUSED(engineId); + Q_D(QQmlProfilerClient); + setRequestedFeatures(features); + connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded, + this, &QQmlProfilerClient::sendRecordingStatus); } -void QQmlProfilerClient::rangeStart(QQmlProfilerDefinitions::RangeType type, qint64 startTime) +QQmlProfilerClient::~QQmlProfilerClient() { - Q_UNUSED(type); - Q_UNUSED(startTime); + //Disable profiling if started by client + //Profiling data will be lost!! + if (isRecording()) + setRecording(false); } -void QQmlProfilerClient::rangeData(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QString &data) +void QQmlProfilerClient::clearEvents() { - Q_UNUSED(type); - Q_UNUSED(time); - Q_UNUSED(data); + Q_D(QQmlProfilerClient); + d->rangesInProgress.clear(); + d->pendingMessages.clear(); + d->pendingDebugMessages.clear(); + if (d->recordedFeatures != 0) { + d->recordedFeatures = 0; + emit recordedFeaturesChanged(0); + } + emit cleared(); } -void QQmlProfilerClient::rangeLocation(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QQmlEventLocation &location) +void QQmlProfilerClient::clearAll() { - Q_UNUSED(type); - Q_UNUSED(time); - Q_UNUSED(location); + Q_D(QQmlProfilerClient); + d->serverTypeIds.clear(); + d->eventTypeIds.clear(); + clearEvents(); } -void QQmlProfilerClient::rangeEnd(QQmlProfilerDefinitions::RangeType type, qint64 endTime) +void QQmlProfilerClientPrivate::finalize() { - Q_UNUSED(type); - Q_UNUSED(endTime); + while (!rangesInProgress.isEmpty()) { + currentEvent = rangesInProgress.top(); + currentEvent.event.setRangeStage(RangeEnd); + currentEvent.event.setTimestamp(maximumTime); + processCurrentEvent(); + } + while (!pendingDebugMessages.isEmpty()) + eventReceiver->addEvent(pendingDebugMessages.dequeue()); } -void QQmlProfilerClient::animationFrame(qint64 time, int frameRate, int animationCount, - int threadId) + +void QQmlProfilerClient::sendRecordingStatus(int engineId) { - Q_UNUSED(time); - Q_UNUSED(frameRate); - Q_UNUSED(animationCount); - Q_UNUSED(threadId); + Q_D(QQmlProfilerClient); + d->sendRecordingStatus(engineId); } -void QQmlProfilerClient::sceneGraphEvent(QQmlProfilerDefinitions::SceneGraphFrameType type, - qint64 time, qint64 numericData1, qint64 numericData2, - qint64 numericData3, qint64 numericData4, - qint64 numericData5) +bool QQmlProfilerClient::isRecording() const { - Q_UNUSED(type); - Q_UNUSED(time); - Q_UNUSED(numericData1); - Q_UNUSED(numericData2); - Q_UNUSED(numericData3); - Q_UNUSED(numericData4); - Q_UNUSED(numericData5); + Q_D(const QQmlProfilerClient); + return d->recording; } -void QQmlProfilerClient::pixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type, - qint64 time, const QString &url, int numericData1, - int numericData2) +void QQmlProfilerClient::setRecording(bool v) { - Q_UNUSED(type); - Q_UNUSED(time); - Q_UNUSED(url); - Q_UNUSED(numericData1); - Q_UNUSED(numericData2); + Q_D(QQmlProfilerClient); + if (v == d->recording) + return; + + d->recording = v; + + if (state() == Enabled) + sendRecordingStatus(); + + emit recordingChanged(v); } -void QQmlProfilerClient::memoryAllocation(QQmlProfilerDefinitions::MemoryType type, qint64 time, - qint64 amount) +quint64 QQmlProfilerClient::recordedFeatures() const { - Q_UNUSED(type); - Q_UNUSED(time); - Q_UNUSED(amount); + Q_D(const QQmlProfilerClient); + return d->recordedFeatures; } -void QQmlProfilerClient::inputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time, - int a, int b) +void QQmlProfilerClient::setRequestedFeatures(quint64 features) { - Q_UNUSED(type); - Q_UNUSED(time); - Q_UNUSED(a); - Q_UNUSED(b); + Q_D(QQmlProfilerClient); + d->requestedFeatures = features; + if (features & static_cast<quint64>(1) << ProfileDebugMessages) { + if (d->messageClient.isNull()) { + d->messageClient.reset(new QQmlDebugMessageClient(connection())); + connect(d->messageClient.data(), &QQmlDebugMessageClient::message, this, + [this](QtMsgType type, const QString &text, const QQmlDebugContextInfo &context) + { + Q_D(QQmlProfilerClient); + d->updateFeatures(ProfileDebugMessages); + d->currentEvent.event.setTimestamp(context.timestamp > 0 ? context.timestamp : 0); + d->currentEvent.event.setTypeIndex(-1); + d->currentEvent.event.setString(text); + d->currentEvent.type = QQmlProfilerEventType( + DebugMessage, MaximumRangeType, type, + QQmlProfilerEventLocation(context.file, context.line, 1)); + d->currentEvent.serverTypeId = 0; + d->processCurrentEvent(); + }); + } + } else { + d->messageClient.reset(); + } } -void QQmlProfilerClient::complete() +void QQmlProfilerClient::setFlushInterval(quint32 flushInterval) { + Q_D(QQmlProfilerClient); + d->flushInterval = flushInterval; } -void QQmlProfilerClient::unknownEvent(QQmlProfilerDefinitions::Message messageType, qint64 time, - int detailType) +QQmlProfilerClient::QQmlProfilerClient(QQmlProfilerClientPrivate &dd) : + QQmlDebugClient(dd) { - Q_UNUSED(messageType); - Q_UNUSED(time); - Q_UNUSED(detailType); + Q_D(QQmlProfilerClient); + connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded, + this, &QQmlProfilerClient::sendRecordingStatus); } -void QQmlProfilerClient::unknownData(QPacket &stream) +bool QQmlProfilerClientPrivate::updateFeatures(ProfileFeature feature) { - Q_UNUSED(stream); + Q_Q(QQmlProfilerClient); + quint64 flag = 1ULL << feature; + if (!(requestedFeatures & flag)) + return false; + if (!(recordedFeatures & flag)) { + recordedFeatures |= flag; + emit q->recordedFeaturesChanged(recordedFeatures); + } + return true; } -inline QQmlProfilerDefinitions::ProfileFeature featureFromRangeType( - QQmlProfilerDefinitions::RangeType range) +void QQmlProfilerClient::stateChanged(State status) { - switch (range) { - case QQmlProfilerDefinitions::Painting: - return QQmlProfilerDefinitions::ProfilePainting; - case QQmlProfilerDefinitions::Compiling: - return QQmlProfilerDefinitions::ProfileCompiling; - case QQmlProfilerDefinitions::Creating: - return QQmlProfilerDefinitions::ProfileCreating; - case QQmlProfilerDefinitions::Binding: - return QQmlProfilerDefinitions::ProfileBinding; - case QQmlProfilerDefinitions::HandlingSignal: - return QQmlProfilerDefinitions::ProfileHandlingSignal; - case QQmlProfilerDefinitions::Javascript: - return QQmlProfilerDefinitions::ProfileJavaScript; - default: - return QQmlProfilerDefinitions::MaximumProfileFeature; + if (status == Enabled) { + sendRecordingStatus(-1); + } else { + Q_D(QQmlProfilerClient); + d->finalize(); } + } void QQmlProfilerClient::messageReceived(const QByteArray &data) { Q_D(QQmlProfilerClient); - QPacket stream(d->connection->currentDataStreamVersion(), data); - // Force all the 1 << <FLAG> expressions to be done in 64 bit, to silence some warnings - const quint64 one = static_cast<quint64>(1); - - qint64 time; - int messageType; - - stream >> time >> messageType; - - if (messageType >= QQmlProfilerDefinitions::MaximumMessage) { - unknownEvent(static_cast<QQmlProfilerDefinitions::Message>(messageType), time, -1); - return; + stream >> d->currentEvent; + + d->maximumTime = qMax(d->currentEvent.event.timestamp(), d->maximumTime); + if (d->currentEvent.type.message() == Complete) { + d->finalize(); + emit complete(d->maximumTime); + } else if (d->currentEvent.type.message() == Event + && d->currentEvent.type.detailType() == StartTrace) { + emit traceStarted(d->currentEvent.event.timestamp(), + d->currentEvent.event.numbers<QList<int>, qint32>()); + } else if (d->currentEvent.type.message() == Event + && d->currentEvent.type.detailType() == EndTrace) { + emit traceFinished(d->currentEvent.event.timestamp(), + d->currentEvent.event.numbers<QList<int>, qint32>()); + } else if (d->updateFeatures(d->currentEvent.type.feature())) { + d->processCurrentEvent(); } - - if (messageType == QQmlProfilerDefinitions::Event) { - int type; - stream >> type; - - QQmlProfilerDefinitions::EventType eventType = - static_cast<QQmlProfilerDefinitions::EventType>(type); - - if (eventType == QQmlProfilerDefinitions::EndTrace) { - int engineId = -1; - if (!stream.atEnd()) - stream >> engineId; - traceFinished(time, engineId); - } else if (eventType == QQmlProfilerDefinitions::AnimationFrame) { - if (!(d->features & one << QQmlProfilerDefinitions::ProfileAnimations)) - return; - - int frameRate, animationCount; - int threadId = 0; - stream >> frameRate >> animationCount; - if (!stream.atEnd()) - stream >> threadId; - - animationFrame(time, frameRate, animationCount, threadId); - } else if (type == QQmlProfilerDefinitions::StartTrace) { - int engineId = -1; - if (!stream.atEnd()) - stream >> engineId; - traceStarted(time, engineId); - } else if (eventType == QQmlProfilerDefinitions::Key || - eventType == QQmlProfilerDefinitions::Mouse) { - - if (!(d->features & one << QQmlProfilerDefinitions::ProfileInputEvents)) - return; - - int type; - if (!stream.atEnd()) { - stream >> type; - } else { - type = (eventType == QQmlProfilerDefinitions::Key) ? - QQmlProfilerDefinitions::InputKeyUnknown : - QQmlProfilerDefinitions::InputMouseUnknown; - } - - int a = 0; - if (!stream.atEnd()) - stream >> a; - - int b = 0; - if (!stream.atEnd()) - stream >> b; - - inputEvent(static_cast<QQmlProfilerDefinitions::InputEventType>(type), time, a, b); - } else { - unknownEvent(QQmlProfilerDefinitions::Event, time, type); - } - } else if (messageType == QQmlProfilerDefinitions::Complete) { - complete(); - } else if (messageType == QQmlProfilerDefinitions::SceneGraphFrame) { - if (!(d->features & one << QQmlProfilerDefinitions::ProfileSceneGraph)) - return; - - int type; - int count = 0; - qint64 params[5]; - - stream >> type; - while (!stream.atEnd()) - stream >> params[count++]; - - while (count < 5) - params[count++] = 0; - - sceneGraphEvent(static_cast<QQmlProfilerDefinitions::SceneGraphFrameType>(type), time, - params[0], params[1], params[2], params[3], params[4]); - } else if (messageType == QQmlProfilerDefinitions::PixmapCacheEvent) { - if (!(d->features & one << QQmlProfilerDefinitions::ProfilePixmapCache)) - return; - - int type, param1 = 0, param2 = 0; - QString pixUrl; - stream >> type >> pixUrl; - - QQmlProfilerDefinitions::PixmapEventType pixmapEventType = - static_cast<QQmlProfilerDefinitions::PixmapEventType>(type); - - if (pixmapEventType == QQmlProfilerDefinitions::PixmapReferenceCountChanged || - pixmapEventType == QQmlProfilerDefinitions::PixmapCacheCountChanged) { - stream >> param1; - } else if (pixmapEventType == QQmlProfilerDefinitions::PixmapSizeKnown) { - stream >> param1 >> param2; - } - - pixmapCacheEvent(pixmapEventType, time, pixUrl, param1, param2); - } else if (messageType == QQmlProfilerDefinitions::MemoryAllocation) { - if (!(d->features & one << QQmlProfilerDefinitions::ProfileMemory)) - return; - int type; - qint64 delta; - stream >> type >> delta; - memoryAllocation((QQmlProfilerDefinitions::MemoryType)type, time, delta); - } else { - int range; - stream >> range; - - QQmlProfilerDefinitions::RangeType rangeType = - static_cast<QQmlProfilerDefinitions::RangeType>(range); - - if (range >= QQmlProfilerDefinitions::MaximumRangeType || - !(d->features & one << featureFromRangeType(rangeType))) - return; - - qint64 typeId = 0; - if (messageType == QQmlProfilerDefinitions::RangeStart) { - rangeStart(rangeType, time); - if (!stream.atEnd()) { - stream >> typeId; - auto i = d->types.constFind(typeId); - if (i != d->types.constEnd()) { - rangeLocation(rangeType, time, i->location); - rangeData(rangeType, time, i->name); - } - } - } else if (messageType == QQmlProfilerDefinitions::RangeData) { - QString data; - stream >> data; - rangeData(rangeType, time, data); - if (!stream.atEnd()) { - stream >> typeId; - d->types[typeId].name = data; - } - } else if (messageType == QQmlProfilerDefinitions::RangeLocation) { - QQmlEventLocation location; - stream >> location.filename >> location.line; - - if (!stream.atEnd()) - stream >> location.column; - - rangeLocation(rangeType, time, location); - if (!stream.atEnd()) { - stream >> typeId; - d->types[typeId].location = location; - } - } else if (messageType == QQmlProfilerDefinitions::RangeEnd) { - rangeEnd(rangeType, time); - } else { - unknownEvent(static_cast<QQmlProfilerDefinitions::Message>(messageType), time, range); - } - } - - if (!stream.atEnd()) - unknownData(stream); } + QT_END_NAMESPACE #include "moc_qqmlprofilerclient_p.cpp" diff --git a/src/qmldebug/qqmlprofilerclient_p.h b/src/qmldebug/qqmlprofilerclient_p.h index a328cad26c..68a32a1a5a 100644 --- a/src/qmldebug/qqmlprofilerclient_p.h +++ b/src/qmldebug/qqmlprofilerclient_p.h @@ -41,7 +41,9 @@ #define QQMLPROFILERCLIENT_P_H #include "qqmldebugclient_p.h" -#include "qqmleventlocation_p.h" +#include "qqmlprofilereventlocation_p.h" +#include "qqmlprofilereventreceiver_p.h" + #include <private/qqmlprofilerdefinitions_p.h> #include <private/qpacket_p.h> @@ -59,52 +61,42 @@ QT_BEGIN_NAMESPACE class QQmlProfilerClientPrivate; -class QQmlProfilerClient : public QQmlDebugClient +class QQmlProfilerClient : public QQmlDebugClient, public QQmlProfilerDefinitions { Q_OBJECT Q_DECLARE_PRIVATE(QQmlProfilerClient) + Q_PROPERTY(bool recording READ isRecording WRITE setRecording NOTIFY recordingChanged) public: - QQmlProfilerClient(QQmlDebugConnection *connection); - void setFeatures(quint64 features); - void sendRecordingStatus(bool record, int engineId = -1, quint32 flushInterval = 0); - -protected: - QQmlProfilerClient(QQmlProfilerClientPrivate &dd); - -private: - void messageReceived(const QByteArray &message) override; + QQmlProfilerClient(QQmlDebugConnection *connection, QQmlProfilerEventReceiver *eventReceiver, + quint64 features = std::numeric_limits<quint64>::max()); + ~QQmlProfilerClient(); - virtual void traceStarted(qint64 time, int engineId); - virtual void traceFinished(qint64 time, int engineId); + bool isRecording() const; + void setRecording(bool); + quint64 recordedFeatures() const; + virtual void messageReceived(const QByteArray &) override; + virtual void stateChanged(State status) override; - virtual void rangeStart(QQmlProfilerDefinitions::RangeType type, qint64 startTime); - virtual void rangeData(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QString &data); - virtual void rangeLocation(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QQmlEventLocation &location); - virtual void rangeEnd(QQmlProfilerDefinitions::RangeType type, qint64 endTime); + void clearEvents(); + void clearAll(); - virtual void animationFrame(qint64 time, int frameRate, int animationCount, int threadId); + void sendRecordingStatus(int engineId = -1); + void setRequestedFeatures(quint64 features); + void setFlushInterval(quint32 flushInterval); - virtual void sceneGraphEvent(QQmlProfilerDefinitions::SceneGraphFrameType type, qint64 time, - qint64 numericData1, qint64 numericData2, qint64 numericData3, - qint64 numericData4, qint64 numericData5); - - virtual void pixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type, qint64 time, - const QString &url, int numericData1, int numericData2); - - virtual void memoryAllocation(QQmlProfilerDefinitions::MemoryType type, qint64 time, - qint64 amount); +protected: + QQmlProfilerClient(QQmlProfilerClientPrivate &dd); - virtual void inputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time, int a, - int b); +signals: + void complete(qint64 maximumTime); + void traceFinished(qint64 timestamp, const QList<int> &engineIds); + void traceStarted(qint64 timestamp, const QList<int> &engineIds); - virtual void complete(); + void recordingChanged(bool arg); + void recordedFeaturesChanged(quint64 features); - virtual void unknownEvent(QQmlProfilerDefinitions::Message messageType, qint64 time, - int detailType); - virtual void unknownData(QPacket &stream); + void cleared(); }; QT_END_NAMESPACE diff --git a/src/qmldebug/qqmlprofilerclient_p_p.h b/src/qmldebug/qqmlprofilerclient_p_p.h index 9c44113aa8..cf0145409a 100644 --- a/src/qmldebug/qqmlprofilerclient_p_p.h +++ b/src/qmldebug/qqmlprofilerclient_p_p.h @@ -40,8 +40,15 @@ #ifndef QQMLPROFILERCLIENT_P_P_H #define QQMLPROFILERCLIENT_P_P_H -#include "qqmlprofilerclient_p.h" #include "qqmldebugclient_p_p.h" +#include "qqmldebugmessageclient_p.h" +#include "qqmlenginecontrolclient_p.h" +#include "qqmlprofilerclient_p.h" +#include "qqmlprofilertypedevent_p.h" + +#include <private/qqmlprofilerdefinitions_p.h> + +#include <QtCore/qqueue.h> // // W A R N I N G @@ -56,20 +63,48 @@ QT_BEGIN_NAMESPACE -struct QQmlProfilerRangeType -{ - QQmlEventLocation location; - QString name; -}; - -class QQmlProfilerClientPrivate : public QQmlDebugClientPrivate -{ +class QQmlProfilerClientPrivate : public QQmlDebugClientPrivate, public QQmlProfilerDefinitions { Q_DECLARE_PUBLIC(QQmlProfilerClient) public: - QQmlProfilerClientPrivate(QQmlDebugConnection *connection); - quint64 features; + QQmlProfilerClientPrivate(QQmlDebugConnection *connection, + QQmlProfilerEventReceiver *eventReceiver) + : QQmlDebugClientPrivate(QLatin1String("CanvasFrameRate"), connection) + , eventReceiver(eventReceiver) + , engineControl(new QQmlEngineControlClient(connection)) + , maximumTime(0) + , recording(false) + , requestedFeatures(0) + , recordedFeatures(0) + , flushInterval(0) + { + } + + virtual ~QQmlProfilerClientPrivate() override {} + + void sendRecordingStatus(int engineId); + bool updateFeatures(ProfileFeature feature); + int resolveType(const QQmlProfilerTypedEvent &type); + int resolveStackTop(); + void forwardEvents(const QQmlProfilerEvent &last); + void processCurrentEvent(); + void finalize(); + + QQmlProfilerEventReceiver *eventReceiver; + QScopedPointer<QQmlEngineControlClient> engineControl; + QScopedPointer<QQmlDebugMessageClient> messageClient; + qint64 maximumTime; + bool recording; + quint64 requestedFeatures; + quint64 recordedFeatures; + quint32 flushInterval; - QHash<qint64, QQmlProfilerRangeType> types; + // Reuse the same event, so that we don't have to constantly reallocate all the data. + QQmlProfilerTypedEvent currentEvent; + QHash<QQmlProfilerEventType, int> eventTypeIds; + QHash<qint64, int> serverTypeIds; + QStack<QQmlProfilerTypedEvent> rangesInProgress; + QQueue<QQmlProfilerEvent> pendingMessages; + QQueue<QQmlProfilerEvent> pendingDebugMessages; }; QT_END_NAMESPACE diff --git a/src/qmldebug/qqmlprofilerevent.cpp b/src/qmldebug/qqmlprofilerevent.cpp new file mode 100644 index 0000000000..30ae1c79a1 --- /dev/null +++ b/src/qmldebug/qqmlprofilerevent.cpp @@ -0,0 +1,273 @@ +/**************************************************************************** +** +** Copyright (C) 2017 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qqmlprofilerevent_p.h" +#include <QtCore/qdatastream.h> + +QT_BEGIN_NAMESPACE + +bool operator==(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2) +{ + if (event1.timestamp() != event2.timestamp() || event1.typeIndex() != event2.typeIndex()) + return false; + + // This is not particularly efficient, but we also don't need to do this very often. + return event1.numbers<QVarLengthArray<qint64>>() == event2.numbers<QVarLengthArray<qint64>>(); +} + +bool operator!=(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2) +{ + return !(event1 == event2); +} + +enum SerializationType { + OneByte = 0, + TwoByte = 1, + FourByte = 2, + EightByte = 3, + TypeMask = 0x3 +}; + +enum SerializationTypeOffset { + TimestampOffset = 0, + TypeIndexOffset = 2, + DataLengthOffset = 4, + DataOffset = 6 +}; + +template<typename Number> +static inline void readNumbers(QDataStream &stream, Number *data, quint16 length) +{ + for (quint16 i = 0; i != length; ++i) + stream >> data[i]; +} + +template<typename Number> +static inline Number readNumber(QDataStream &stream, qint8 type) +{ + switch (type) { + case OneByte: { + qint8 value; + stream >> value; + return static_cast<Number>(value); + } + case TwoByte: { + qint16 value; + stream >> value; + return static_cast<Number>(value); + } + case FourByte: { + qint32 value; + stream >> value; + return static_cast<Number>(value); + } + case EightByte: { + qint64 value; + stream >> value; + return static_cast<Number>(value); + } + default: + Q_UNREACHABLE(); + return 0; + } +} + +QDataStream &operator>>(QDataStream &stream, QQmlProfilerEvent &event) +{ + qint8 type; + stream >> type; + + event.m_timestamp = readNumber<qint64>(stream, (type >> TimestampOffset) & TypeMask); + event.m_typeIndex = readNumber<qint32>(stream, (type >> TypeIndexOffset) & TypeMask); + event.m_dataLength = readNumber<quint16>(stream, (type >> DataLengthOffset) & TypeMask); + + uint bytesPerNumber = 1 << ((type >> DataOffset) & TypeMask); + + if (event.m_dataLength * bytesPerNumber > sizeof(event.m_data)) { + event.m_dataType = static_cast<QQmlProfilerEvent::Type>((bytesPerNumber * 8) + | QQmlProfilerEvent::External); + event.m_data.external = malloc(event.m_dataLength * bytesPerNumber); + } else { + event.m_dataType = static_cast<QQmlProfilerEvent::Type>(bytesPerNumber * 8); + } + + switch (event.m_dataType) { + case QQmlProfilerEvent::Inline8Bit: + readNumbers<qint8>(stream, event.m_data.internal8bit, event.m_dataLength); + break; + case QQmlProfilerEvent::External8Bit: + readNumbers<qint8>(stream, static_cast<qint8 *>(event.m_data.external), + event.m_dataLength); + break; + case QQmlProfilerEvent::Inline16Bit: + readNumbers<qint16>(stream, event.m_data.internal16bit, event.m_dataLength); + break; + case QQmlProfilerEvent::External16Bit: + readNumbers<qint16>(stream, static_cast<qint16 *>(event.m_data.external), + event.m_dataLength); + break; + case QQmlProfilerEvent::Inline32Bit: + readNumbers<qint32>(stream, event.m_data.internal32bit, event.m_dataLength); + break; + case QQmlProfilerEvent::External32Bit: + readNumbers<qint32>(stream, static_cast<qint32 *>(event.m_data.external), + event.m_dataLength); + break; + case QQmlProfilerEvent::Inline64Bit: + readNumbers<qint64>(stream, event.m_data.internal64bit, event.m_dataLength); + break; + case QQmlProfilerEvent::External64Bit: + readNumbers<qint64>(stream, static_cast<qint64 *>(event.m_data.external), + event.m_dataLength); + break; + default: + Q_UNREACHABLE(); + break; + } + + return stream; +} + +static inline qint8 minimumType(const QQmlProfilerEvent &event, quint16 length, + quint16 origBitsPerNumber) +{ + qint8 type = OneByte; + bool ok = true; + for (quint16 i = 0; i < length;) { + if ((1 << type) == origBitsPerNumber / 8) + return type; + switch (type) { + case OneByte: + ok = (event.number<qint8>(i) == event.number<qint64>(i)); + break; + case TwoByte: + ok = (event.number<qint16>(i) == event.number<qint64>(i)); + break; + case FourByte: + ok = (event.number<qint32>(i) == event.number<qint64>(i)); + break; + default: + // EightByte isn't possible, as (1 << type) == origBitsPerNumber / 8 then. + Q_UNREACHABLE(); + break; + } + + if (ok) + ++i; + else + ++type; + } + return type; +} + +template<typename Number> +static inline qint8 minimumType(Number number) +{ + if (static_cast<qint8>(number) == number) + return OneByte; + if (static_cast<qint16>(number) == number) + return TwoByte; + if (static_cast<qint32>(number) == number) + return FourByte; + return EightByte; +} + +template<typename Number> +static inline void writeNumbers(QDataStream &stream, const QQmlProfilerEvent &event, quint16 length) +{ + for (quint16 i = 0; i != length; ++i) + stream << event.number<Number>(i); +} + +template<typename Number> +static inline void writeNumber(QDataStream &stream, Number number, qint8 type) +{ + switch (type) { + case OneByte: + stream << static_cast<qint8>(number); + break; + case TwoByte: + stream << static_cast<qint16>(number); + break; + case FourByte: + stream << static_cast<qint32>(number); + break; + case EightByte: + stream << static_cast<qint64>(number); + break; + default: + Q_UNREACHABLE(); + break; + } +} + +QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEvent &event) +{ + qint8 type = minimumType(event.m_timestamp); // << TimestampOffset; + type |= minimumType(event.m_typeIndex) << TypeIndexOffset; + type |= minimumType(event.m_dataLength) << DataLengthOffset; + type |= minimumType(event, event.m_dataLength, event.m_dataType) << DataOffset; + stream << type; + + writeNumber(stream, event.m_timestamp, (type >> TimestampOffset) & TypeMask); + writeNumber(stream, event.m_typeIndex, (type >> TypeIndexOffset) & TypeMask); + writeNumber(stream, event.m_dataLength, (type >> DataLengthOffset) & TypeMask); + + switch ((type >> DataOffset) & TypeMask) { + case OneByte: + writeNumbers<qint8>(stream, event, event.m_dataLength); + break; + case TwoByte: + writeNumbers<qint16>(stream, event, event.m_dataLength); + break; + case FourByte: + writeNumbers<qint32>(stream, event, event.m_dataLength); + break; + case EightByte: + writeNumbers<qint64>(stream, event, event.m_dataLength); + break; + default: + Q_UNREACHABLE(); + break; + } + + return stream; +} + +QT_END_NAMESPACE diff --git a/src/qmldebug/qqmlprofilerevent_p.h b/src/qmldebug/qqmlprofilerevent_p.h new file mode 100644 index 0000000000..93562302e9 --- /dev/null +++ b/src/qmldebug/qqmlprofilerevent_p.h @@ -0,0 +1,355 @@ +/**************************************************************************** +** +** Copyright (C) 2017 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQMLPROFILEREVENT_P_H +#define QQMLPROFILEREVENT_P_H + +#include <private/qqmlprofilerdefinitions_p.h> + +#include <QtCore/qstring.h> +#include <QtCore/qbytearray.h> +#include <QtCore/qvarlengtharray.h> +#include <QtCore/qmetatype.h> + +#include <initializer_list> +#include <type_traits> + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +QT_BEGIN_NAMESPACE + +struct QQmlProfilerEvent : public QQmlProfilerDefinitions { + QQmlProfilerEvent() : + m_timestamp(-1), m_typeIndex(-1), m_dataType(Inline8Bit), m_dataLength(0) + {} + + template<typename Number> + QQmlProfilerEvent(qint64 timestamp, int typeIndex, std::initializer_list<Number> list) + : m_timestamp(timestamp), m_typeIndex(typeIndex) + { + assignNumbers<std::initializer_list<Number>, Number>(list); + } + + QQmlProfilerEvent(qint64 timestamp, int typeIndex, const QString &data) + : m_timestamp(timestamp), m_typeIndex(typeIndex) + { + assignNumbers<QByteArray, qint8>(data.toUtf8()); + } + + template<typename Number> + QQmlProfilerEvent(qint64 timestamp, int typeIndex, const QVector<Number> &data) + : m_timestamp(timestamp), m_typeIndex(typeIndex) + { + assignNumbers<QVector<Number>, Number>(data); + } + + QQmlProfilerEvent(const QQmlProfilerEvent &other) + : m_timestamp(other.m_timestamp), m_typeIndex(other.m_typeIndex), + m_dataType(other.m_dataType), m_dataLength(other.m_dataLength) + { + assignData(other); + } + + QQmlProfilerEvent(QQmlProfilerEvent &&other) + { + memcpy(this, &other, sizeof(QQmlProfilerEvent)); + other.m_dataType = Inline8Bit; // prevent dtor from deleting the pointer + } + + QQmlProfilerEvent &operator=(const QQmlProfilerEvent &other) + { + if (this != &other) { + clearPointer(); + m_timestamp = other.m_timestamp; + m_typeIndex = other.m_typeIndex; + m_dataType = other.m_dataType; + m_dataLength = other.m_dataLength; + assignData(other); + } + return *this; + } + + QQmlProfilerEvent &operator=(QQmlProfilerEvent &&other) + { + if (this != &other) { + memcpy(this, &other, sizeof(QQmlProfilerEvent)); + other.m_dataType = Inline8Bit; + } + return *this; + } + + ~QQmlProfilerEvent() + { + clearPointer(); + } + + qint64 timestamp() const { return m_timestamp; } + void setTimestamp(qint64 timestamp) { m_timestamp = timestamp; } + + int typeIndex() const { return m_typeIndex; } + void setTypeIndex(int typeIndex) { m_typeIndex = typeIndex; } + + template<typename Number> + Number number(int i) const + { + // Trailing zeroes can be omitted, for example for SceneGraph events + if (i >= m_dataLength) + return 0; + switch (m_dataType) { + case Inline8Bit: + return m_data.internal8bit[i]; +QT_WARNING_PUSH +QT_WARNING_DISABLE_GCC("-Warray-bounds") // Mingw 5.3 gcc doesn't get the type/length logic. + case Inline16Bit: + return m_data.internal16bit[i]; + case Inline32Bit: + return m_data.internal32bit[i]; + case Inline64Bit: + return m_data.internal64bit[i]; +QT_WARNING_POP + case External8Bit: + return static_cast<const qint8 *>(m_data.external)[i]; + case External16Bit: + return static_cast<const qint16 *>(m_data.external)[i]; + case External32Bit: + return static_cast<const qint32 *>(m_data.external)[i]; + case External64Bit: + return static_cast<const qint64 *>(m_data.external)[i]; + default: + return 0; + } + } + + template<typename Number> + void setNumber(int i, Number number) + { + QVarLengthArray<Number> nums = numbers<QVarLengthArray<Number>, Number>(); + int prevSize = nums.size(); + if (i >= prevSize) { + nums.resize(i + 1); + // Fill with zeroes. We don't want to accidentally prevent squeezing. + while (prevSize < i) + nums[prevSize++] = 0; + } + nums[i] = number; + setNumbers<QVarLengthArray<Number>, Number>(nums); + } + + template<typename Container, typename Number> + void setNumbers(const Container &numbers) + { + clearPointer(); + assignNumbers<Container, Number>(numbers); + } + + template<typename Number> + void setNumbers(std::initializer_list<Number> numbers) + { + setNumbers<std::initializer_list<Number>, Number>(numbers); + } + + template<typename Container, typename Number = qint64> + Container numbers() const + { + Container container; + for (int i = 0; i < m_dataLength; ++i) + container.append(number<Number>(i)); + return container; + } + + QString string() const + { + switch (m_dataType) { + case External8Bit: + return QString::fromUtf8(static_cast<const char *>(m_data.external), m_dataLength); + case Inline8Bit: + return QString::fromUtf8(m_data.internalChar, m_dataLength); + default: + Q_UNREACHABLE(); + return QString(); + } + } + + void setString(const QString &data) + { + clearPointer(); + assignNumbers<QByteArray, char>(data.toUtf8()); + } + + Message rangeStage() const + { + Q_ASSERT(m_dataType == Inline8Bit); + return static_cast<Message>(m_data.internal8bit[0]); + } + + void setRangeStage(Message stage) + { + clearPointer(); + m_dataType = Inline8Bit; + m_dataLength = 1; + m_data.internal8bit[0] = stage; + } + + bool isValid() const + { + return m_timestamp != -1; + } + +private: + enum Type: quint16 { + External = 1, + Inline8Bit = 8, + External8Bit = Inline8Bit | External, + Inline16Bit = 16, + External16Bit = Inline16Bit | External, + Inline32Bit = 32, + External32Bit = Inline32Bit | External, + Inline64Bit = 64, + External64Bit = Inline64Bit | External + }; + + qint64 m_timestamp; + + static const int s_internalDataLength = 8; + union { + void *external; + char internalChar [s_internalDataLength]; + qint8 internal8bit [s_internalDataLength]; + qint16 internal16bit[s_internalDataLength / 2]; + qint32 internal32bit[s_internalDataLength / 4]; + qint64 internal64bit[s_internalDataLength / 8]; + } m_data; + + qint32 m_typeIndex; + Type m_dataType; + quint16 m_dataLength; + + void assignData(const QQmlProfilerEvent &other) + { + if (m_dataType & External) { + uint length = m_dataLength * (other.m_dataType / 8); + m_data.external = malloc(length); + memcpy(m_data.external, other.m_data.external, length); + } else { + memcpy(&m_data, &other.m_data, sizeof(m_data)); + } + } + + template<typename Big, typename Small> + bool squeezable(Big source) + { + return static_cast<Small>(source) == source; + } + + template<typename Container, typename Number> + typename std::enable_if<(sizeof(Number) > 1), bool>::type + squeeze(const Container &numbers) + { + typedef typename QIntegerForSize<sizeof(Number) / 2>::Signed Small; + foreach (Number item, numbers) { + if (!squeezable<Number, Small>(item)) + return false; + } + assignNumbers<Container, Small>(numbers); + return true; + } + + template<typename Container, typename Number> + typename std::enable_if<(sizeof(Number) <= 1), bool>::type + squeeze(const Container &) + { + return false; + } + + template<typename Container, typename Number> + void assignNumbers(const Container &numbers) + { + Number *data; + m_dataLength = squeezable<size_t, quint16>(static_cast<size_t>(numbers.size())) ? + static_cast<quint16>(numbers.size()) : std::numeric_limits<quint16>::max(); + if (m_dataLength > sizeof(m_data) / sizeof(Number)) { + if (squeeze<Container, Number>(numbers)) + return; + m_dataType = static_cast<Type>((sizeof(Number) * 8) | External); + m_data.external = malloc(m_dataLength * sizeof(Number)); + data = static_cast<Number *>(m_data.external); + } else { + m_dataType = static_cast<Type>(sizeof(Number) * 8); + data = static_cast<Number *>(m_dataType & External ? m_data.external : &m_data); + } + quint16 i = 0; + for (Number item : numbers) { + if (i >= m_dataLength) + break; + data[i++] = item; + } + } + + void clearPointer() + { + if (m_dataType & External) + free(m_data.external); + } + + friend QDataStream &operator>>(QDataStream &stream, QQmlProfilerEvent &event); + friend QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEvent &event); +}; + +bool operator==(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2); +bool operator!=(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2); + +QDataStream &operator>>(QDataStream &stream, QQmlProfilerEvent &event); +QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEvent &event); + +Q_DECLARE_TYPEINFO(QQmlProfilerEvent, Q_MOVABLE_TYPE); + +QT_END_NAMESPACE + +Q_DECLARE_METATYPE(QQmlProfilerEvent) + +#endif // QQMLPROFILEREVENT_P_H diff --git a/src/qmldebug/qqmlprofilereventlocation.cpp b/src/qmldebug/qqmlprofilereventlocation.cpp new file mode 100644 index 0000000000..8be44c17a3 --- /dev/null +++ b/src/qmldebug/qqmlprofilereventlocation.cpp @@ -0,0 +1,56 @@ +/**************************************************************************** +** +** Copyright (C) 2017 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qqmlprofilereventlocation_p.h" + +#include <QtCore/qdatastream.h> + +QT_BEGIN_NAMESPACE + +QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventLocation &location) +{ + return stream >> location.m_filename >> location.m_line >> location.m_column; +} + +QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventLocation &location) +{ + return stream << location.m_filename << location.m_line << location.m_column; +} + +QT_END_NAMESPACE diff --git a/src/qmldebug/qqmlprofilereventlocation_p.h b/src/qmldebug/qqmlprofilereventlocation_p.h new file mode 100644 index 0000000000..6f37eab14b --- /dev/null +++ b/src/qmldebug/qqmlprofilereventlocation_p.h @@ -0,0 +1,121 @@ +/**************************************************************************** +** +** Copyright (C) 2016 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQMLPROFILEREVENTLOCATION_P_H +#define QQMLPROFILEREVENTLOCATION_P_H + +#include <QtCore/qstring.h> +#include <QtCore/qhash.h> +#include <QtCore/qdatastream.h> + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +QT_BEGIN_NAMESPACE + +class QQmlProfilerEventLocation +{ +public: + QQmlProfilerEventLocation() : m_line(-1),m_column(-1) {} + QQmlProfilerEventLocation(const QString &file, int lineNumber, int columnNumber) : + m_filename(file), m_line(lineNumber), m_column(columnNumber) + {} + + void clear() + { + m_filename.clear(); + m_line = m_column = -1; + } + + bool isValid() const + { + return !m_filename.isEmpty(); + } + + QString filename() const { return m_filename; } + int line() const { return m_line; } + int column() const { return m_column; } + +private: + friend QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventLocation &location); + friend QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventLocation &location); + + QString m_filename; + int m_line; + int m_column; +}; + +inline bool operator==(const QQmlProfilerEventLocation &location1, + const QQmlProfilerEventLocation &location2) +{ + // compare filename last as it's expensive. + return location1.line() == location2.line() && location1.column() == location2.column() + && location1.filename() == location2.filename(); +} + +inline bool operator!=(const QQmlProfilerEventLocation &location1, + const QQmlProfilerEventLocation &location2) +{ + return !(location1 == location2); +} + +inline uint qHash(const QQmlProfilerEventLocation &location) +{ + return qHash(location.filename()) + ^ ((location.line() & 0xfff) // 12 bits of line number + | ((location.column() << 16) & 0xff0000)); // 8 bits of column + +} + +QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventLocation &location); +QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventLocation &location); + +Q_DECLARE_TYPEINFO(QQmlProfilerEventLocation, Q_MOVABLE_TYPE); + +QT_END_NAMESPACE + +#endif // QQMLPROFILEREVENTLOCATION_P_H diff --git a/src/qmldebug/qqmlprofilereventreceiver_p.h b/src/qmldebug/qqmlprofilereventreceiver_p.h new file mode 100644 index 0000000000..ee8e592858 --- /dev/null +++ b/src/qmldebug/qqmlprofilereventreceiver_p.h @@ -0,0 +1,63 @@ +/**************************************************************************** +** +** Copyright (C) 2017 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQMLPROFILEREVENTRECEIVER_P_H +#define QQMLPROFILEREVENTRECEIVER_P_H + +#include "qqmlprofilerevent_p.h" +#include "qqmlprofilereventtype_p.h" + +#include <QtCore/qobject.h> + +QT_BEGIN_NAMESPACE + +class QQmlProfilerEventReceiver : public QObject +{ + Q_OBJECT +public: + QQmlProfilerEventReceiver(QObject *parent = nullptr) : QObject(parent) {} + + virtual int numLoadedEventTypes() const = 0; + virtual void addEventType(const QQmlProfilerEventType &type) = 0; + virtual void addEvent(const QQmlProfilerEvent &event) = 0; +}; + +QT_END_NAMESPACE + +#endif // QQMLPROFILEREVENTRECEIVER_P_H diff --git a/src/qmldebug/qqmlprofilereventtype.cpp b/src/qmldebug/qqmlprofilereventtype.cpp new file mode 100644 index 0000000000..b0aad3fc5b --- /dev/null +++ b/src/qmldebug/qqmlprofilereventtype.cpp @@ -0,0 +1,92 @@ +/**************************************************************************** +** +** Copyright (C) 2017 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qqmlprofilereventtype_p.h" + +#include <QtCore/qdatastream.h> + +QT_BEGIN_NAMESPACE + +QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventType &type) +{ + quint8 message; + quint8 rangeType; + stream >> type.m_displayName >> type.m_data >> type.m_location >> message >> rangeType + >> type.m_detailType; + type.m_message = static_cast<QQmlProfilerDefinitions::Message>(message); + type.m_rangeType = static_cast<QQmlProfilerDefinitions::RangeType>(rangeType); + return stream; +} + +QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventType &type) +{ + return stream << type.m_displayName << type.m_data << type.m_location + << static_cast<quint8>(type.m_message) << static_cast<quint8>(type.m_rangeType) + << type.m_detailType; +} + +QQmlProfilerDefinitions::ProfileFeature QQmlProfilerEventType::feature() const +{ + switch (m_message) { + case Event: { + switch (m_detailType) { + case Mouse: + case Key: + return ProfileInputEvents; + case AnimationFrame: + return ProfileAnimations; + default: + return MaximumProfileFeature; + } + } + case PixmapCacheEvent: + return ProfilePixmapCache; + case SceneGraphFrame: + return ProfileSceneGraph; + case MemoryAllocation: + return ProfileMemory; + case DebugMessage: + return ProfileDebugMessages; + default: + return featureFromRangeType(m_rangeType); + } +} + + +QT_END_NAMESPACE diff --git a/src/qmldebug/qqmlprofilereventtype_p.h b/src/qmldebug/qqmlprofilereventtype_p.h new file mode 100644 index 0000000000..7bd67f9ca8 --- /dev/null +++ b/src/qmldebug/qqmlprofilereventtype_p.h @@ -0,0 +1,126 @@ +/**************************************************************************** +** +** Copyright (C) 2017 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQMLPROFILEREVENTTYPE_P_H +#define QQMLPROFILEREVENTTYPE_P_H + +#include "qqmlprofilereventlocation_p.h" + +#include <private/qqmlprofilerdefinitions_p.h> + +#include <QtCore/qstring.h> +#include <QtCore/qmetatype.h> +#include <QtCore/qhash.h> + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +QT_BEGIN_NAMESPACE + +class QQmlProfilerEventType : public QQmlProfilerDefinitions { +public: + QQmlProfilerEventType(Message message = MaximumMessage, RangeType rangeType = MaximumRangeType, + int detailType = -1, + const QQmlProfilerEventLocation &location = QQmlProfilerEventLocation(), + const QString &data = QString(), const QString displayName = QString()) : + m_displayName(displayName), m_data(data), m_location(location), m_message(message), + m_rangeType(rangeType), m_detailType(detailType) + {} + + void setDisplayName(const QString &displayName) { m_displayName = displayName; } + void setData(const QString &data) { m_data = data; } + void setLocation(const QQmlProfilerEventLocation &location) { m_location = location; } + + ProfileFeature feature() const; + QString displayName() const { return m_displayName; } + QString data() const { return m_data; } + QQmlProfilerEventLocation location() const { return m_location; } + Message message() const { return m_message; } + RangeType rangeType() const { return m_rangeType; } + int detailType() const { return m_detailType; } + +private: + friend QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventType &type); + friend QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventType &type); + + QString m_displayName; + QString m_data; + QQmlProfilerEventLocation m_location; + Message m_message; + RangeType m_rangeType; + int m_detailType; // can be EventType, BindingType, PixmapEventType or SceneGraphFrameType +}; + +QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventType &type); +QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventType &type); + +inline uint qHash(const QQmlProfilerEventType &type) +{ + return qHash(type.location()) + ^ (((type.message() << 12) & 0xf000) // 4 bits message + | ((type.rangeType() << 24) & 0xf000000) // 4 bits rangeType + | ((static_cast<uint>(type.detailType()) << 28) & 0xf0000000)); // 4 bits detailType +} + +inline bool operator==(const QQmlProfilerEventType &type1, const QQmlProfilerEventType &type2) +{ + return type1.message() == type2.message() && type1.rangeType() == type2.rangeType() + && type1.detailType() == type2.detailType() && type1.location() == type2.location(); +} + +inline bool operator!=(const QQmlProfilerEventType &type1, const QQmlProfilerEventType &type2) +{ + return !(type1 == type2); +} + +Q_DECLARE_TYPEINFO(QQmlProfilerEventType, Q_MOVABLE_TYPE); + +QT_END_NAMESPACE + +Q_DECLARE_METATYPE(QQmlProfilerEventType) + +#endif // QQMLPROFILEREVENTTYPE_P_H diff --git a/src/qmldebug/qqmlprofilertypedevent.cpp b/src/qmldebug/qqmlprofilertypedevent.cpp new file mode 100644 index 0000000000..9b00481e17 --- /dev/null +++ b/src/qmldebug/qqmlprofilertypedevent.cpp @@ -0,0 +1,226 @@ +/**************************************************************************** +** +** Copyright (C) 2017 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:LGPL$ +** 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. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qqmlprofilertypedevent_p.h" +#include <QtCore/qvarlengtharray.h> + +QT_BEGIN_NAMESPACE + +QDataStream &operator>>(QDataStream &stream, QQmlProfilerTypedEvent &event) +{ + qint64 time; + qint32 messageType; + qint32 subtype; + + stream >> time >> messageType; + + if (messageType < 0 || messageType > QQmlProfilerDefinitions::MaximumMessage) + messageType = QQmlProfilerDefinitions::MaximumMessage; + + QQmlProfilerDefinitions::RangeType rangeType = QQmlProfilerDefinitions::MaximumRangeType; + if (!stream.atEnd()) { + stream >> subtype; + rangeType = static_cast<QQmlProfilerDefinitions::RangeType>(subtype); + if (rangeType < 0 || rangeType > QQmlProfilerDefinitions::MaximumRangeType) + rangeType = QQmlProfilerDefinitions::MaximumRangeType; + } else { + subtype = -1; + } + + event.event.setTimestamp(time > 0 ? time : 0); + event.event.setTypeIndex(-1); + event.serverTypeId = 0; + + switch (messageType) { + case QQmlProfilerDefinitions::Event: { + event.type = QQmlProfilerEventType( + static_cast<QQmlProfilerDefinitions::Message>(messageType), + QQmlProfilerDefinitions::MaximumRangeType, subtype); + switch (subtype) { + case QQmlProfilerDefinitions::StartTrace: + case QQmlProfilerDefinitions::EndTrace: { + QVarLengthArray<qint32> engineIds; + while (!stream.atEnd()) { + qint32 id; + stream >> id; + engineIds << id; + } + event.event.setNumbers<QVarLengthArray<qint32>, qint32>(engineIds); + break; + } + case QQmlProfilerDefinitions::AnimationFrame: { + qint32 frameRate, animationCount; + qint32 threadId; + stream >> frameRate >> animationCount; + if (!stream.atEnd()) + stream >> threadId; + else + threadId = 0; + + event.event.setNumbers<qint32>({frameRate, animationCount, threadId}); + break; + } + case QQmlProfilerDefinitions::Mouse: + case QQmlProfilerDefinitions::Key: + int inputType = (subtype == QQmlProfilerDefinitions::Key + ? QQmlProfilerDefinitions::InputKeyUnknown + : QQmlProfilerDefinitions::InputMouseUnknown); + if (!stream.atEnd()) + stream >> inputType; + qint32 a = -1; + if (!stream.atEnd()) + stream >> a; + qint32 b = -1; + if (!stream.atEnd()) + stream >> b; + + event.event.setNumbers<qint32>({inputType, a, b}); + break; + } + + break; + } + case QQmlProfilerDefinitions::Complete: { + event.type = QQmlProfilerEventType( + static_cast<QQmlProfilerDefinitions::Message>(messageType), + QQmlProfilerDefinitions::MaximumRangeType, subtype); + break; + } + case QQmlProfilerDefinitions::SceneGraphFrame: { + QVarLengthArray<qint64> params; + qint64 param; + + while (!stream.atEnd()) { + stream >> param; + params.push_back(param); + } + + event.type = QQmlProfilerEventType( + static_cast<QQmlProfilerDefinitions::Message>(messageType), + QQmlProfilerDefinitions::MaximumRangeType, subtype); + event.event.setNumbers<QVarLengthArray<qint64>, qint64>(params); + break; + } + case QQmlProfilerDefinitions::PixmapCacheEvent: { + qint32 width = 0, height = 0, refcount = 0; + QString filename; + stream >> filename; + if (subtype == QQmlProfilerDefinitions::PixmapReferenceCountChanged + || subtype == QQmlProfilerDefinitions::PixmapCacheCountChanged) { + stream >> refcount; + } else if (subtype == QQmlProfilerDefinitions::PixmapSizeKnown) { + stream >> width >> height; + refcount = 1; + } + + event.type = QQmlProfilerEventType( + static_cast<QQmlProfilerDefinitions::Message>(messageType), + QQmlProfilerDefinitions::MaximumRangeType, subtype, + QQmlProfilerEventLocation(filename, 0, 0)); + event.event.setNumbers<qint32>({width, height, refcount}); + break; + } + case QQmlProfilerDefinitions::MemoryAllocation: { + qint64 delta; + stream >> delta; + + event.type = QQmlProfilerEventType( + static_cast<QQmlProfilerDefinitions::Message>(messageType), + QQmlProfilerDefinitions::MaximumRangeType, subtype); + event.event.setNumbers<qint64>({delta}); + break; + } + case QQmlProfilerDefinitions::RangeStart: { + if (!stream.atEnd()) { + qint64 typeId; + stream >> typeId; + if (stream.status() == QDataStream::Ok) + event.serverTypeId = typeId; + // otherwise it's the old binding type of 4 bytes + } + + event.type = QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, rangeType, -1); + event.event.setRangeStage(QQmlProfilerDefinitions::RangeStart); + break; + } + case QQmlProfilerDefinitions::RangeData: { + QString data; + stream >> data; + + event.type = QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, rangeType, -1, + QQmlProfilerEventLocation(), data); + event.event.setRangeStage(QQmlProfilerDefinitions::RangeData); + if (!stream.atEnd()) + stream >> event.serverTypeId; + break; + } + case QQmlProfilerDefinitions::RangeLocation: { + QString filename; + qint32 line = 0; + qint32 column = 0; + stream >> filename >> line; + + if (!stream.atEnd()) { + stream >> column; + if (!stream.atEnd()) + stream >> event.serverTypeId; + } + + event.type = QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, rangeType, -1, + QQmlProfilerEventLocation(filename, line, column)); + event.event.setRangeStage(QQmlProfilerDefinitions::RangeLocation); + break; + } + case QQmlProfilerDefinitions::RangeEnd: { + event.type = QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, rangeType, -1); + event.event.setRangeStage(QQmlProfilerDefinitions::RangeEnd); + break; + } + default: + event.event.setNumbers<char>({}); + event.type = QQmlProfilerEventType( + static_cast<QQmlProfilerDefinitions::Message>(messageType), + QQmlProfilerDefinitions::MaximumRangeType, subtype); + break; + } + + return stream; +} + +QT_END_NAMESPACE diff --git a/src/qmldebug/qqmleventlocation_p.h b/src/qmldebug/qqmlprofilertypedevent_p.h index c3a2b93f0f..e7e947f2ef 100644 --- a/src/qmldebug/qqmleventlocation_p.h +++ b/src/qmldebug/qqmlprofilertypedevent_p.h @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2017 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtQml module of the Qt Toolkit. @@ -37,10 +37,13 @@ ** ****************************************************************************/ -#ifndef QQMLEVENTLOCATION_P_H -#define QQMLEVENTLOCATION_P_H +#ifndef QQMLPROFILERTYPEDEVENT_P_H +#define QQMLPROFILERTYPEDEVENT_P_H -#include <QtCore/qstring.h> +#include "qqmlprofilerevent_p.h" +#include "qqmlprofilereventtype_p.h" + +#include <QtCore/qdatastream.h> // // W A R N I N G @@ -55,19 +58,19 @@ QT_BEGIN_NAMESPACE -struct QQmlEventLocation +struct QQmlProfilerTypedEvent { - QQmlEventLocation() : line(-1), column(-1) {} - QQmlEventLocation(const QString &file, int lineNumber, int columnNumber) : - filename(file), line(lineNumber), column(columnNumber) {} - - QString filename; - int line; - int column; + QQmlProfilerEvent event; + QQmlProfilerEventType type; + qint64 serverTypeId = 0; }; -Q_DECLARE_TYPEINFO(QQmlEventLocation, Q_MOVABLE_TYPE); +QDataStream &operator>>(QDataStream &stream, QQmlProfilerTypedEvent &event); + +Q_DECLARE_TYPEINFO(QQmlProfilerTypedEvent, Q_MOVABLE_TYPE); QT_END_NAMESPACE -#endif // QQMLEVENTLOCATION_P_H +Q_DECLARE_METATYPE(QQmlProfilerTypedEvent) + +#endif // QQMLPROFILERTYPEDEVENT_P_H diff --git a/tests/auto/qml/debugger/qqmlprofilerservice/data/controlFromJS.qml b/tests/auto/qml/debugger/qqmlprofilerservice/data/controlFromJS.qml index dd7cb2055d..4235a2d55f 100644 --- a/tests/auto/qml/debugger/qqmlprofilerservice/data/controlFromJS.qml +++ b/tests/auto/qml/debugger/qqmlprofilerservice/data/controlFromJS.qml @@ -43,13 +43,6 @@ QtObject { interval: 1000 onTriggered: { console.profileEnd(); - endTimer.start(); } } - - property var endTimer: Timer { - id: endTimer - interval: 1000 - onTriggered: Qt.quit(); - } } diff --git a/tests/auto/qml/debugger/qqmlprofilerservice/data/exit.qml b/tests/auto/qml/debugger/qqmlprofilerservice/data/exit.qml index 4236d70ea3..3b28e65174 100644 --- a/tests/auto/qml/debugger/qqmlprofilerservice/data/exit.qml +++ b/tests/auto/qml/debugger/qqmlprofilerservice/data/exit.qml @@ -1,7 +1,7 @@ import QtQml 2.0 QtObject { - Timer { + property Timer timer: Timer { running: true interval: 1 onTriggered: Qt.quit(); diff --git a/tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp b/tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp index 43ab3e1171..c32fa7ea7d 100644 --- a/tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp +++ b/tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp @@ -40,223 +40,134 @@ #include <QtGui/private/qguiapplication_p.h> #include <QtGui/qpa/qplatformintegration.h> -struct QQmlProfilerData -{ - QQmlProfilerData(qint64 time = -2, int messageType = -1, int detailType = -1, - const QString &detailData = QString()) : - time(time), messageType(messageType), detailType(detailType), detailData(detailData), - line(-1), column(-1), framerate(-1), animationcount(-1), amount(-1) - {} - - qint64 time; - int messageType; - int detailType; - - //### - QString detailData; //used by RangeData and RangeLocation - int line; //used by RangeLocation - int column; //used by RangeLocation - int framerate; //used by animation events - int animationcount; //used by animation events - qint64 amount; //used by heap events -}; - -class QQmlProfilerTestClient : public QQmlProfilerClient +class QQmlProfilerTestClient : public QQmlProfilerEventReceiver, public QQmlProfilerDefinitions { Q_OBJECT public: - QQmlProfilerTestClient(QQmlDebugConnection *connection) : QQmlProfilerClient(connection), - lastTimestamp(-1) {} + QQmlProfilerTestClient(QQmlDebugConnection *connection) : + client(new QQmlProfilerClient(connection, this)) + { + connect(client.data(), &QQmlProfilerClient::traceStarted, + this, &QQmlProfilerTestClient::startTrace); + connect(client.data(), &QQmlProfilerClient::traceFinished, + this, &QQmlProfilerTestClient::endTrace); + } - QVector<QQmlProfilerData> qmlMessages; - QVector<QQmlProfilerData> javascriptMessages; - QVector<QQmlProfilerData> jsHeapMessages; - QVector<QQmlProfilerData> asynchronousMessages; - QVector<QQmlProfilerData> pixmapMessages; + void startTrace(qint64 timestamp, const QList<int> &engineIds); + void endTrace(qint64 timestamp, const QList<int> &engineIds); - qint64 lastTimestamp; + QPointer<QQmlProfilerClient> client; // Owned by QQmlDebugTest + QVector<QQmlProfilerEventType> types; -signals: - void recordingFinished(); + QVector<QQmlProfilerEvent> qmlMessages; + QVector<QQmlProfilerEvent> javascriptMessages; + QVector<QQmlProfilerEvent> jsHeapMessages; + QVector<QQmlProfilerEvent> asynchronousMessages; + QVector<QQmlProfilerEvent> pixmapMessages; -private: - void traceStarted(qint64 time, int engineId); - void traceFinished(qint64 time, int engineId); - void rangeStart(QQmlProfilerDefinitions::RangeType type, qint64 startTime); - void rangeData(QQmlProfilerDefinitions::RangeType type, qint64 time, const QString &data); - void rangeLocation(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QQmlEventLocation &location); - void rangeEnd(QQmlProfilerDefinitions::RangeType type, qint64 endTime); - void animationFrame(qint64 time, int frameRate, int animationCount, int threadId); - void sceneGraphEvent(QQmlProfilerDefinitions::SceneGraphFrameType type, qint64 time, - qint64 numericData1, qint64 numericData2, qint64 numericData3, - qint64 numericData4, qint64 numericData5); - void pixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type, qint64 time, - const QString &url, int numericData1, int numericData2); - void memoryAllocation(QQmlProfilerDefinitions::MemoryType type, qint64 time, qint64 amount); - void inputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time, int a, int b); - void complete(); - - void unknownEvent(QQmlProfilerDefinitions::Message messageType, qint64 time, int detailType); - void unknownData(QPacket &stream); + int numLoadedEventTypes() const override; + void addEventType(const QQmlProfilerEventType &type) override; + void addEvent(const QQmlProfilerEvent &event) override; }; -void QQmlProfilerTestClient::traceStarted(qint64 time, int engineId) -{ - asynchronousMessages.append(QQmlProfilerData(time, QQmlProfilerDefinitions::Event, - QQmlProfilerDefinitions::StartTrace, - QString::number(engineId))); -} - -void QQmlProfilerTestClient::traceFinished(qint64 time, int engineId) +void QQmlProfilerTestClient::startTrace(qint64 timestamp, const QList<int> &engineIds) { - asynchronousMessages.append(QQmlProfilerData(time, QQmlProfilerDefinitions::Event, - QQmlProfilerDefinitions::EndTrace, - QString::number(engineId))); + types.append(QQmlProfilerEventType(Event, MaximumRangeType, StartTrace)); + asynchronousMessages.append(QQmlProfilerEvent(timestamp, types.length() - 1, + engineIds.toVector())); } -void QQmlProfilerTestClient::rangeStart(QQmlProfilerDefinitions::RangeType type, qint64 startTime) +void QQmlProfilerTestClient::endTrace(qint64 timestamp, const QList<int> &engineIds) { - QVERIFY(type >= 0 && type < QQmlProfilerDefinitions::MaximumRangeType); - QVERIFY(lastTimestamp <= startTime); - lastTimestamp = startTime; - QQmlProfilerData data(startTime, QQmlProfilerDefinitions::RangeStart, type); - if (type == QQmlProfilerDefinitions::Javascript) - javascriptMessages.append(data); - else - qmlMessages.append(data); + types.append(QQmlProfilerEventType(Event, MaximumRangeType, EndTrace)); + asynchronousMessages.append(QQmlProfilerEvent(timestamp, types.length() - 1, + engineIds.toVector())); } -void QQmlProfilerTestClient::rangeData(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QString &string) +int QQmlProfilerTestClient::numLoadedEventTypes() const { - QVERIFY(type >= 0 && type < QQmlProfilerDefinitions::MaximumRangeType); - QVERIFY(lastTimestamp <= time); - lastTimestamp = time; - QQmlProfilerData data(time, QQmlProfilerDefinitions::RangeData, type, string); - if (type == QQmlProfilerDefinitions::Javascript) - javascriptMessages.append(data); - else - qmlMessages.append(data); + return types.length(); } -void QQmlProfilerTestClient::rangeLocation(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QQmlEventLocation &location) +void QQmlProfilerTestClient::addEventType(const QQmlProfilerEventType &type) { - QVERIFY(type >= 0 && type < QQmlProfilerDefinitions::MaximumRangeType); - QVERIFY(location.line >= -2); - QVERIFY(lastTimestamp <= time); - lastTimestamp = time; - QQmlProfilerData data(time, QQmlProfilerDefinitions::RangeLocation, type, location.filename); - data.line = location.line; - data.column = location.column; - if (type == QQmlProfilerDefinitions::Javascript) - javascriptMessages.append(data); - else - qmlMessages.append(data); + types.append(type); } -void QQmlProfilerTestClient::rangeEnd(QQmlProfilerDefinitions::RangeType type, qint64 endTime) +void QQmlProfilerTestClient::addEvent(const QQmlProfilerEvent &event) { - QVERIFY(type >= 0 && type < QQmlProfilerDefinitions::MaximumRangeType); - QVERIFY(lastTimestamp <= endTime); - lastTimestamp = endTime; - QQmlProfilerData data(endTime, QQmlProfilerDefinitions::RangeEnd, type); - if (type == QQmlProfilerDefinitions::Javascript) - javascriptMessages.append(data); - else - qmlMessages.append(data); -} + const int typeIndex = event.typeIndex(); + QVERIFY(typeIndex < types.length()); -void QQmlProfilerTestClient::animationFrame(qint64 time, int frameRate, int animationCount, int threadId) -{ - QVERIFY(threadId >= 0); - QVERIFY(frameRate != -1); - QVERIFY(animationCount != -1); - QVERIFY(lastTimestamp <= time); - lastTimestamp = time; - QQmlProfilerData data(time, QQmlProfilerDefinitions::Event, - QQmlProfilerDefinitions::AnimationFrame); - data.framerate = frameRate; - data.animationcount = animationCount; - asynchronousMessages.append(data); -} + const QQmlProfilerEventType &type = types[typeIndex]; -void QQmlProfilerTestClient::sceneGraphEvent(QQmlProfilerDefinitions::SceneGraphFrameType type, - qint64 time, qint64 numericData1, qint64 numericData2, - qint64 numericData3, qint64 numericData4, - qint64 numericData5) -{ - Q_UNUSED(numericData1); - Q_UNUSED(numericData2); - Q_UNUSED(numericData3); - Q_UNUSED(numericData4); - Q_UNUSED(numericData5); - QVERIFY(lastTimestamp <= time); - lastTimestamp = time; - asynchronousMessages.append(QQmlProfilerData(time, QQmlProfilerDefinitions::SceneGraphFrame, - type)); -} - -void QQmlProfilerTestClient::pixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type, - qint64 time, const QString &url, int numericData1, - int numericData2) -{ - QVERIFY(lastTimestamp <= time); - lastTimestamp = time; - QQmlProfilerData data(time, QQmlProfilerDefinitions::PixmapCacheEvent, type, url); - switch (type) { - case QQmlProfilerDefinitions::PixmapSizeKnown: - data.line = numericData1; - data.column = numericData2; + switch (type.message()) { + case Event: { + switch (type.detailType()) { + case StartTrace: + QFAIL("StartTrace should not be passed on as event"); + break; + case EndTrace: + QFAIL("EndTrace should not be passed on as event"); + break; + case AnimationFrame: + asynchronousMessages.append(event); + break; + case Mouse: + case Key: + qmlMessages.append(event); + break; + default: + QFAIL(qPrintable(QString::fromLatin1("Event with unknown detailType %1 received at %2.") + .arg(type.detailType()).arg(event.timestamp()))); + break; + } break; - case QQmlProfilerDefinitions::PixmapReferenceCountChanged: - case QQmlProfilerDefinitions::PixmapCacheCountChanged: - data.animationcount = numericData1; + } + case RangeStart: + case RangeData: + case RangeLocation: + case RangeEnd: + QFAIL("Range stages are transmitted as part of events"); break; - default: + case Complete: + QFAIL("Complete should not be passed on as event"); + break; + case PixmapCacheEvent: + pixmapMessages.append(event); + break; + case SceneGraphFrame: + asynchronousMessages.append(event); + break; + case MemoryAllocation: + jsHeapMessages.append(event); + break; + case DebugMessage: + // Unhandled + break; + case MaximumMessage: + switch (type.rangeType()) { + case Painting: + QFAIL("QtQuick1 paint message received."); + break; + case Compiling: + case Creating: + case Binding: + case HandlingSignal: + qmlMessages.append(event); + break; + case Javascript: + javascriptMessages.append(event); + break; + default: + QFAIL(qPrintable( + QString::fromLatin1("Unknown range event %1 received at %2.") + .arg(type.rangeType()).arg(event.timestamp()))); + break; + } break; } - pixmapMessages.append(data); -} - -void QQmlProfilerTestClient::memoryAllocation(QQmlProfilerDefinitions::MemoryType type, qint64 time, - qint64 amount) -{ - QVERIFY(lastTimestamp <= time); - lastTimestamp = time; - QQmlProfilerData data(time, QQmlProfilerDefinitions::MemoryAllocation, type); - data.amount = amount; - jsHeapMessages.append(data); -} - -void QQmlProfilerTestClient::inputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time, - int a, int b) -{ - QVERIFY(lastTimestamp <= time); - lastTimestamp = time; - qmlMessages.append(QQmlProfilerData(time, QQmlProfilerDefinitions::Event, type, - QString::number(a) + QLatin1Char('x') + - QString::number(b))); -} - -void QQmlProfilerTestClient::unknownEvent(QQmlProfilerDefinitions::Message messageType, qint64 time, - int detailType) -{ - QFAIL(qPrintable(QString::fromLatin1("Unknown event %1 with detail type %2 received at %3.") - .arg(messageType).arg(detailType).arg(time))); -} - -void QQmlProfilerTestClient::unknownData(QPacket &stream) -{ - QFAIL(qPrintable(QString::fromLatin1("%1 bytes of extra data after receiving message.") - .arg(stream.device()->bytesAvailable()))); -} - -void QQmlProfilerTestClient::complete() -{ - emit recordingFinished(); } class tst_QQmlProfilerService : public QQmlDebugTest @@ -278,18 +189,23 @@ private: CheckLine = 1 << 2, CheckColumn = 1 << 3, CheckDataEndsWith = 1 << 4, + CheckFileEndsWith = 1 << 5, + CheckNumbers = 1 << 6, - CheckAll = CheckMessageType | CheckDetailType | CheckLine | CheckColumn | CheckDataEndsWith + CheckType = CheckMessageType | CheckDetailType | CheckLine | CheckColumn | CheckFileEndsWith }; - ConnectResult connect(bool block, const QString &testFile, bool restrictServices = true); + ConnectResult connect(bool block, const QString &testFile, bool recordFromStart = true, + uint flushInterval = 0, bool restrictServices = true); + void checkProcessTerminated(); void checkTraceReceived(); void checkJsHeap(); - bool verify(MessageListType type, int expectedPosition, const QQmlProfilerData &expected, - quint32 checks); + bool verify(MessageListType type, int expectedPosition, + const QQmlProfilerEventType &expectedType, quint32 checks, + const QVector<qint64> &numbers); QList<QQmlDebugClient *> createClients() override; - QPointer<QQmlProfilerTestClient> m_client; + QScopedPointer<QQmlProfilerTestClient> m_client; private slots: void cleanup() override; @@ -305,33 +221,63 @@ private slots: void flushInterval(); void translationBinding(); void memory(); + +private: + bool m_recordFromStart = true; + bool m_flushInterval = 0; + bool m_isComplete = false; + + // Don't use ({...}) here as MSVC will interpret that as the "QVector(int size)" ctor. + const QVector<qint64> m_rangeStart = (QVector<qint64>() << QQmlProfilerDefinitions::RangeStart); + const QVector<qint64> m_rangeEnd = (QVector<qint64>() << QQmlProfilerDefinitions::RangeEnd); }; -#define VERIFY(type, position, expected, checks) QVERIFY(verify(type, position, expected, checks)) +#define VERIFY(type, position, expected, checks, numbers) \ + QVERIFY(verify(type, position, expected, checks, numbers)) -QQmlDebugTest::ConnectResult tst_QQmlProfilerService::connect(bool block, const QString &file, - bool restrictServices) +QQmlDebugTest::ConnectResult tst_QQmlProfilerService::connect( + bool block, const QString &file, bool recordFromStart, uint flushInterval, + bool restrictServices) { + m_recordFromStart = recordFromStart; + m_flushInterval = flushInterval; + m_isComplete = false; + // ### Still using qmlscene due to QTBUG-33377 return QQmlDebugTest::connect(QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmlscene", restrictServices ? QStringLiteral("CanvasFrameRate") : QString(), testFile(file), block); } +void tst_QQmlProfilerService::checkProcessTerminated() +{ + // If the process ends before connect(), we get a non-success value from connect() + // That's not a problem as we will still receive the trace. We check that process has terminated + // cleanly here. + + // Wait for the process to finish by itself, if that hasn't happened already + QTRY_COMPARE(m_client->client->state(), QQmlDebugClient::NotConnected); + QTRY_COMPARE(m_process->exitStatus(), QProcess::NormalExit); +} + void tst_QQmlProfilerService::checkTraceReceived() { - QVERIFY2(QQmlDebugTest::waitForSignal(m_client, SIGNAL(recordingFinished())), - "No trace received in time."); + QTRY_VERIFY2(m_isComplete, "No trace received in time."); + + QVector<qint64> numbers; // must start with "StartTrace" - QQmlProfilerData expected(0, QQmlProfilerDefinitions::Event, - QQmlProfilerDefinitions::StartTrace); - VERIFY(MessageListAsynchronous, 0, expected, CheckMessageType | CheckDetailType); + QQmlProfilerEventType expected(QQmlProfilerDefinitions::Event, + QQmlProfilerDefinitions::MaximumRangeType, + QQmlProfilerDefinitions::StartTrace); + VERIFY(MessageListAsynchronous, 0, expected, CheckMessageType | CheckDetailType, numbers); // must end with "EndTrace" - expected.detailType = QQmlProfilerDefinitions::EndTrace; + expected = QQmlProfilerEventType(QQmlProfilerDefinitions::Event, + QQmlProfilerDefinitions::MaximumRangeType, + QQmlProfilerDefinitions::EndTrace); VERIFY(MessageListAsynchronous, m_client->asynchronousMessages.length() - 1, expected, - CheckMessageType | CheckDetailType); + CheckMessageType | CheckDetailType, numbers); } void tst_QQmlProfilerService::checkJsHeap() @@ -344,33 +290,35 @@ void tst_QQmlProfilerService::checkJsHeap() qint64 allocated = 0; qint64 used = 0; qint64 lastTimestamp = -1; - foreach (const QQmlProfilerData &message, m_client->jsHeapMessages) { - switch (message.detailType) { + foreach (const QQmlProfilerEvent &message, m_client->jsHeapMessages) { + const qint64 amount = message.number<qint64>(0); + const QQmlProfilerEventType &type = m_client->types.at(message.typeIndex()); + switch (type.detailType()) { case QV4::Profiling::HeapPage: - allocated += message.amount; + allocated += amount; seen_alloc = true; break; case QV4::Profiling::SmallItem: - used += message.amount; + used += amount; seen_small = true; break; case QV4::Profiling::LargeItem: - allocated += message.amount; - used += message.amount; + allocated += amount; + used += amount; seen_large = true; break; } - QVERIFY(message.time >= lastTimestamp); + QVERIFY(message.timestamp() >= lastTimestamp); // The heap will only be consistent after all events of the same timestamp are processed. if (lastTimestamp == -1) { - lastTimestamp = message.time; + lastTimestamp = message.timestamp(); continue; - } else if (message.time == lastTimestamp) { + } else if (message.timestamp() == lastTimestamp) { continue; } - lastTimestamp = message.time; + lastTimestamp = message.timestamp(); QVERIFY2(used >= 0, QString::fromLatin1("Negative memory usage seen: %1") .arg(used).toUtf8().constData()); @@ -389,10 +337,10 @@ void tst_QQmlProfilerService::checkJsHeap() } bool tst_QQmlProfilerService::verify(tst_QQmlProfilerService::MessageListType type, - int expectedPosition, const QQmlProfilerData &expected, - quint32 checks) + int expectedPosition, const QQmlProfilerEventType &expected, + quint32 checks, const QVector<qint64> &expectedNumbers) { - QVector<QQmlProfilerData> *target = 0; + const QVector<QQmlProfilerEvent> *target = 0; switch (type) { case MessageListQML: target = &(m_client->qmlMessages); break; case MessageListJavaScript: target = &(m_client->javascriptMessages); break; @@ -408,41 +356,81 @@ bool tst_QQmlProfilerService::verify(tst_QQmlProfilerService::MessageListType ty } uint position = expectedPosition; - qint64 timestamp = target->at(expectedPosition).time; - while (position > 0 && target->at(position - 1).time == timestamp) + qint64 timestamp = target->at(expectedPosition).timestamp(); + while (position > 0 && target->at(position - 1).timestamp() == timestamp) --position; QStringList warnings; do { - const QQmlProfilerData &actual = target->at(position); - if ((checks & CheckMessageType) && actual.messageType != expected.messageType) { - warnings << QString::fromLatin1("%1: unexpected messageType. actual: %2 - expected: %3") - .arg(position).arg(actual.messageType).arg(expected.messageType); + const QQmlProfilerEvent &event = target->at(position); + const QQmlProfilerEventType &actual = m_client->types.at(event.typeIndex()); + if ((checks & CheckMessageType) && + (actual.message() != expected.message() + || actual.rangeType() != expected.rangeType())) { + warnings << QString::fromLatin1("%1: unexpected messageType or rangeType. " + "actual: %2, %3 - expected: %4, %5") + .arg(position).arg(actual.message()).arg(actual.rangeType()) + .arg(expected.message()).arg(expected.rangeType()); continue; } - if ((checks & CheckDetailType) && actual.detailType != expected.detailType) { + if ((checks & CheckDetailType) && actual.detailType() != expected.detailType()) { warnings << QString::fromLatin1("%1: unexpected detailType. actual: %2 - expected: %3") - .arg(position).arg(actual.detailType).arg(expected.detailType); + .arg(position).arg(actual.detailType()).arg(expected.detailType()); continue; } - if ((checks & CheckLine) && actual.line != expected.line) { + + const QQmlProfilerEventLocation expectedLocation = expected.location(); + const QQmlProfilerEventLocation actualLocation = actual.location(); + + if ((checks & CheckLine) && actualLocation.line() != expectedLocation.line()) { warnings << QString::fromLatin1("%1: unexpected line. actual: %2 - expected: %3") - .arg(position).arg(actual.line).arg(expected.line); + .arg(position).arg(actualLocation.line()) + .arg(expectedLocation.line()); continue; } - if ((checks & CheckColumn) && actual.column != expected.column) { + if ((checks & CheckColumn) && actualLocation.column() != expectedLocation.column()) { warnings << QString::fromLatin1("%1: unexpected column. actual: %2 - expected: %3") - .arg(position).arg(actual.column).arg(expected.column); + .arg(position).arg(actualLocation.column()) + .arg(expectedLocation.column()); continue; } - if ((checks & CheckDataEndsWith) && !actual.detailData.endsWith(expected.detailData)) { + if ((checks & CheckFileEndsWith) && + !actualLocation.filename().endsWith(expectedLocation.filename())) { + warnings << QString::fromLatin1("%1: unexpected fileName. actual: %2 - expected: %3") + .arg(position).arg(actualLocation.filename()) + .arg(expectedLocation.filename()); + continue; + } + + if ((checks & CheckDataEndsWith) && !actual.data().endsWith(expected.data())) { warnings << QString::fromLatin1("%1: unexpected detailData. actual: %2 - expected: %3") - .arg(position).arg(actual.detailData).arg(expected.detailData); + .arg(position).arg(actual.data()).arg(expected.data()); continue; } + + if (checks & CheckNumbers) { + const QVector<qint64> actualNumbers = event.numbers<QVector<qint64>>(); + if (actualNumbers != expectedNumbers) { + + QStringList expectedList; + for (qint64 number : expectedNumbers) + expectedList.append(QString::number(number)); + QStringList actualList; + for (qint64 number : actualNumbers) + actualList.append(QString::number(number)); + + warnings << QString::fromLatin1( + "%1: unexpected numbers. actual [%2] - expected: [%3]") + .arg(position) + .arg(actualList.join(QLatin1String(", "))) + .arg(expectedList.join(QLatin1String(", "))); + continue; + } + } + return true; - } while (target->at(++position).time == timestamp); + } while (target->at(++position).timestamp() == timestamp); foreach (const QString &message, warnings) qWarning() << message.toLocal8Bit().constData(); @@ -452,49 +440,59 @@ bool tst_QQmlProfilerService::verify(tst_QQmlProfilerService::MessageListType ty QList<QQmlDebugClient *> tst_QQmlProfilerService::createClients() { - m_client = new QQmlProfilerTestClient(m_connection); - return QList<QQmlDebugClient *>({m_client}); + m_client.reset(new QQmlProfilerTestClient(m_connection)); + m_client->client->setRecording(m_recordFromStart); + m_client->client->setFlushInterval(m_flushInterval); + QObject::connect(m_client->client, &QQmlProfilerClient::complete, + this, [this](){ m_isComplete = true; }); + return QList<QQmlDebugClient *>({m_client->client}); } void tst_QQmlProfilerService::cleanup() { + auto log = [this](const QQmlProfilerEvent &data, int i) { + const QQmlProfilerEventType &type = m_client->types.at(data.typeIndex()); + const QQmlProfilerEventLocation location = type.location(); + qDebug() << i << data.timestamp() << type.message() << type.rangeType() << type.detailType() + << location.filename() << location.line() << location.column() + << data.numbers<QVector<qint64>>(); + }; + if (m_client && QTest::currentTestFailed()) { qDebug() << "QML Messages:" << m_client->qmlMessages.count(); int i = 0; - foreach (const QQmlProfilerData &data, m_client->qmlMessages) { - qDebug() << i++ << data.time << data.messageType << data.detailType << data.detailData - << data.line << data.column; - } + for (const QQmlProfilerEvent &data : qAsConst(m_client->qmlMessages)) + log(data, i++); + qDebug() << " "; qDebug() << "JavaScript Messages:" << m_client->javascriptMessages.count(); i = 0; - foreach (const QQmlProfilerData &data, m_client->javascriptMessages) { - qDebug() << i++ << data.time << data.messageType << data.detailType << data.detailData - << data.line << data.column; - } + + for (const QQmlProfilerEvent &data : qAsConst(m_client->javascriptMessages)) + log(data, i++); + qDebug() << " "; qDebug() << "Asynchronous Messages:" << m_client->asynchronousMessages.count(); i = 0; - foreach (const QQmlProfilerData &data, m_client->asynchronousMessages) { - qDebug() << i++ << data.time << data.messageType << data.detailType << data.detailData - << data.framerate << data.animationcount << data.line << data.column; - } + for (const QQmlProfilerEvent &data : qAsConst(m_client->asynchronousMessages)) + log(data, i++); + qDebug() << " "; qDebug() << "Pixmap Cache Messages:" << m_client->pixmapMessages.count(); i = 0; - foreach (const QQmlProfilerData &data, m_client->pixmapMessages) { - qDebug() << i++ << data.time << data.messageType << data.detailType << data.detailData - << data.line << data.column; - } + for (const QQmlProfilerEvent &data : qAsConst(m_client->pixmapMessages)) + log(data, i++); + qDebug() << " "; qDebug() << "Javascript Heap Messages:" << m_client->jsHeapMessages.count(); i = 0; - foreach (const QQmlProfilerData &data, m_client->jsHeapMessages) { - qDebug() << i++ << data.time << data.messageType << data.detailType; - } + for (const QQmlProfilerEvent &data : qAsConst(m_client->jsHeapMessages)) + log(data, i++); + qDebug() << " "; } + m_client.reset(); QQmlDebugTest::cleanup(); } @@ -519,63 +517,62 @@ void tst_QQmlProfilerService::connect() QFETCH(bool, restrictMode); QFETCH(bool, traceEnabled); - QCOMPARE(connect(blockMode, "test.qml", restrictMode), ConnectSuccess); + QCOMPARE(connect(blockMode, "test.qml", traceEnabled, 0, restrictMode), ConnectSuccess); - // if the engine is waiting, then the first message determines if it starts with trace enabled if (!traceEnabled) - m_client->sendRecordingStatus(false); - m_client->sendRecordingStatus(true); - m_client->sendRecordingStatus(false); + m_client->client->setRecording(true); + m_client->client->setRecording(false); checkTraceReceived(); checkJsHeap(); } void tst_QQmlProfilerService::pixmapCacheData() { - QCOMPARE(connect(true, "pixmapCacheTest.qml"), ConnectSuccess); - m_client->sendRecordingStatus(true); - QVERIFY(QQmlDebugTest::waitForSignal(m_process, SIGNAL(readyReadStandardOutput()))); + QCOMPARE(connect(true, "pixmapCacheTest.qml"), ConnectSuccess); + // Don't wait for readyReadStandardOutput before the loop. It may have already arrived. while (m_process->output().indexOf(QLatin1String("image loaded")) == -1 && m_process->output().indexOf(QLatin1String("image error")) == -1) QVERIFY(QQmlDebugTest::waitForSignal(m_process, SIGNAL(readyReadStandardOutput()))); - m_client->sendRecordingStatus(false); + m_client->client->setRecording(false); checkTraceReceived(); checkJsHeap(); - QQmlProfilerData expected(0, QQmlProfilerDefinitions::PixmapCacheEvent); + auto createType = [](QQmlProfilerDefinitions::PixmapEventType type) { + return QQmlProfilerEventType(QQmlProfilerDefinitions::PixmapCacheEvent, + QQmlProfilerDefinitions::MaximumRangeType, type); + }; + + QVector<qint64> numbers; // image starting to load - expected.detailType = QQmlProfilerDefinitions::PixmapLoadingStarted; - VERIFY(MessageListPixmap, 0, expected, CheckMessageType | CheckDetailType); + VERIFY(MessageListPixmap, 0, createType(QQmlProfilerDefinitions::PixmapLoadingStarted), + CheckMessageType | CheckDetailType, numbers); // image size - expected.detailType = QQmlProfilerDefinitions::PixmapSizeKnown; - expected.line = expected.column = 2; // width and height, in fact - VERIFY(MessageListPixmap, 1, expected, - CheckMessageType | CheckDetailType | CheckLine | CheckColumn); + numbers = QVector<qint64>({2, 2, 1}); + VERIFY(MessageListPixmap, 1, createType(QQmlProfilerDefinitions::PixmapSizeKnown), + CheckMessageType | CheckDetailType | CheckNumbers, numbers); // image loaded - expected.detailType = QQmlProfilerDefinitions::PixmapLoadingFinished; - VERIFY(MessageListPixmap, 2, expected, CheckMessageType | CheckDetailType); + VERIFY(MessageListPixmap, 2, createType(QQmlProfilerDefinitions::PixmapLoadingFinished), + CheckMessageType | CheckDetailType, numbers); // cache size - expected.detailType = QQmlProfilerDefinitions::PixmapCacheCountChanged; - VERIFY(MessageListPixmap, 3, expected, CheckMessageType | CheckDetailType); + VERIFY(MessageListPixmap, 3, createType(QQmlProfilerDefinitions::PixmapCacheCountChanged), + CheckMessageType | CheckDetailType, numbers); } void tst_QQmlProfilerService::scenegraphData() { QCOMPARE(connect(true, "scenegraphTest.qml"), ConnectSuccess); - m_client->sendRecordingStatus(true); - while (!m_process->output().contains(QLatin1String("tick"))) QVERIFY(QQmlDebugTest::waitForSignal(m_process, SIGNAL(readyReadStandardOutput()))); - m_client->sendRecordingStatus(false); + m_client->client->setRecording(false); checkTraceReceived(); checkJsHeap(); @@ -591,10 +588,11 @@ void tst_QQmlProfilerService::scenegraphData() qint64 renderFrameTime = -1; #if QT_CONFIG(opengl) //Software renderer doesn't have context frames if (QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL)) { - foreach (const QQmlProfilerData &msg, m_client->asynchronousMessages) { - if (msg.messageType == QQmlProfilerDefinitions::SceneGraphFrame) { - if (msg.detailType == QQmlProfilerDefinitions::SceneGraphContextFrame) { - contextFrameTime = msg.time; + foreach (const QQmlProfilerEvent &msg, m_client->asynchronousMessages) { + const QQmlProfilerEventType &type = m_client->types.at(msg.typeIndex()); + if (type.message() == QQmlProfilerDefinitions::SceneGraphFrame) { + if (type.detailType() == QQmlProfilerDefinitions::SceneGraphContextFrame) { + contextFrameTime = msg.timestamp(); break; } } @@ -603,23 +601,25 @@ void tst_QQmlProfilerService::scenegraphData() QVERIFY(contextFrameTime != -1); } #endif - foreach (const QQmlProfilerData &msg, m_client->asynchronousMessages) { - if (msg.detailType == QQmlProfilerDefinitions::SceneGraphRendererFrame) { - QVERIFY(msg.time >= contextFrameTime); - renderFrameTime = msg.time; + foreach (const QQmlProfilerEvent &msg, m_client->asynchronousMessages) { + const QQmlProfilerEventType &type = m_client->types.at(msg.typeIndex()); + if (type.detailType() == QQmlProfilerDefinitions::SceneGraphRendererFrame) { + QVERIFY(msg.timestamp() >= contextFrameTime); + renderFrameTime = msg.timestamp(); break; } } QVERIFY(renderFrameTime != -1); - foreach (const QQmlProfilerData &msg, m_client->asynchronousMessages) { - if (msg.detailType == QQmlProfilerDefinitions::SceneGraphRenderLoopFrame) { - if (msg.time >= contextFrameTime) { + foreach (const QQmlProfilerEvent &msg, m_client->asynchronousMessages) { + const QQmlProfilerEventType &type = m_client->types.at(msg.typeIndex()); + if (type.detailType() == QQmlProfilerDefinitions::SceneGraphRenderLoopFrame) { + if (msg.timestamp() >= contextFrameTime) { // Make sure SceneGraphRenderLoopFrame is not between SceneGraphContextFrame and // SceneGraphRendererFrame. A SceneGraphRenderLoopFrame before everything else is // OK as the scene graph might decide to do an initial rendering. - QVERIFY(msg.time >= renderFrameTime); + QVERIFY(msg.timestamp() >= renderFrameTime); break; } } @@ -628,9 +628,8 @@ void tst_QQmlProfilerService::scenegraphData() void tst_QQmlProfilerService::profileOnExit() { - QCOMPARE(connect(true, "exit.qml"), ConnectSuccess); - - m_client->sendRecordingStatus(true); + connect(true, "exit.qml"); + checkProcessTerminated(); checkTraceReceived(); checkJsHeap(); @@ -638,9 +637,9 @@ void tst_QQmlProfilerService::profileOnExit() void tst_QQmlProfilerService::controlFromJS() { - QCOMPARE(connect(true, "controlFromJS.qml"), ConnectSuccess); + QCOMPARE(connect(true, "controlFromJS.qml", false), ConnectSuccess); - m_client->sendRecordingStatus(false); + m_client->client->setRecording(false); checkTraceReceived(); checkJsHeap(); } @@ -649,104 +648,97 @@ void tst_QQmlProfilerService::signalSourceLocation() { QCOMPARE(connect(true, "signalSourceLocation.qml"), ConnectSuccess); - m_client->sendRecordingStatus(true); while (!(m_process->output().contains(QLatin1String("500")))) QVERIFY(QQmlDebugTest::waitForSignal(m_process, SIGNAL(readyReadStandardOutput()))); - m_client->sendRecordingStatus(false); + m_client->client->setRecording(false); checkTraceReceived(); checkJsHeap(); - QQmlProfilerData expected(0, QQmlProfilerDefinitions::RangeLocation, - QQmlProfilerDefinitions::HandlingSignal, - QLatin1String("signalSourceLocation.qml")); - expected.line = 8; - expected.column = 28; - VERIFY(MessageListQML, 9, expected, CheckAll); + auto createType = [](int line, int column) { + return QQmlProfilerEventType( + QQmlProfilerDefinitions::MaximumMessage, + QQmlProfilerDefinitions::HandlingSignal, -1, + QQmlProfilerEventLocation(QLatin1String("signalSourceLocation.qml"), line, + column)); + }; - expected.line = 7; - expected.column = 21; - VERIFY(MessageListQML, 11, expected, CheckAll); + VERIFY(MessageListQML, 4, createType(8, 28), CheckType | CheckNumbers, m_rangeStart); + VERIFY(MessageListQML, 6, createType(7, 21), CheckType | CheckNumbers, m_rangeEnd); } void tst_QQmlProfilerService::javascript() { QCOMPARE(connect(true, "javascript.qml"), ConnectSuccess); - m_client->sendRecordingStatus(true); while (!(m_process->output().contains(QLatin1String("done")))) QVERIFY(QQmlDebugTest::waitForSignal(m_process, SIGNAL(readyReadStandardOutput()))); - m_client->sendRecordingStatus(false); + m_client->client->setRecording(false); checkTraceReceived(); checkJsHeap(); - QQmlProfilerData expected(0, QQmlProfilerDefinitions::RangeStart, - QQmlProfilerDefinitions::Javascript); - VERIFY(MessageListJavaScript, 6, expected, CheckMessageType | CheckDetailType); + VERIFY(MessageListJavaScript, 2, QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, + QQmlProfilerDefinitions::Javascript), + CheckMessageType | CheckDetailType | CheckNumbers, m_rangeStart); - expected.messageType = QQmlProfilerDefinitions::RangeLocation; - expected.detailData = QLatin1String("javascript.qml"); - expected.line = 4; - expected.column = 5; - VERIFY(MessageListJavaScript, 7, expected, CheckAll); + VERIFY(MessageListJavaScript, 3, + QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, + QQmlProfilerDefinitions::Javascript, -1, + QQmlProfilerEventLocation(QLatin1String("javascript.qml"), 4, 5)), + CheckType | CheckNumbers, m_rangeStart); - expected.messageType = QQmlProfilerDefinitions::RangeData; - expected.detailData = QLatin1String("something"); - VERIFY(MessageListJavaScript, 8, expected, - CheckMessageType | CheckDetailType | CheckDataEndsWith); + VERIFY(MessageListJavaScript, 4, QQmlProfilerEventType( + QQmlProfilerDefinitions::MaximumMessage, QQmlProfilerDefinitions::Javascript, -1, + QQmlProfilerEventLocation(), QLatin1String("something")), + CheckMessageType | CheckDetailType | CheckDataEndsWith | CheckNumbers, m_rangeStart); - expected.messageType = QQmlProfilerDefinitions::RangeEnd; - VERIFY(MessageListJavaScript, 21, expected, CheckMessageType | CheckDetailType); + VERIFY(MessageListJavaScript, 10, QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, + QQmlProfilerDefinitions::Javascript), + CheckMessageType | CheckDetailType | CheckNumbers, m_rangeEnd); } void tst_QQmlProfilerService::flushInterval() { - QCOMPARE(connect(true, "timer.qml"), ConnectSuccess); - - m_client->sendRecordingStatus(true, -1, 1); + QCOMPARE(connect(true, "timer.qml", true, 1), ConnectSuccess); // Make sure we get multiple messages QTRY_VERIFY(m_client->qmlMessages.length() > 0); QVERIFY(m_client->qmlMessages.length() < 100); QTRY_VERIFY(m_client->qmlMessages.length() > 100); - m_client->sendRecordingStatus(false); + m_client->client->setRecording(false); checkTraceReceived(); checkJsHeap(); } void tst_QQmlProfilerService::translationBinding() { - QCOMPARE(connect(true, "qstr.qml"), ConnectSuccess); - - m_client->sendRecordingStatus(true); + connect(true, "qstr.qml"); + checkProcessTerminated(); checkTraceReceived(); checkJsHeap(); - QQmlProfilerData expected(0, QQmlProfilerDefinitions::RangeStart, - QQmlProfilerDefinitions::Binding); - VERIFY(MessageListQML, 8, expected, - CheckDetailType | CheckMessageType); + const QQmlProfilerEventType type(QQmlProfilerDefinitions::MaximumMessage, + QQmlProfilerDefinitions::Binding); - expected.messageType = QQmlProfilerDefinitions::RangeEnd; - VERIFY(MessageListQML, 10, expected, - CheckDetailType | CheckMessageType); + VERIFY(MessageListQML, 4, type, CheckDetailType | CheckMessageType | CheckNumbers, + m_rangeStart); + VERIFY(MessageListQML, 5, type, CheckDetailType | CheckMessageType | CheckNumbers, + m_rangeEnd); } void tst_QQmlProfilerService::memory() { connect(true, "memory.qml"); - if (QTest::currentTestFailed() || QTestResult::skipCurrentTest()) - return; - - m_client->sendRecordingStatus(true); + checkProcessTerminated(); checkTraceReceived(); checkJsHeap(); int smallItems = 0; for (auto message : m_client->jsHeapMessages) { - if (message.detailType == QV4::Profiling::SmallItem) + const QQmlProfilerEventType &type = m_client->types[message.typeIndex()]; + if (type.detailType() == QV4::Profiling::SmallItem) ++smallItems; } diff --git a/tools/qmlprofiler/qmlprofilerapplication.cpp b/tools/qmlprofiler/qmlprofilerapplication.cpp index 033492b516..0b0417bd7d 100644 --- a/tools/qmlprofiler/qmlprofilerapplication.cpp +++ b/tools/qmlprofiler/qmlprofilerapplication.cpp @@ -83,24 +83,27 @@ QmlProfilerApplication::QmlProfilerApplication(int &argc, char **argv) : m_verbose(false), m_recording(true), m_interactive(false), - m_qmlProfilerClient(&m_connection, &m_profilerData), m_connectionAttempts(0) { + m_connection.reset(new QQmlDebugConnection); + m_profilerData.reset(new QmlProfilerData); + m_qmlProfilerClient.reset(new QmlProfilerClient(m_connection.data(), m_profilerData.data())); m_connectTimer.setInterval(1000); connect(&m_connectTimer, &QTimer::timeout, this, &QmlProfilerApplication::tryToConnect); - connect(&m_connection, &QQmlDebugConnection::connected, + connect(m_connection.data(), &QQmlDebugConnection::connected, this, &QmlProfilerApplication::connected); - connect(&m_qmlProfilerClient, &QmlProfilerClient::enabledChanged, + connect(m_qmlProfilerClient.data(), &QmlProfilerClient::enabledChanged, this, &QmlProfilerApplication::traceClientEnabledChanged); - connect(&m_qmlProfilerClient, &QmlProfilerClient::recordingStarted, + connect(m_qmlProfilerClient.data(), &QmlProfilerClient::traceStarted, this, &QmlProfilerApplication::notifyTraceStarted); - connect(&m_qmlProfilerClient, &QmlProfilerClient::error, + connect(m_qmlProfilerClient.data(), &QmlProfilerClient::error, this, &QmlProfilerApplication::logError); - connect(&m_profilerData, &QmlProfilerData::error, this, &QmlProfilerApplication::logError); - connect(&m_profilerData, &QmlProfilerData::dataReady, + connect(m_profilerData.data(), &QmlProfilerData::error, + this, &QmlProfilerApplication::logError); + connect(m_profilerData.data(), &QmlProfilerData::dataReady, this, &QmlProfilerApplication::traceFinished); } @@ -239,7 +242,7 @@ void QmlProfilerApplication::parseArguments() if (features == 0) parser.showHelp(4); - m_qmlProfilerClient.setFeatures(features); + m_qmlProfilerClient->setRequestedFeatures(features); if (parser.isSet(verbose)) m_verbose = true; @@ -295,10 +298,10 @@ void QmlProfilerApplication::flush() { if (m_recording) { m_pendingRequest = REQUEST_FLUSH; - m_qmlProfilerClient.sendRecordingStatus(false); + m_qmlProfilerClient->sendRecordingStatus(false); } else { - if (m_profilerData.save(m_interactiveOutputFile)) { - m_profilerData.clear(); + if (m_profilerData->save(m_interactiveOutputFile)) { + m_profilerData->clear(); if (!m_interactiveOutputFile.isEmpty()) prompt(tr("Data written to %1.").arg(m_interactiveOutputFile)); else @@ -313,7 +316,7 @@ void QmlProfilerApplication::flush() void QmlProfilerApplication::output() { - if (m_profilerData.save(m_interactiveOutputFile)) { + if (m_profilerData->save(m_interactiveOutputFile)) { if (!m_interactiveOutputFile.isEmpty()) prompt(tr("Data written to %1.").arg(m_interactiveOutputFile)); else @@ -385,12 +388,12 @@ void QmlProfilerApplication::userCommand(const QString &command) if (cmd == Constants::CMD_RECORD || cmd == Constants::CMD_RECORD2) { m_pendingRequest = REQUEST_TOGGLE_RECORDING; - m_qmlProfilerClient.sendRecordingStatus(!m_recording); + m_qmlProfilerClient->sendRecordingStatus(!m_recording); } else if (cmd == Constants::CMD_QUIT || cmd == Constants::CMD_QUIT2) { m_pendingRequest = REQUEST_QUIT; if (m_recording) { prompt(tr("The application is still generating data. Really quit (y/n)?")); - } else if (!m_profilerData.isEmpty()) { + } else if (!m_profilerData->isEmpty()) { prompt(tr("There is still trace data in memory. Really quit (y/n)?")); } else { quit(); @@ -398,7 +401,7 @@ void QmlProfilerApplication::userCommand(const QString &command) } else if (cmd == Constants::CMD_OUTPUT || cmd == Constants::CMD_OUTPUT2) { if (m_recording) { prompt(tr("Cannot output while recording data.")); - } else if (m_profilerData.isEmpty()) { + } else if (m_profilerData->isEmpty()) { prompt(tr("No data was recorded so far.")); } else { m_interactiveOutputFile = args.length() > 0 ? args.at(0).toString() : m_outputFile; @@ -408,14 +411,14 @@ void QmlProfilerApplication::userCommand(const QString &command) } else if (cmd == Constants::CMD_CLEAR || cmd == Constants::CMD_CLEAR2) { if (m_recording) { prompt(tr("Cannot clear data while recording.")); - } else if (m_profilerData.isEmpty()) { + } else if (m_profilerData->isEmpty()) { prompt(tr("No data was recorded so far.")); } else { - m_profilerData.clear(); + m_profilerData->clear(); prompt(tr("Trace data cleared.")); } } else if (cmd == Constants::CMD_FLUSH || cmd == Constants::CMD_FLUSH2) { - if (!m_recording && m_profilerData.isEmpty()) { + if (!m_recording && m_profilerData->isEmpty()) { prompt(tr("No data was recorded so far.")); } else { m_interactiveOutputFile = args.length() > 0 ? args.at(0).toString() : m_outputFile; @@ -443,9 +446,9 @@ void QmlProfilerApplication::notifyTraceStarted() void QmlProfilerApplication::outputData() { - if (!m_profilerData.isEmpty()) { - m_profilerData.save(m_outputFile); - m_profilerData.clear(); + if (!m_profilerData->isEmpty()) { + m_profilerData->save(m_outputFile); + m_profilerData->clear(); } } @@ -454,7 +457,7 @@ void QmlProfilerApplication::run() if (m_runMode == LaunchMode) { if (!m_socketFile.isEmpty()) { logStatus(QString::fromLatin1("Listening on %1 ...").arg(m_socketFile)); - m_connection.startLocalServer(m_socketFile); + m_connection->startLocalServer(m_socketFile); } m_process = new QProcess(this); QStringList arguments; @@ -481,7 +484,7 @@ void QmlProfilerApplication::run() void QmlProfilerApplication::tryToConnect() { - Q_ASSERT(!m_connection.isConnected()); + Q_ASSERT(!m_connection->isConnected()); ++ m_connectionAttempts; if (!m_verbose && !(m_connectionAttempts % 5)) {// print every 5 seconds @@ -497,7 +500,7 @@ void QmlProfilerApplication::tryToConnect() if (m_socketFile.isEmpty()) { logStatus(QString::fromLatin1("Connecting to %1:%2 ...").arg(m_hostName).arg(m_port)); - m_connection.connectToHost(m_hostName, m_port); + m_connection->connectToHost(m_hostName, m_port); } } @@ -538,7 +541,7 @@ void QmlProfilerApplication::processFinished() if (!m_interactive) exit(exitCode); else - m_qmlProfilerClient.clearPendingData(); + m_qmlProfilerClient->clearAll(); } void QmlProfilerApplication::traceClientEnabledChanged(bool enabled) @@ -547,7 +550,7 @@ void QmlProfilerApplication::traceClientEnabledChanged(bool enabled) logStatus("Trace client is attached."); // blocked server is waiting for recording message from both clients // once the last one is connected, both messages should be sent - m_qmlProfilerClient.sendRecordingStatus(m_recording); + m_qmlProfilerClient->setRecording(m_recording); } } @@ -564,7 +567,7 @@ void QmlProfilerApplication::traceFinished() prompt(tr("Application stopped recording."), false); } - m_qmlProfilerClient.clearPendingData(); + m_qmlProfilerClient->clearEvents(); } void QmlProfilerApplication::prompt(const QString &line, bool ready) diff --git a/tools/qmlprofiler/qmlprofilerapplication.h b/tools/qmlprofiler/qmlprofilerapplication.h index 13f0f041f0..f7a8efd61b 100644 --- a/tools/qmlprofiler/qmlprofilerapplication.h +++ b/tools/qmlprofiler/qmlprofilerapplication.h @@ -105,9 +105,9 @@ private: bool m_recording; bool m_interactive; - QQmlDebugConnection m_connection; - QmlProfilerClient m_qmlProfilerClient; - QmlProfilerData m_profilerData; + QScopedPointer<QQmlDebugConnection> m_connection; + QScopedPointer<QmlProfilerClient> m_qmlProfilerClient; + QScopedPointer<QmlProfilerData> m_profilerData; QTimer m_connectTimer; uint m_connectionAttempts; }; diff --git a/tools/qmlprofiler/qmlprofilerclient.cpp b/tools/qmlprofiler/qmlprofilerclient.cpp index 0c031db914..b69c7e73e1 100644 --- a/tools/qmlprofiler/qmlprofilerclient.cpp +++ b/tools/qmlprofiler/qmlprofilerclient.cpp @@ -43,36 +43,26 @@ public: QmlProfilerClientPrivate(QQmlDebugConnection *connection, QmlProfilerData *data); QmlProfilerData *data; - - qint64 inProgressRanges; - QStack<qint64> rangeStartTimes[QQmlProfilerDefinitions::MaximumRangeType]; - QStack<QStringList> rangeDatas[QQmlProfilerDefinitions::MaximumRangeType]; - QStack<QQmlEventLocation> rangeLocations[QQmlProfilerDefinitions::MaximumRangeType]; - int rangeCount[QQmlProfilerDefinitions::MaximumRangeType]; - bool enabled; }; QmlProfilerClientPrivate::QmlProfilerClientPrivate(QQmlDebugConnection *connection, QmlProfilerData *data) : - QQmlProfilerClientPrivate(connection), data(data), inProgressRanges(0), enabled(false) + QQmlProfilerClientPrivate(connection, data), data(data), enabled(false) { - ::memset(rangeCount, 0, QQmlProfilerDefinitions::MaximumRangeType * sizeof(int)); } QmlProfilerClient::QmlProfilerClient(QQmlDebugConnection *connection, QmlProfilerData *data) : QQmlProfilerClient(*(new QmlProfilerClientPrivate(connection, data))) { -} - -void QmlProfilerClient::clearPendingData() -{ Q_D(QmlProfilerClient); - for (int i = 0; i < QQmlProfilerDefinitions::MaximumRangeType; ++i) { - d->rangeCount[i] = 0; - d->rangeDatas[i].clear(); - d->rangeLocations[i].clear(); - } + setRequestedFeatures(std::numeric_limits<quint64>::max()); + connect(this, &QQmlProfilerClient::traceStarted, + d->data, &QmlProfilerData::setTraceStartTime); + connect(this, &QQmlProfilerClient::traceFinished, + d->data, &QmlProfilerData::setTraceEndTime); + connect(this, &QQmlProfilerClient::complete, + d->data, &QmlProfilerData::complete); } void QmlProfilerClient::stateChanged(State state) @@ -84,119 +74,4 @@ void QmlProfilerClient::stateChanged(State state) } } -void QmlProfilerClient::traceStarted(qint64 time, int engineId) -{ - Q_UNUSED(engineId); - Q_D(QmlProfilerClient); - d->data->setTraceStartTime(time); - emit recordingStarted(); -} - -void QmlProfilerClient::traceFinished(qint64 time, int engineId) -{ - Q_UNUSED(engineId); - Q_D(QmlProfilerClient); - d->data->setTraceEndTime(time); -} - -void QmlProfilerClient::rangeStart(QQmlProfilerDefinitions::RangeType type, qint64 startTime) -{ - Q_D(QmlProfilerClient); - d->rangeStartTimes[type].push(startTime); - d->inProgressRanges |= (static_cast<qint64>(1) << type); - ++d->rangeCount[type]; -} - -void QmlProfilerClient::rangeData(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QString &data) -{ - Q_UNUSED(time); - Q_D(QmlProfilerClient); - int count = d->rangeCount[type]; - if (count > 0) { - while (d->rangeDatas[type].count() < count) - d->rangeDatas[type].push(QStringList()); - d->rangeDatas[type][count - 1] << data; - } -} - -void QmlProfilerClient::rangeLocation(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QQmlEventLocation &location) -{ - Q_UNUSED(time); - Q_D(QmlProfilerClient); - if (d->rangeCount[type] > 0) - d->rangeLocations[type].push(location); -} - -void QmlProfilerClient::rangeEnd(QQmlProfilerDefinitions::RangeType type, qint64 endTime) -{ - Q_D(QmlProfilerClient); - - if (d->rangeCount[type] == 0) { - emit error(tr("Spurious range end detected.")); - return; - } - - --d->rangeCount[type]; - if (d->inProgressRanges & (static_cast<qint64>(1) << type)) - d->inProgressRanges &= ~(static_cast<qint64>(1) << type); - QStringList data = d->rangeDatas[type].count() ? d->rangeDatas[type].pop() : QStringList(); - QQmlEventLocation location = d->rangeLocations[type].count() ? d->rangeLocations[type].pop() : - QQmlEventLocation(); - qint64 startTime = d->rangeStartTimes[type].pop(); - - if (d->rangeCount[type] == 0 && d->rangeDatas[type].count() + d->rangeStartTimes[type].count() - + d->rangeLocations[type].count() != 0) { - emit error(tr("Incorrectly nested range data")); - return; - } - - d->data->addQmlEvent(type, QQmlProfilerDefinitions::QmlBinding, startTime, endTime - startTime, - data, location); -} - -void QmlProfilerClient::animationFrame(qint64 time, int frameRate, int animationCount, int threadId) -{ - Q_D(QmlProfilerClient); - d->data->addFrameEvent(time, frameRate, animationCount, threadId); -} - -void QmlProfilerClient::sceneGraphEvent(QQmlProfilerDefinitions::SceneGraphFrameType type, - qint64 time, qint64 numericData1, qint64 numericData2, - qint64 numericData3, qint64 numericData4, - qint64 numericData5) -{ - Q_D(QmlProfilerClient); - d->data->addSceneGraphFrameEvent(type, time, numericData1, numericData2, numericData3, - numericData4, numericData5); -} - -void QmlProfilerClient::pixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type, qint64 time, - const QString &url, int numericData1, int numericData2) -{ - Q_D(QmlProfilerClient); - d->data->addPixmapCacheEvent(type, time, url, numericData1, numericData2); -} - -void QmlProfilerClient::memoryAllocation(QQmlProfilerDefinitions::MemoryType type, qint64 time, - qint64 amount) -{ - Q_D(QmlProfilerClient); - d->data->addMemoryEvent(type, time, amount); -} - -void QmlProfilerClient::inputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time, - int a, int b) -{ - Q_D(QmlProfilerClient); - d->data->addInputEvent(type, time, a, b); -} - -void QmlProfilerClient::complete() -{ - Q_D(QmlProfilerClient); - d->data->complete(); -} - #include "moc_qmlprofilerclient.cpp" diff --git a/tools/qmlprofiler/qmlprofilerclient.h b/tools/qmlprofiler/qmlprofilerclient.h index a04a412bb0..b9d8ce241f 100644 --- a/tools/qmlprofiler/qmlprofilerclient.h +++ b/tools/qmlprofiler/qmlprofilerclient.h @@ -29,9 +29,9 @@ #ifndef QMLPROFILERCLIENT_H #define QMLPROFILERCLIENT_H -#include <private/qqmleventlocation_p.h> #include <private/qqmlprofilerclient_p.h> #include <private/qqmlprofilerdefinitions_p.h> +#include <private/qqmlprofilereventlocation_p.h> class QmlProfilerData; class QmlProfilerClientPrivate; @@ -42,32 +42,13 @@ class QmlProfilerClient : public QQmlProfilerClient public: QmlProfilerClient(QQmlDebugConnection *connection, QmlProfilerData *data); - void clearPendingData(); signals: void enabledChanged(bool enabled); - void recordingStarted(); void error(const QString &error); private: void stateChanged(State state) override; - - void traceStarted(qint64 time, int engineId) override; - void traceFinished(qint64 time, int engineId) override; - void rangeStart(QQmlProfilerDefinitions::RangeType type, qint64 startTime) override; - void rangeData(QQmlProfilerDefinitions::RangeType type, qint64 time, const QString &data) override; - void rangeLocation(QQmlProfilerDefinitions::RangeType type, qint64 time, - const QQmlEventLocation &location) override; - void rangeEnd(QQmlProfilerDefinitions::RangeType type, qint64 endTime) override; - void animationFrame(qint64 time, int frameRate, int animationCount, int threadId) override; - void sceneGraphEvent(QQmlProfilerDefinitions::SceneGraphFrameType type, qint64 time, - qint64 numericData1, qint64 numericData2, qint64 numericData3, - qint64 numericData4, qint64 numericData5) override; - void pixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type, qint64 time, - const QString &url, int numericData1, int numericData2) override; - void memoryAllocation(QQmlProfilerDefinitions::MemoryType type, qint64 time, qint64 amount) override; - void inputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time, int a, int b) override; - void complete() override; }; #endif // QMLPROFILERCLIENT_H diff --git a/tools/qmlprofiler/qmlprofilerdata.cpp b/tools/qmlprofiler/qmlprofilerdata.cpp index 7dcfa4cdaa..32e03298da 100644 --- a/tools/qmlprofiler/qmlprofilerdata.cpp +++ b/tools/qmlprofiler/qmlprofilerdata.cpp @@ -34,6 +34,8 @@ #include <QFile> #include <QXmlStreamReader> #include <QRegularExpression> +#include <QQueue> +#include <QStack> #include <limits> @@ -60,72 +62,13 @@ static const char *MESSAGE_STRINGS[] = { "Complete", "PixmapCache", "SceneGraph", - "MemoryAllocation" + "MemoryAllocation", + "DebugMessage" }; Q_STATIC_ASSERT(sizeof(MESSAGE_STRINGS) == QQmlProfilerDefinitions::MaximumMessage * sizeof(const char *)); -struct QmlRangeEventData { - QmlRangeEventData() {} // never called - QmlRangeEventData(const QString &_displayName, int _detailType, const QString &_eventHashStr, - const QQmlEventLocation &_location, const QString &_details, - QQmlProfilerDefinitions::Message _message, - QQmlProfilerDefinitions::RangeType _rangeType) - : displayName(_displayName), eventHashStr(_eventHashStr), location(_location), - details(_details), message(_message), rangeType(_rangeType), detailType(_detailType) {} - QString displayName; - QString eventHashStr; - QQmlEventLocation location; - QString details; - QQmlProfilerDefinitions::Message message; - QQmlProfilerDefinitions::RangeType rangeType; - int detailType; // can be BindingType, PixmapCacheEventType or SceneGraphFrameType -}; - -struct QmlRangeEventStartInstance { - QmlRangeEventStartInstance() {} // never called - QmlRangeEventStartInstance(qint64 _startTime, qint64 _duration, int _frameRate, - int _animationCount, int _threadId, QmlRangeEventData *_data) - : startTime(_startTime), duration(_duration), frameRate(_frameRate), - animationCount(_animationCount), threadId(_threadId), numericData4(-1), numericData5(-1), - data(_data) - { } - - QmlRangeEventStartInstance(qint64 _startTime, qint64 _numericData1, qint64 _numericData2, - qint64 _numericData3, qint64 _numericData4, qint64 _numericData5, - QmlRangeEventData *_data) - : startTime(_startTime), duration(-1), numericData1(_numericData1), - numericData2(_numericData2), numericData3(_numericData3), numericData4(_numericData4), - numericData5(_numericData5), data(_data) - { } - qint64 startTime; - qint64 duration; - union { - int frameRate; - int inputType; - qint64 numericData1; - }; - union { - int animationCount; - int inputA; - qint64 numericData2; - }; - union { - int threadId; - int inputB; - qint64 numericData3; - }; - qint64 numericData4; - qint64 numericData5; - QmlRangeEventData *data; -}; - -QT_BEGIN_NAMESPACE -Q_DECLARE_TYPEINFO(QmlRangeEventData, Q_MOVABLE_TYPE); -Q_DECLARE_TYPEINFO(QmlRangeEventStartInstance, Q_MOVABLE_TYPE); -QT_END_NAMESPACE - ///////////////////////////////////////////////////////////////// class QmlProfilerDataPrivate { @@ -133,8 +76,8 @@ public: QmlProfilerDataPrivate(QmlProfilerData *qq){ Q_UNUSED(qq); } // data storage - QHash<QString, QmlRangeEventData *> eventDescriptions; - QVector<QmlRangeEventStartInstance> startInstanceList; + QVector<QQmlProfilerEventType> eventTypes; + QVector<QQmlProfilerEvent> events; qint64 traceStartTime; qint64 traceEndTime; @@ -146,7 +89,7 @@ public: ///////////////////////////////////////////////////////////////// QmlProfilerData::QmlProfilerData(QObject *parent) : - QObject(parent),d(new QmlProfilerDataPrivate(this)) + QQmlProfilerEventReceiver(parent), d(new QmlProfilerDataPrivate(this)) { d->state = Empty; clear(); @@ -160,9 +103,8 @@ QmlProfilerData::~QmlProfilerData() void QmlProfilerData::clear() { - qDeleteAll(d->eventDescriptions); - d->eventDescriptions.clear(); - d->startInstanceList.clear(); + d->eventTypes.clear(); + d->events.clear(); d->traceEndTime = std::numeric_limits<qint64>::min(); d->traceStartTime = std::numeric_limits<qint64>::max(); @@ -171,15 +113,6 @@ void QmlProfilerData::clear() setState(Empty); } -QString QmlProfilerData::getHashStringForQmlEvent(const QQmlEventLocation &location, int eventType) -{ - return QString(QStringLiteral("%1:%2:%3:%4")).arg( - location.filename, - QString::number(location.line), - QString::number(location.column), - QString::number(eventType)); -} - QString QmlProfilerData::qmlRangeTypeAsString(QQmlProfilerDefinitions::RangeType type) { if (type * sizeof(char *) < sizeof(RANGE_TYPE_STRINGS)) @@ -218,20 +151,20 @@ qint64 QmlProfilerData::traceEndTime() const return d->traceEndTime; } -void QmlProfilerData::addQmlEvent(QQmlProfilerDefinitions::RangeType type, - QQmlProfilerDefinitions::BindingType bindingType, - qint64 startTime, - qint64 duration, - const QStringList &data, - const QQmlEventLocation &location) +void QmlProfilerData::addEvent(const QQmlProfilerEvent &event) { setState(AcquiringData); + d->events.append(event); +} + +void QmlProfilerData::addEventType(const QQmlProfilerEventType &type) +{ + QQmlProfilerEventType newType = type; QString details; // generate details string - if (!data.isEmpty()) { - details = data.join(QLatin1Char(' ')).replace( - QLatin1Char('\n'), QLatin1Char(' ')).simplified(); + if (!type.data().isEmpty()) { + details = type.data().simplified(); QRegularExpression rewrite(QStringLiteral("^\\(function \\$(\\w+)\\(\\) \\{ (return |)(.+) \\}\\)$")); QRegularExpressionMatch match = rewrite.match(details); if (match.hasMatch()) { @@ -241,223 +174,132 @@ void QmlProfilerData::addQmlEvent(QQmlProfilerDefinitions::RangeType type, details = details.mid(details.lastIndexOf(QLatin1Char('/')) + 1); } - QQmlEventLocation eventLocation = location; - QString displayName, eventHashStr; - // generate hash - if (eventLocation.filename.isEmpty()) { - displayName = tr("<bytecode>"); - eventHashStr = getHashStringForQmlEvent(eventLocation, type); - } else { - const QString filePath = QUrl(eventLocation.filename).path(); - displayName = filePath.midRef( - filePath.lastIndexOf(QLatin1Char('/')) + 1) + - QLatin1Char(':') + QString::number(eventLocation.line); - eventHashStr = getHashStringForQmlEvent(eventLocation, type); - } - - QmlRangeEventData *newEvent; - if (d->eventDescriptions.contains(eventHashStr)) { - newEvent = d->eventDescriptions[eventHashStr]; - } else { - newEvent = new QmlRangeEventData(displayName, bindingType, eventHashStr, location, details, - QQmlProfilerDefinitions::MaximumMessage, type); - d->eventDescriptions.insert(eventHashStr, newEvent); - } - - QmlRangeEventStartInstance rangeEventStartInstance(startTime, duration, -1, -1, -1, newEvent); - - d->startInstanceList.append(rangeEventStartInstance); -} - -void QmlProfilerData::addFrameEvent(qint64 time, int framerate, int animationcount, int threadId) -{ - setState(AcquiringData); - - QString details = tr("Animation Timer Update"); - QString displayName = tr("<Animation Update>"); - QString eventHashStr = displayName; - - QmlRangeEventData *newEvent; - if (d->eventDescriptions.contains(eventHashStr)) { - newEvent = d->eventDescriptions[eventHashStr]; - } else { - newEvent = new QmlRangeEventData(displayName, QQmlProfilerDefinitions::AnimationFrame, - eventHashStr, - QQmlEventLocation(), details, - QQmlProfilerDefinitions::Event, - QQmlProfilerDefinitions::MaximumRangeType); - d->eventDescriptions.insert(eventHashStr, newEvent); - } - - QmlRangeEventStartInstance rangeEventStartInstance(time, -1, framerate, animationcount, - threadId, newEvent); - - d->startInstanceList.append(rangeEventStartInstance); -} - -void QmlProfilerData::addSceneGraphFrameEvent(QQmlProfilerDefinitions::SceneGraphFrameType type, - qint64 time, qint64 numericData1, qint64 numericData2, - qint64 numericData3, qint64 numericData4, - qint64 numericData5) -{ - setState(AcquiringData); - - QString eventHashStr = QString::fromLatin1("SceneGraph:%1").arg(type); - QmlRangeEventData *newEvent; - if (d->eventDescriptions.contains(eventHashStr)) { - newEvent = d->eventDescriptions[eventHashStr]; - } else { - newEvent = new QmlRangeEventData(QStringLiteral("<SceneGraph>"), type, eventHashStr, - QQmlEventLocation(), QString(), - QQmlProfilerDefinitions::SceneGraphFrame, - QQmlProfilerDefinitions::MaximumRangeType); - d->eventDescriptions.insert(eventHashStr, newEvent); - } + newType.setData(details); - QmlRangeEventStartInstance rangeEventStartInstance(time, numericData1, numericData2, - numericData3, numericData4, numericData5, - newEvent); - d->startInstanceList.append(rangeEventStartInstance); -} - -void QmlProfilerData::addPixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type, - qint64 time, const QString &location, - int numericData1, int numericData2) -{ - setState(AcquiringData); - - QString filePath = QUrl(location).path(); - - const QString eventHashStr = filePath.midRef(filePath.lastIndexOf(QLatin1Char('/')) + 1) - + QLatin1Char(':') + QString::number(type); - QmlRangeEventData *newEvent; - if (d->eventDescriptions.contains(eventHashStr)) { - newEvent = d->eventDescriptions[eventHashStr]; - } else { - newEvent = new QmlRangeEventData(eventHashStr, type, eventHashStr, - QQmlEventLocation(location, -1, -1), QString(), - QQmlProfilerDefinitions::PixmapCacheEvent, - QQmlProfilerDefinitions::MaximumRangeType); - d->eventDescriptions.insert(eventHashStr, newEvent); + QString displayName; + switch (type.message()) { + case QQmlProfilerDefinitions::Event: { + switch (type.detailType()) { + case QQmlProfilerDefinitions::Mouse: + case QQmlProfilerDefinitions::Key: + displayName = QString::fromLatin1("Input:%1").arg(type.detailType()); + break; + case QQmlProfilerDefinitions::AnimationFrame: + displayName = QString::fromLatin1("AnimationFrame"); + break; + default: + displayName = QString::fromLatin1("Unknown"); + } + break; } - - QmlRangeEventStartInstance rangeEventStartInstance(time, numericData1, numericData2, 0, 0, 0, - newEvent); - d->startInstanceList.append(rangeEventStartInstance); -} - -void QmlProfilerData::addMemoryEvent(QQmlProfilerDefinitions::MemoryType type, qint64 time, - qint64 size) -{ - setState(AcquiringData); - QString eventHashStr = QString::fromLatin1("MemoryAllocation:%1").arg(type); - QmlRangeEventData *newEvent; - if (d->eventDescriptions.contains(eventHashStr)) { - newEvent = d->eventDescriptions[eventHashStr]; - } else { - newEvent = new QmlRangeEventData(eventHashStr, type, eventHashStr, QQmlEventLocation(), - QString(), QQmlProfilerDefinitions::MemoryAllocation, - QQmlProfilerDefinitions::MaximumRangeType); - d->eventDescriptions.insert(eventHashStr, newEvent); + case QQmlProfilerDefinitions::RangeStart: + case QQmlProfilerDefinitions::RangeData: + case QQmlProfilerDefinitions::RangeLocation: + case QQmlProfilerDefinitions::RangeEnd: + case QQmlProfilerDefinitions::Complete: + Q_UNREACHABLE(); + break; + case QQmlProfilerDefinitions::PixmapCacheEvent: { + const QString filePath = QUrl(type.location().filename()).path(); + displayName = filePath.midRef(filePath.lastIndexOf(QLatin1Char('/')) + 1) + + QLatin1Char(':') + QString::number(type.detailType()); + break; } - QmlRangeEventStartInstance rangeEventStartInstance(time, size, 0, 0, 0, 0, newEvent); - d->startInstanceList.append(rangeEventStartInstance); -} - -void QmlProfilerData::addInputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time, - int a, int b) -{ - setState(AcquiringData); - - QQmlProfilerDefinitions::EventType eventType; - switch (type) { - case QQmlProfilerDefinitions::InputKeyPress: - case QQmlProfilerDefinitions::InputKeyRelease: - case QQmlProfilerDefinitions::InputKeyUnknown: - eventType = QQmlProfilerDefinitions::Key; + case QQmlProfilerDefinitions::SceneGraphFrame: + displayName = QString::fromLatin1("SceneGraph:%1").arg(type.detailType()); break; - default: - eventType = QQmlProfilerDefinitions::Mouse; + case QQmlProfilerDefinitions::MemoryAllocation: + displayName = QString::fromLatin1("MemoryAllocation:%1").arg(type.detailType()); + break; + case QQmlProfilerDefinitions::DebugMessage: + displayName = QString::fromLatin1("DebugMessage:%1").arg(type.detailType()); + break; + case QQmlProfilerDefinitions::MaximumMessage: { + const QQmlProfilerEventLocation eventLocation = type.location(); + // generate hash + if (eventLocation.filename().isEmpty()) { + displayName = QString::fromLatin1("Unknown"); + } else { + const QString filePath = QUrl(eventLocation.filename()).path(); + displayName = filePath.midRef( + filePath.lastIndexOf(QLatin1Char('/')) + 1) + + QLatin1Char(':') + QString::number(eventLocation.line()); + } break; } - - QString eventHashStr = QString::fromLatin1("Input:%1").arg(eventType); - - QmlRangeEventData *newEvent; - if (d->eventDescriptions.contains(eventHashStr)) { - newEvent = d->eventDescriptions[eventHashStr]; - } else { - newEvent = new QmlRangeEventData(QString(), eventType, eventHashStr, QQmlEventLocation(), - QString(), QQmlProfilerDefinitions::Event, - QQmlProfilerDefinitions::MaximumRangeType); - d->eventDescriptions.insert(eventHashStr, newEvent); } - d->startInstanceList.append(QmlRangeEventStartInstance(time, -1, type, a, b, newEvent)); + newType.setDisplayName(displayName); + d->eventTypes.append(newType); } void QmlProfilerData::computeQmlTime() { // compute levels - QHash<int, qint64> endtimesPerLevel; - int minimumLevel = 1; - int level = minimumLevel; - - for (int i = 0; i < d->startInstanceList.count(); i++) { - qint64 st = d->startInstanceList.at(i).startTime; + qint64 level0Start = -1; + int level = 0; - if (d->startInstanceList.at(i).data->rangeType == QQmlProfilerDefinitions::Painting) { + for (const QQmlProfilerEvent &event : qAsConst(d->events)) { + const QQmlProfilerEventType &type = d->eventTypes.at(event.typeIndex()); + if (type.message() != QQmlProfilerDefinitions::MaximumMessage) continue; - } - - // general level - if (endtimesPerLevel.value(level) > st) { - level++; - } else { - while (level > minimumLevel && endtimesPerLevel[level-1] <= st) - level--; - } - endtimesPerLevel[level] = st + d->startInstanceList.at(i).duration; - if (level == minimumLevel) { - d->qmlMeasuredTime += d->startInstanceList.at(i).duration; + switch (type.rangeType()) { + case QQmlProfilerDefinitions::Compiling: + case QQmlProfilerDefinitions::Creating: + case QQmlProfilerDefinitions::Binding: + case QQmlProfilerDefinitions::HandlingSignal: + case QQmlProfilerDefinitions::Javascript: + switch (event.rangeStage()) { + case QQmlProfilerDefinitions::RangeStart: + if (level++ == 0) + level0Start = event.timestamp(); + break; + case QQmlProfilerDefinitions::RangeEnd: + if (--level == 0) + d->qmlMeasuredTime += event.timestamp() - level0Start; + break; + default: + break; + } + break; + default: + break; } } } -bool compareStartTimes(const QmlRangeEventStartInstance &t1, const QmlRangeEventStartInstance &t2) +bool compareStartTimes(const QQmlProfilerEvent &t1, const QQmlProfilerEvent &t2) { - return t1.startTime < t2.startTime; + return t1.timestamp() < t2.timestamp(); } void QmlProfilerData::sortStartTimes() { - if (d->startInstanceList.count() < 2) + if (d->events.count() < 2) return; // assuming startTimes is partially sorted // identify blocks of events and sort them with quicksort - QVector<QmlRangeEventStartInstance>::iterator itFrom = d->startInstanceList.end() - 2; - QVector<QmlRangeEventStartInstance>::iterator itTo = d->startInstanceList.end() - 1; + QVector<QQmlProfilerEvent>::iterator itFrom = d->events.end() - 2; + QVector<QQmlProfilerEvent>::iterator itTo = d->events.end() - 1; - while (itFrom != d->startInstanceList.begin() && itTo != d->startInstanceList.begin()) { + while (itFrom != d->events.begin() && itTo != d->events.begin()) { // find block to sort - while ( itFrom != d->startInstanceList.begin() - && itTo->startTime > itFrom->startTime ) { + while (itFrom != d->events.begin() && itTo->timestamp() > itFrom->timestamp()) { --itTo; itFrom = itTo - 1; } // if we're at the end of the list - if (itFrom == d->startInstanceList.begin()) + if (itFrom == d->events.begin()) break; // find block length - while ( itFrom != d->startInstanceList.begin() - && itTo->startTime <= itFrom->startTime ) + while (itFrom != d->events.begin() && itTo->timestamp() <= itFrom->timestamp()) --itFrom; - if (itTo->startTime <= itFrom->startTime) + if (itTo->timestamp() <= itFrom->timestamp()) std::sort(itFrom, itTo + 1, compareStartTimes); else std::sort(itFrom + 1, itTo + 1, compareStartTimes); @@ -479,9 +321,88 @@ void QmlProfilerData::complete() bool QmlProfilerData::isEmpty() const { - return d->startInstanceList.isEmpty(); + return d->events.isEmpty(); } +struct StreamWriter { + QString error; + + StreamWriter(const QString &filename) + { + if (!filename.isEmpty()) { + file.setFileName(filename); + if (!file.open(QIODevice::WriteOnly)) { + error = QmlProfilerData::tr("Could not open %1 for writing").arg(filename); + return; + } + } else { + if (!file.open(stdout, QIODevice::WriteOnly)) { + error = QmlProfilerData::tr("Could not open stdout for writing"); + return; + } + } + + stream.setDevice(&file); + stream.setAutoFormatting(true); + stream.writeStartDocument(); + writeStartElement("trace"); + } + + ~StreamWriter() { + writeEndElement(); + stream.writeEndDocument(); + file.close(); + } + + template<typename Number> + void writeAttribute(const char *name, Number number) + { + stream.writeAttribute(QLatin1String(name), QString::number(number)); + } + + void writeAttribute(const char *name, const char *value) + { + stream.writeAttribute(QLatin1String(name), QLatin1String(value)); + } + + void writeAttribute(const char *name, const QQmlProfilerEvent &event, int i, bool printZero = true) + { + const qint64 number = event.number<qint64>(i); + if (printZero || number != 0) + writeAttribute(name, number); + } + + template<typename Number> + void writeTextElement(const char *name, Number number) + { + writeTextElement(name, QString::number(number)); + } + + void writeTextElement(const char *name, const char *value) + { + stream.writeTextElement(QLatin1String(name), QLatin1String(value)); + } + + void writeTextElement(const char *name, const QString &value) + { + stream.writeTextElement(QLatin1String(name), value); + } + + void writeStartElement(const char *name) + { + stream.writeStartElement(QLatin1String(name)); + } + + void writeEndElement() + { + stream.writeEndElement(); + } + +private: + QFile file; + QXmlStreamWriter stream; +}; + bool QmlProfilerData::save(const QString &filename) { if (isEmpty()) { @@ -489,157 +410,178 @@ bool QmlProfilerData::save(const QString &filename) return false; } - QFile file; - if (!filename.isEmpty()) { - file.setFileName(filename); - if (!file.open(QIODevice::WriteOnly)) { - emit error(tr("Could not open %1 for writing").arg(filename)); - return false; - } - } else { - if (!file.open(stdout, QIODevice::WriteOnly)) { - emit error(tr("Could not open stdout for writing")); - return false; - } + StreamWriter stream(filename); + if (!stream.error.isEmpty()) { + emit error(stream.error); + return false; } - QXmlStreamWriter stream(&file); - stream.setAutoFormatting(true); - stream.writeStartDocument(); - - stream.writeStartElement(QStringLiteral("trace")); - stream.writeAttribute(QStringLiteral("version"), PROFILER_FILE_VERSION); - - stream.writeAttribute(QStringLiteral("traceStart"), QString::number(traceStartTime())); - stream.writeAttribute(QStringLiteral("traceEnd"), QString::number(traceEndTime())); - - stream.writeStartElement(QStringLiteral("eventData")); - stream.writeAttribute(QStringLiteral("totalTime"), QString::number(d->qmlMeasuredTime)); - - const auto eventDescriptionsKeys = d->eventDescriptions.keys(); - for (auto it = d->eventDescriptions.cbegin(), end = d->eventDescriptions.cend(); - it != end; ++it) { - const QmlRangeEventData *eventData = it.value(); - stream.writeStartElement(QStringLiteral("event")); - stream.writeAttribute(QStringLiteral("index"), QString::number( - eventDescriptionsKeys.indexOf(eventData->eventHashStr))); - if (!eventData->displayName.isEmpty()) - stream.writeTextElement(QStringLiteral("displayname"), eventData->displayName); - if (eventData->rangeType != QQmlProfilerDefinitions::MaximumRangeType) - stream.writeTextElement(QStringLiteral("type"), - qmlRangeTypeAsString(eventData->rangeType)); - else - stream.writeTextElement(QStringLiteral("type"), - qmlMessageAsString(eventData->message)); - if (!eventData->location.filename.isEmpty()) - stream.writeTextElement(QStringLiteral("filename"), eventData->location.filename); - if (eventData->location.line >= 0) - stream.writeTextElement(QStringLiteral("line"), - QString::number(eventData->location.line)); - if (eventData->location.column >= 0) - stream.writeTextElement(QStringLiteral("column"), - QString::number(eventData->location.column)); - if (!eventData->details.isEmpty()) - stream.writeTextElement(QStringLiteral("details"), eventData->details); - if (eventData->rangeType == QQmlProfilerDefinitions::Binding) - stream.writeTextElement(QStringLiteral("bindingType"), - QString::number((int)eventData->detailType)); - else if (eventData->message == QQmlProfilerDefinitions::Event) { - switch (eventData->detailType) { + stream.writeAttribute("version", PROFILER_FILE_VERSION); + stream.writeAttribute("traceStart", traceStartTime()); + stream.writeAttribute("traceEnd", traceEndTime()); + + stream.writeStartElement("eventData"); + stream.writeAttribute("totalTime", d->qmlMeasuredTime); + + for (int typeIndex = 0, end = d->eventTypes.size(); typeIndex < end; ++typeIndex) { + const QQmlProfilerEventType &eventData = d->eventTypes.at(typeIndex); + stream.writeStartElement("event"); + stream.writeAttribute("index", typeIndex); + if (!eventData.displayName().isEmpty()) + stream.writeTextElement("displayname", eventData.displayName()); + + stream.writeTextElement("type", + eventData.rangeType() == QQmlProfilerDefinitions::MaximumRangeType + ? qmlMessageAsString(eventData.message()) + : qmlRangeTypeAsString(eventData.rangeType())); + + const QQmlProfilerEventLocation location = eventData.location(); + if (!location.filename().isEmpty()) + stream.writeTextElement("filename", location.filename()); + if (location.line() >= 0) + stream.writeTextElement("line", location.line()); + if (location.column() >= 0) + stream.writeTextElement("column", location.column()); + if (!eventData.data().isEmpty()) + stream.writeTextElement("details", eventData.data()); + if (eventData.rangeType() == QQmlProfilerDefinitions::Binding) + stream.writeTextElement("bindingType", eventData.detailType()); + else if (eventData.message() == QQmlProfilerDefinitions::Event) { + switch (eventData.detailType()) { case QQmlProfilerDefinitions::AnimationFrame: - stream.writeTextElement(QStringLiteral("animationFrame"), - QString::number((int)eventData->detailType)); + stream.writeTextElement("animationFrame", eventData.detailType()); break; case QQmlProfilerDefinitions::Key: - stream.writeTextElement(QStringLiteral("keyEvent"), - QString::number((int)eventData->detailType)); + stream.writeTextElement("keyEvent", eventData.detailType()); break; case QQmlProfilerDefinitions::Mouse: - stream.writeTextElement(QStringLiteral("mouseEvent"), - QString::number((int)eventData->detailType)); + stream.writeTextElement("mouseEvent", eventData.detailType()); break; } - } else if (eventData->message == QQmlProfilerDefinitions::PixmapCacheEvent) - stream.writeTextElement(QStringLiteral("cacheEventType"), - QString::number((int)eventData->detailType)); - else if (eventData->message == QQmlProfilerDefinitions::SceneGraphFrame) - stream.writeTextElement(QStringLiteral("sgEventType"), - QString::number((int)eventData->detailType)); - else if (eventData->message == QQmlProfilerDefinitions::MemoryAllocation) - stream.writeTextElement(QStringLiteral("memoryEventType"), - QString::number((int)eventData->detailType)); + } else if (eventData.message() == QQmlProfilerDefinitions::PixmapCacheEvent) + stream.writeTextElement("cacheEventType", eventData.detailType()); + else if (eventData.message() == QQmlProfilerDefinitions::SceneGraphFrame) + stream.writeTextElement("sgEventType", eventData.detailType()); + else if (eventData.message() == QQmlProfilerDefinitions::MemoryAllocation) + stream.writeTextElement("memoryEventType", eventData.detailType()); stream.writeEndElement(); } stream.writeEndElement(); // eventData - stream.writeStartElement(QStringLiteral("profilerDataModel")); - for (const QmlRangeEventStartInstance &event : qAsConst(d->startInstanceList)) { - stream.writeStartElement(QStringLiteral("range")); - stream.writeAttribute(QStringLiteral("startTime"), QString::number(event.startTime)); - if (event.duration >= 0) - stream.writeAttribute(QStringLiteral("duration"), - QString::number(event.duration)); - stream.writeAttribute(QStringLiteral("eventIndex"), QString::number( - eventDescriptionsKeys.indexOf(event.data->eventHashStr))); - if (event.data->message == QQmlProfilerDefinitions::Event) { - if (event.data->detailType == QQmlProfilerDefinitions::AnimationFrame) { + stream.writeStartElement("profilerDataModel"); + + auto sendEvent = [&](const QQmlProfilerEvent &event, qint64 duration = 0) { + const QQmlProfilerEventType &type = d->eventTypes.at(event.typeIndex()); + stream.writeStartElement("range"); + stream.writeAttribute("startTime", event.timestamp()); + if (duration != 0) + stream.writeAttribute("duration", duration); + stream.writeAttribute("eventIndex", event.typeIndex()); + if (type.message() == QQmlProfilerDefinitions::Event) { + if (type.detailType() == QQmlProfilerDefinitions::AnimationFrame) { // special: animation frame - stream.writeAttribute(QStringLiteral("framerate"), QString::number(event.frameRate)); - stream.writeAttribute(QStringLiteral("animationcount"), - QString::number(event.animationCount)); - stream.writeAttribute(QStringLiteral("thread"), QString::number(event.threadId)); - } else if (event.data->detailType == QQmlProfilerDefinitions::Key || - event.data->detailType == QQmlProfilerDefinitions::Mouse) { + stream.writeAttribute("framerate", event, 0); + stream.writeAttribute("animationcount", event, 1); + stream.writeAttribute("thread", event, 2); + } else if (type.detailType() == QQmlProfilerDefinitions::Key || + type.detailType() == QQmlProfilerDefinitions::Mouse) { // numerical value here, to keep the format a bit more compact - stream.writeAttribute(QStringLiteral("type"), - QString::number(event.inputType)); - stream.writeAttribute(QStringLiteral("data1"), - QString::number(event.inputA)); - stream.writeAttribute(QStringLiteral("data2"), - QString::number(event.inputB)); + stream.writeAttribute("type", event, 0); + stream.writeAttribute("data1", event, 1); + stream.writeAttribute("data2", event, 2); } - } else if (event.data->message == QQmlProfilerDefinitions::PixmapCacheEvent) { + } else if (type.message() == QQmlProfilerDefinitions::PixmapCacheEvent) { // special: pixmap cache event - if (event.data->detailType == QQmlProfilerDefinitions::PixmapSizeKnown) { - stream.writeAttribute(QStringLiteral("width"), - QString::number(event.numericData1)); - stream.writeAttribute(QStringLiteral("height"), - QString::number(event.numericData2)); - } else if (event.data->detailType == - QQmlProfilerDefinitions::PixmapReferenceCountChanged || - event.data->detailType == - QQmlProfilerDefinitions::PixmapCacheCountChanged) { - stream.writeAttribute(QStringLiteral("refCount"), - QString::number(event.numericData1)); + if (type.detailType() == QQmlProfilerDefinitions::PixmapSizeKnown) { + stream.writeAttribute("width", event, 0); + stream.writeAttribute("height", event, 1); + } else if (type.detailType() == QQmlProfilerDefinitions::PixmapReferenceCountChanged + || type.detailType() == QQmlProfilerDefinitions::PixmapCacheCountChanged) { + stream.writeAttribute("refCount", event, 1); } - } else if (event.data->message == QQmlProfilerDefinitions::SceneGraphFrame) { - // special: scenegraph frame events - if (event.numericData1 > 0) - stream.writeAttribute(QStringLiteral("timing1"), - QString::number(event.numericData1)); - if (event.numericData2 > 0) - stream.writeAttribute(QStringLiteral("timing2"), - QString::number(event.numericData2)); - if (event.numericData3 > 0) - stream.writeAttribute(QStringLiteral("timing3"), - QString::number(event.numericData3)); - if (event.numericData4 > 0) - stream.writeAttribute(QStringLiteral("timing4"), - QString::number(event.numericData4)); - if (event.numericData5 > 0) - stream.writeAttribute(QStringLiteral("timing5"), - QString::number(event.numericData5)); - } else if (event.data->message == QQmlProfilerDefinitions::MemoryAllocation) { - stream.writeAttribute(QStringLiteral("amount"), QString::number(event.numericData1)); + } else if (type.message() == QQmlProfilerDefinitions::SceneGraphFrame) { + stream.writeAttribute("timing1", event, 0, false); + stream.writeAttribute("timing2", event, 1, false); + stream.writeAttribute("timing3", event, 2, false); + stream.writeAttribute("timing4", event, 3, false); + stream.writeAttribute("timing5", event, 4, false); + } else if (type.message() == QQmlProfilerDefinitions::MemoryAllocation) { + stream.writeAttribute("amount", event, 0); } stream.writeEndElement(); + }; + + QQueue<QQmlProfilerEvent> pointEvents; + QQueue<QQmlProfilerEvent> rangeStarts[QQmlProfilerDefinitions::MaximumRangeType]; + QStack<qint64> rangeEnds[QQmlProfilerDefinitions::MaximumRangeType]; + int level = 0; + + auto sendPending = [&]() { + forever { + int minimum = QQmlProfilerDefinitions::MaximumRangeType; + qint64 minimumTime = std::numeric_limits<qint64>::max(); + for (int i = 0; i < QQmlProfilerDefinitions::MaximumRangeType; ++i) { + const QQueue<QQmlProfilerEvent> &starts = rangeStarts[i]; + if (starts.isEmpty()) + continue; + if (starts.head().timestamp() < minimumTime) { + minimumTime = starts.head().timestamp(); + minimum = i; + } + } + if (minimum == QQmlProfilerDefinitions::MaximumRangeType) + break; + + while (!pointEvents.isEmpty() && pointEvents.front().timestamp() < minimumTime) + sendEvent(pointEvents.dequeue()); + + sendEvent(rangeStarts[minimum].dequeue(), + rangeEnds[minimum].pop() - minimumTime); + } + }; + + for (const QQmlProfilerEvent &event : qAsConst(d->events)) { + const QQmlProfilerEventType &type = d->eventTypes.at(event.typeIndex()); + + if (type.rangeType() != QQmlProfilerDefinitions::MaximumRangeType) { + QQueue<QQmlProfilerEvent> &starts = rangeStarts[type.rangeType()]; + switch (event.rangeStage()) { + case QQmlProfilerDefinitions::RangeStart: { + ++level; + starts.enqueue(event); + break; + } + case QQmlProfilerDefinitions::RangeEnd: { + QStack<qint64> &ends = rangeEnds[type.rangeType()]; + if (starts.length() > ends.length()) { + ends.push(event.timestamp()); + if (--level == 0) + sendPending(); + } + break; + } + default: + break; + } + } else { + if (level == 0) + sendEvent(event); + else + pointEvents.enqueue(event); + } } - stream.writeEndElement(); // profilerDataModel - stream.writeEndElement(); // trace - stream.writeEndDocument(); + for (int i = 0; i < QQmlProfilerDefinitions::MaximumRangeType; ++i) { + while (rangeEnds[i].length() < rangeStarts[i].length()) { + rangeEnds[i].push(d->traceEndTime); + --level; + } + } + + sendPending(); + + stream.writeEndElement(); // profilerDataModel - file.close(); return true; } @@ -683,4 +625,9 @@ void QmlProfilerData::setState(QmlProfilerData::State state) return; } +int QmlProfilerData::numLoadedEventTypes() const +{ + return d->eventTypes.length(); +} + #include "moc_qmlprofilerdata.cpp" diff --git a/tools/qmlprofiler/qmlprofilerdata.h b/tools/qmlprofiler/qmlprofilerdata.h index 00ef037071..2be0b73aee 100644 --- a/tools/qmlprofiler/qmlprofilerdata.h +++ b/tools/qmlprofiler/qmlprofilerdata.h @@ -29,13 +29,14 @@ #ifndef QMLPROFILERDATA_H #define QMLPROFILERDATA_H -#include <private/qqmleventlocation_p.h> #include <private/qqmlprofilerdefinitions_p.h> +#include <private/qqmlprofilereventlocation_p.h> +#include <private/qqmlprofilereventreceiver_p.h> #include <QObject> class QmlProfilerDataPrivate; -class QmlProfilerData : public QObject +class QmlProfilerData : public QQmlProfilerEventReceiver { Q_OBJECT public: @@ -49,7 +50,11 @@ public: explicit QmlProfilerData(QObject *parent = 0); ~QmlProfilerData(); - static QString getHashStringForQmlEvent(const QQmlEventLocation &location, int eventType); + int numLoadedEventTypes() const override; + void addEventType(const QQmlProfilerEventType &type) override; + void addEvent(const QQmlProfilerEvent &event) override; + + static QString getHashStringForQmlEvent(const QQmlProfilerEventLocation &location, int eventType); static QString qmlRangeTypeAsString(QQmlProfilerDefinitions::RangeType type); static QString qmlMessageAsString(QQmlProfilerDefinitions::Message type); @@ -61,18 +66,6 @@ public: void clear(); void setTraceEndTime(qint64 time); void setTraceStartTime(qint64 time); - void addQmlEvent(QQmlProfilerDefinitions::RangeType type, - QQmlProfilerDefinitions::BindingType bindingType, - qint64 startTime, qint64 duration, const QStringList &data, - const QQmlEventLocation &location); - void addFrameEvent(qint64 time, int framerate, int animationcount, int threadId); - void addSceneGraphFrameEvent(QQmlProfilerDefinitions::SceneGraphFrameType type, qint64 time, - qint64 numericData1, qint64 numericData2, qint64 numericData3, - qint64 numericData4, qint64 numericData5); - void addPixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type, qint64 time, - const QString &location, int numericData1, int numericData2); - void addMemoryEvent(QQmlProfilerDefinitions::MemoryType type, qint64 time, qint64 size); - void addInputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time, int a, int b); void complete(); bool save(const QString &filename); |