diff options
Diffstat (limited to 'src/qmldebug/qqmlprofilerevent.cpp')
| -rw-r--r-- | src/qmldebug/qqmlprofilerevent.cpp | 273 |
1 files changed, 273 insertions, 0 deletions
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 |