diff options
author | Edward Welbourne <edward.welbourne@qt.io> | 2021-08-18 11:48:29 +0200 |
---|---|---|
committer | Edward Welbourne <edward.welbourne@qt.io> | 2021-08-30 19:21:08 +0200 |
commit | 9004a2412ba1f9976c2c61f01223dff852208c42 (patch) | |
tree | f06abeec8b9cc66abf0e66cc9048c7a0ed02a360 /tests/benchmarks/corelib/kernel/qvariant/tst_bench_qvariant.cpp | |
parent | c2a6749af795386495b275684418d083410fa1e4 (diff) |
Standardise layout and naming in corelib benchmarks
Make file names match CMake's test names (and those follow dir-name)
and class names follow tst_ClassName pattern when testing
ClassName. Purge comments about the qmake configs the CMakeLists.txt
are generated from. Purge empty constructors and init/cleanup methods
of classes. Fix petty coding style violations.
Add qdir/tree/, qurl, qbench and qset benchmarks to their parent directories'
lists of subdirs. Fix unused return error from qurl benchmark.
Change-Id: Ifc15a3a46e71cf82ad0637753517e0df34049763
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Diffstat (limited to 'tests/benchmarks/corelib/kernel/qvariant/tst_bench_qvariant.cpp')
-rw-r--r-- | tests/benchmarks/corelib/kernel/qvariant/tst_bench_qvariant.cpp | 381 |
1 files changed, 381 insertions, 0 deletions
diff --git a/tests/benchmarks/corelib/kernel/qvariant/tst_bench_qvariant.cpp b/tests/benchmarks/corelib/kernel/qvariant/tst_bench_qvariant.cpp new file mode 100644 index 0000000000..1e35cf85f9 --- /dev/null +++ b/tests/benchmarks/corelib/kernel/qvariant/tst_bench_qvariant.cpp @@ -0,0 +1,381 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** 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. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtCore> +#ifdef QT_GUI_LIB +# include <QtGui/QPixmap> +#endif +#include <qtest.h> + +#define ITERATION_COUNT 1e5 + +class tst_QVariant : public QObject +{ + Q_OBJECT + +public: + enum ABenchmarkEnum { + FirstEnumValue, + SecondEnumValue, + ThirdEnumValue + }; + Q_ENUM(ABenchmarkEnum) + +private slots: + void testBound(); + + void doubleVariantCreation(); + void floatVariantCreation(); + void rectVariantCreation(); + void stringVariantCreation(); +#ifdef QT_GUI_LIB + void pixmapVariantCreation(); +#endif + void stringListVariantCreation(); + void bigClassVariantCreation(); + void smallClassVariantCreation(); + void enumVariantCreation(); + + void doubleVariantSetValue(); + void floatVariantSetValue(); + void rectVariantSetValue(); + void stringVariantSetValue(); + void stringListVariantSetValue(); + void bigClassVariantSetValue(); + void smallClassVariantSetValue(); + void enumVariantSetValue(); + + void doubleVariantAssignment(); + void floatVariantAssignment(); + void rectVariantAssignment(); + void stringVariantAssignment(); + void stringListVariantAssignment(); + + void doubleVariantValue(); + void floatVariantValue(); + void rectVariantValue(); + void stringVariantValue(); + + void createCoreType_data(); + void createCoreType(); + void createCoreTypeCopy_data(); + void createCoreTypeCopy(); +}; + +struct BigClass +{ + double n,i,e,r,o,b; +}; +static_assert(sizeof(BigClass) > sizeof(QVariant::Private::MaxInternalSize)); +QT_BEGIN_NAMESPACE +Q_DECLARE_TYPEINFO(BigClass, Q_RELOCATABLE_TYPE); +QT_END_NAMESPACE +Q_DECLARE_METATYPE(BigClass); + +struct SmallClass +{ + char s; +}; +static_assert(sizeof(SmallClass) <= sizeof(QVariant::Private::MaxInternalSize)); +QT_BEGIN_NAMESPACE +Q_DECLARE_TYPEINFO(SmallClass, Q_RELOCATABLE_TYPE); +QT_END_NAMESPACE +Q_DECLARE_METATYPE(SmallClass); + +void tst_QVariant::testBound() +{ + qreal d = qreal(.5); + QBENCHMARK { + for(int i = 0; i < ITERATION_COUNT; ++i) { + d = qBound<qreal>(0, d, 1); + } + } +} + +template <typename T> +static void variantCreation(T val) +{ + QBENCHMARK { + for(int i = 0; i < ITERATION_COUNT; ++i) { + QVariant v(val); + } + } +} + +template <> +void variantCreation<BigClass>(BigClass val) +{ + QBENCHMARK { + for (int i = 0; i < ITERATION_COUNT; ++i) { + QVariant::fromValue(val); + } + } +} + +template <> +void variantCreation<SmallClass>(SmallClass val) +{ + QBENCHMARK { + for (int i = 0; i < ITERATION_COUNT; ++i) { + QVariant::fromValue(val); + } + } +} + +template <> +void variantCreation<tst_QVariant::ABenchmarkEnum>(tst_QVariant::ABenchmarkEnum val) +{ + QBENCHMARK { + for (int i = 0; i < ITERATION_COUNT; ++i) { + QVariant::fromValue(val); + } + } +} + + +void tst_QVariant::doubleVariantCreation() +{ + variantCreation<double>(0.0); +} + +void tst_QVariant::floatVariantCreation() +{ + variantCreation<float>(0.0f); +} + +void tst_QVariant::rectVariantCreation() +{ + variantCreation<QRect>(QRect(1, 2, 3, 4)); +} + +void tst_QVariant::stringVariantCreation() +{ + variantCreation<QString>(QString()); +} + +#ifdef QT_GUI_LIB +void tst_QVariant::pixmapVariantCreation() +{ + variantCreation<QPixmap>(QPixmap()); +} +#endif + +void tst_QVariant::stringListVariantCreation() +{ + variantCreation<QStringList>(QStringList()); +} + +void tst_QVariant::bigClassVariantCreation() +{ + variantCreation<BigClass>(BigClass()); +} + +void tst_QVariant::smallClassVariantCreation() +{ + variantCreation<SmallClass>(SmallClass()); +} + +void tst_QVariant::enumVariantCreation() +{ + variantCreation<ABenchmarkEnum>(FirstEnumValue); +} + + +template <typename T> +static void variantSetValue(T d) +{ + QVariant v; + QBENCHMARK { + for(int i = 0; i < ITERATION_COUNT; ++i) { + v.setValue(d); + } + } +} + +void tst_QVariant::doubleVariantSetValue() +{ + variantSetValue<double>(0.0); +} + +void tst_QVariant::floatVariantSetValue() +{ + variantSetValue<float>(0.0f); +} + +void tst_QVariant::rectVariantSetValue() +{ + variantSetValue<QRect>(QRect()); +} + +void tst_QVariant::stringVariantSetValue() +{ + variantSetValue<QString>(QString()); +} + +void tst_QVariant::stringListVariantSetValue() +{ + variantSetValue<QStringList>(QStringList()); +} + +void tst_QVariant::bigClassVariantSetValue() +{ + variantSetValue<BigClass>(BigClass()); +} + +void tst_QVariant::smallClassVariantSetValue() +{ + variantSetValue<SmallClass>(SmallClass()); +} + +void tst_QVariant::enumVariantSetValue() +{ + variantSetValue<ABenchmarkEnum>(FirstEnumValue); +} + +template <typename T> +static void variantAssignment(T d) +{ + QVariant v; + QBENCHMARK { + for(int i = 0; i < ITERATION_COUNT; ++i) { + v = d; + } + } +} + +void tst_QVariant::doubleVariantAssignment() +{ + variantAssignment<double>(0.0); +} + +void tst_QVariant::floatVariantAssignment() +{ + variantAssignment<float>(0.0f); +} + +void tst_QVariant::rectVariantAssignment() +{ + variantAssignment<QRect>(QRect()); +} + +void tst_QVariant::stringVariantAssignment() +{ + variantAssignment<QString>(QString()); +} + +void tst_QVariant::stringListVariantAssignment() +{ + variantAssignment<QStringList>(QStringList()); +} + +void tst_QVariant::doubleVariantValue() +{ + QVariant v(0.0); + QBENCHMARK { + for(int i = 0; i < ITERATION_COUNT; ++i) { + v.toDouble(); + } + } +} + +void tst_QVariant::floatVariantValue() +{ + QVariant v(0.0f); + QBENCHMARK { + for(int i = 0; i < ITERATION_COUNT; ++i) { + v.toFloat(); + } + } +} + +void tst_QVariant::rectVariantValue() +{ + QVariant v(QRect(1,2,3,4)); + QBENCHMARK { + for(int i = 0; i < ITERATION_COUNT; ++i) { + v.toRect(); + } + } +} + +void tst_QVariant::stringVariantValue() +{ + QVariant v = QString(); + QBENCHMARK { + for(int i = 0; i < ITERATION_COUNT; ++i) { + v.toString(); + } + } +} + +void tst_QVariant::createCoreType_data() +{ + QTest::addColumn<int>("typeId"); + for (int i = QMetaType::FirstCoreType; i <= QMetaType::LastCoreType; ++i) { + if (QMetaType metaType(i); metaType.isValid()) // QMetaType(27) does not exist + QTest::newRow(metaType.name()) << i; + } +} + +// Tests how fast a Qt core type can be default-constructed by a +// QVariant. The purpose of this benchmark is to measure the overhead +// of creating (and destroying) a QVariant compared to creating the +// type directly. +void tst_QVariant::createCoreType() +{ + QFETCH(int, typeId); + QBENCHMARK { + for (int i = 0; i < ITERATION_COUNT; ++i) + QVariant(QMetaType(typeId)); + } +} + +void tst_QVariant::createCoreTypeCopy_data() +{ + createCoreType_data(); +} + +// Tests how fast a Qt core type can be copy-constructed by a +// QVariant. The purpose of this benchmark is to measure the overhead +// of creating (and destroying) a QVariant compared to creating the +// type directly. +void tst_QVariant::createCoreTypeCopy() +{ + QFETCH(int, typeId); + QMetaType metaType(typeId); + QVariant other(metaType); + const void *copy = other.constData(); + QBENCHMARK { + for (int i = 0; i < ITERATION_COUNT; ++i) + QVariant(metaType, copy); + } +} + +QTEST_MAIN(tst_QVariant) + +#include "tst_bench_qvariant.moc" |