qqmlprofilerclient.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant
 
#include "qqmlprofilerclient_p_p.h"
#include "qqmldebugconnection_p.h"
 
QT_BEGIN_NAMESPACE
 
QQmlProfilerClientPrivate::~QQmlProfilerClientPrivate()
{
}
 
int QQmlProfilerClientPrivate::resolveType(const QQmlProfilerTypedEvent &event)
{
    int typeIndex = -1;
    if (event.serverTypeId != 0) {
        QHash<qint64, int>::ConstIterator it = serverTypeIds.constFind(event.serverTypeId);
 
        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;
}
 
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 QQmlProfilerClientPrivate::forwardEvents(const QQmlProfilerEvent &last)
{
    forwardDebugMessages(last.timestamp());
    eventReceiver->addEvent(last);
}
 
void QQmlProfilerClientPrivate::forwardDebugMessages(qint64 untilTimestamp)
{
    while (!pendingDebugMessages.isEmpty()
           && pendingDebugMessages.front().timestamp() <= untilTimestamp) {
        eventReceiver->addEvent(pendingDebugMessages.dequeue());
    }
}
 
void QQmlProfilerClientPrivate::processCurrentEvent()
{
    // 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())
            forwardEvents(currentEvent.event);
        else
            pendingMessages.enqueue(currentEvent.event);
        break;
    }
    }
}
 
void QQmlProfilerClientPrivate::sendRecordingStatus(int 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());
}
 
QQmlProfilerClient::QQmlProfilerClient(QQmlDebugConnection *connection,
                                       QQmlProfilerEventReceiver *eventReceiver,
                                       quint64 features)
    : QQmlDebugClient(*(new QQmlProfilerClientPrivate(connection, eventReceiver)))
{
    Q_D(QQmlProfilerClient);
    setRequestedFeatures(features);
    connect(this, &QQmlDebugClient::stateChanged, this, &QQmlProfilerClient::onStateChanged);
    connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded,
            this, &QQmlProfilerClient::sendRecordingStatus);
    connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeRemoved,
            this, [d](int engineId) {
        // We may already be done with that engine. Then we don't need to block it.
        if (d->trackedEngines.contains(engineId))
            d->engineControl->blockEngine(engineId);
    });
    connect(this, &QQmlProfilerClient::traceFinished,
            d->engineControl.data(), [d](qint64 timestamp, const QList<int> &engineIds) {
        Q_UNUSED(timestamp);
        // The engines might not be blocked because the trace can get finished before engine control
        // sees them.
        for (int blocked : d->engineControl->blockedEngines()) {
            if (engineIds.contains(blocked))
                d->engineControl->releaseEngine(blocked);
        }
    });
}
 
QQmlProfilerClient::~QQmlProfilerClient()
{
    //Disable profiling if started by client
    //Profiling data will be lost!!
    if (isRecording())
        setRecording(false);
}
 
void QQmlProfilerClient::clearEvents()
{
    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::clearAll()
{
    Q_D(QQmlProfilerClient);
    d->serverTypeIds.clear();
    d->eventTypeIds.clear();
    d->trackedEngines.clear();
    clearEvents();
}
 
void QQmlProfilerClientPrivate::finalize()
{
    while (!rangesInProgress.isEmpty()) {
        currentEvent = rangesInProgress.top();
        currentEvent.event.setRangeStage(RangeEnd);
        currentEvent.event.setTimestamp(maximumTime);
        processCurrentEvent();
    }
    forwardDebugMessages(std::numeric_limits<qint64>::max());
}
 
 
void QQmlProfilerClient::sendRecordingStatus(int engineId)
{
    Q_D(QQmlProfilerClient);
    d->sendRecordingStatus(engineId);
}
 
bool QQmlProfilerClient::isRecording() const
{
    Q_D(const QQmlProfilerClient);
    return d->recording;
}
 
void QQmlProfilerClient::setRecording(bool v)
{
    Q_D(QQmlProfilerClient);
    if (v == d->recording)
        return;
 
    d->recording = v;
 
    if (state() == Enabled)
        sendRecordingStatus();
 
    emit recordingChanged(v);
}
 
quint64 QQmlProfilerClient::recordedFeatures() const
{
    Q_D(const QQmlProfilerClient);
    return d->recordedFeatures;
}
 
void QQmlProfilerClient::receiveDebugMessage(
        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();
}
 
void QQmlProfilerClient::setRequestedFeatures(quint64 features)
{
    Q_D(QQmlProfilerClient);
 
    const quint64 messagesFlag = 1ull << ProfileDebugMessages;
    const bool hadMessagesBefore = d->requestedFeatures & messagesFlag;
    const bool hasMessagesNow = features & messagesFlag;
 
    d->requestedFeatures = features;
 
    if (!hadMessagesBefore && hasMessagesNow) {
        connect(d->messageClient.data(), &QQmlDebugMessageClient::message,
                this, &QQmlProfilerClient::receiveDebugMessage);
    } else if (hadMessagesBefore && !hasMessagesNow) {
        disconnect(d->messageClient.data(), &QQmlDebugMessageClient::message,
                   this, &QQmlProfilerClient::receiveDebugMessage);
    }
}
 
void QQmlProfilerClient::setFlushInterval(quint32 flushInterval)
{
    Q_D(QQmlProfilerClient);
    d->flushInterval = flushInterval;
}
 
QQmlProfilerClient::QQmlProfilerClient(QQmlProfilerClientPrivate &dd) :
    QQmlDebugClient(dd)
{
    Q_D(QQmlProfilerClient);
    connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded,
            this, &QQmlProfilerClient::sendRecordingStatus);
}
 
bool QQmlProfilerClientPrivate::updateFeatures(ProfileFeature feature)
{
    Q_Q(QQmlProfilerClient);
    quint64 flag = 1ULL << feature;
    if (!(requestedFeatures & flag))
        return false;
    if (!(recordedFeatures & flag)) {
        recordedFeatures |= flag;
        emit q->recordedFeaturesChanged(recordedFeatures);
    }
    return true;
}
 
void QQmlProfilerClient::onStateChanged(State status)
{
    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);
 
    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) {
        const QList<int> engineIds = d->currentEvent.event.numbers<QList<int>, qint32>();
        d->trackedEngines.append(engineIds);
        d->forwardDebugMessages(d->currentEvent.event.timestamp());
        emit traceStarted(d->currentEvent.event.timestamp(), engineIds);
    } else if (d->currentEvent.type.message() == Event
               && d->currentEvent.type.detailType() == EndTrace) {
        const QList<int> engineIds = d->currentEvent.event.numbers<QList<int>, qint32>();
        for (int engineId : engineIds)
            d->trackedEngines.removeAll(engineId);
        d->forwardDebugMessages(d->currentEvent.event.timestamp());
        emit traceFinished(d->currentEvent.event.timestamp(), engineIds);
    } else if (d->updateFeatures(d->currentEvent.type.feature())) {
        d->processCurrentEvent();
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qqmlprofilerclient_p.cpp"