From bb7925b4effc4c94ed4109482a7e75cb363cd4f5 Mon Sep 17 00:00:00 2001 From: Ulf Hermann Date: Wed, 4 May 2016 15:41:29 +0200 Subject: [PATCH] QmlProfiler: Add data stream operators for QmlEvent We try to further compress the QML events when saving as we can use the additional space in that case. Change-Id: Ida308963685169d1daabd7936612628fd4d265ae Reviewed-by: Joerg Bornemann --- src/plugins/qmlprofiler/qmlevent.cpp | 246 ++++++++++++++++++++++++ src/plugins/qmlprofiler/qmlevent.h | 6 + src/plugins/qmlprofiler/qmlprofiler.pro | 1 + src/plugins/qmlprofiler/qmlprofiler.qbs | 2 +- 4 files changed, 254 insertions(+), 1 deletion(-) create mode 100644 src/plugins/qmlprofiler/qmlevent.cpp diff --git a/src/plugins/qmlprofiler/qmlevent.cpp b/src/plugins/qmlprofiler/qmlevent.cpp new file mode 100644 index 00000000000..4c848ef0ce6 --- /dev/null +++ b/src/plugins/qmlprofiler/qmlevent.cpp @@ -0,0 +1,246 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt Creator. +** +** 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 General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** 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-3.0.html. +** +****************************************************************************/ + +#include "qmlevent.h" +#include +#include + +namespace QmlProfiler { + +enum SerializationType { + OneByte = 0, + TwoByte = 1, + FourByte = 2, + EightByte = 3, + TypeMask = 0x3 +}; + +enum SerializationTypeOffset { + TimestampOffset = 0, + TypeIndexOffset = 2, + DataLengthOffset = 4, + DataOffset = 6 +}; + +template +static void readNumbers(QDataStream &stream, Number *data, quint16 length) +{ + for (quint16 i = 0; i != length; ++i) + stream >> data[i]; +} + +template +static Number readNumber(QDataStream &stream, qint8 type) +{ + switch (type) { + case OneByte: { + qint8 value; + stream >> value; + return static_cast(value); + } + case TwoByte: { + qint16 value; + stream >> value; + return static_cast(value); + } + case FourByte: { + qint32 value; + stream >> value; + return static_cast(value); + } + case EightByte: { + qint64 value; + stream >> value; + return static_cast(value); + } + default: + Q_UNREACHABLE(); + return 0; + } +} + +QDataStream &operator>>(QDataStream &stream, QmlEvent &event) +{ + qint8 type; + stream >> type; + + event.m_timestamp = readNumber(stream, (type >> TimestampOffset) & TypeMask); + event.m_typeIndex = readNumber(stream, (type >> TypeIndexOffset) & TypeMask); + event.m_dataLength = readNumber(stream, (type >> DataLengthOffset) & TypeMask); + + quint8 bytesPerNumber = 1 << ((type >> DataOffset) & TypeMask); + + if (event.m_dataLength * bytesPerNumber > sizeof(event.m_data)) { + event.m_dataType = static_cast((bytesPerNumber * 8) | QmlEvent::External); + event.m_data.external = malloc(event.m_dataLength * bytesPerNumber); + } else { + event.m_dataType = static_cast(bytesPerNumber * 8); + } + + switch (event.m_dataType) { + case QmlEvent::Inline8Bit: + readNumbers(stream, event.m_data.internal8bit, event.m_dataLength); + break; + case QmlEvent::External8Bit: + readNumbers(stream, static_cast(event.m_data.external), + event.m_dataLength); + break; + case QmlEvent::Inline16Bit: + readNumbers(stream, event.m_data.internal16bit, event.m_dataLength); + break; + case QmlEvent::External16Bit: + readNumbers(stream, static_cast(event.m_data.external), + event.m_dataLength); + break; + case QmlEvent::Inline32Bit: + readNumbers(stream, event.m_data.internal32bit, event.m_dataLength); + break; + case QmlEvent::External32Bit: + readNumbers(stream, static_cast(event.m_data.external), + event.m_dataLength); + break; + case QmlEvent::Inline64Bit: + readNumbers(stream, event.m_data.internal64bit, event.m_dataLength); + break; + case QmlEvent::External64Bit: + readNumbers(stream, static_cast(event.m_data.external), + event.m_dataLength); + break; + default: + Q_UNREACHABLE(); + break; + } + + return stream; +} + +static qint8 minimumType(const QmlEvent &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(i) == event.number(i)); + break; + case TwoByte: + ok = (event.number(i) == event.number(i)); + break; + case FourByte: + ok = (event.number(i) == event.number(i)); + break; + case EightByte: + ok = true; + break; + default: + Q_UNREACHABLE(); + break; + } + + if (ok) + ++i; + else + ++type; + } + return type; +} + +template +static qint8 minimumType(Number number) +{ + if (static_cast(number) == number) + return OneByte; + if (static_cast(number) == number) + return TwoByte; + if (static_cast(number) == number) + return FourByte; + return EightByte; +} + +template +static void writeNumbers(QDataStream &stream, const QmlEvent &event, quint16 length) +{ + for (quint16 i = 0; i != length; ++i) + stream << event.number(i); +} + +template +static void writeNumber(QDataStream &stream, Number number, qint8 type) +{ + switch (type) { + case OneByte: + stream << static_cast(number); + break; + case TwoByte: + stream << static_cast(number); + break; + case FourByte: + stream << static_cast(number); + break; + case EightByte: + stream << static_cast(number); + break; + default: + Q_UNREACHABLE(); + break; + } +} + +QDataStream &operator<<(QDataStream &stream, const QmlEvent &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(stream, event, event.m_dataLength); + break; + case TwoByte: + writeNumbers(stream, event, event.m_dataLength); + break; + case FourByte: + writeNumbers(stream, event, event.m_dataLength); + break; + case EightByte: + writeNumbers(stream, event, event.m_dataLength); + break; + default: + Q_UNREACHABLE(); + break; + } + + return stream; +} + +} // namespace QmlProfiler diff --git a/src/plugins/qmlprofiler/qmlevent.h b/src/plugins/qmlprofiler/qmlevent.h index d3fd49e8e90..d08bbe00960 100644 --- a/src/plugins/qmlprofiler/qmlevent.h +++ b/src/plugins/qmlprofiler/qmlevent.h @@ -292,8 +292,14 @@ private: if (m_dataType & External) free(m_data.external); } + + friend QDataStream &operator>>(QDataStream &stream, QmlEvent &event); + friend QDataStream &operator<<(QDataStream &stream, const QmlEvent &event); }; +QDataStream &operator>>(QDataStream &stream, QmlEvent &event); +QDataStream &operator<<(QDataStream &stream, const QmlEvent &event); + } // namespace QmlProfiler Q_DECLARE_METATYPE(QmlProfiler::QmlEvent) diff --git a/src/plugins/qmlprofiler/qmlprofiler.pro b/src/plugins/qmlprofiler/qmlprofiler.pro index ee7786fec7e..4b1aec9b775 100644 --- a/src/plugins/qmlprofiler/qmlprofiler.pro +++ b/src/plugins/qmlprofiler/qmlprofiler.pro @@ -13,6 +13,7 @@ SOURCES += \ localqmlprofilerrunner.cpp \ memoryusagemodel.cpp \ pixmapcachemodel.cpp \ + qmlevent.cpp \ qmleventlocation.cpp \ qmleventtype.cpp \ qmlnote.cpp \ diff --git a/src/plugins/qmlprofiler/qmlprofiler.qbs b/src/plugins/qmlprofiler/qmlprofiler.qbs index a2335867fe7..69aa4ea0dcb 100644 --- a/src/plugins/qmlprofiler/qmlprofiler.qbs +++ b/src/plugins/qmlprofiler/qmlprofiler.qbs @@ -27,7 +27,7 @@ QtcPlugin { "localqmlprofilerrunner.cpp", "localqmlprofilerrunner.h", "memoryusagemodel.cpp", "memoryusagemodel.h", "pixmapcachemodel.cpp", "pixmapcachemodel.h", - "qmlevent.h", + "qmlevent.cpp", "qmlevent.h", "qmleventlocation.cpp", "qmleventlocation.h", "qmleventtype.cpp", "qmleventtype.h", "qmlnote.cpp", "qmlnote.h",