whytofly
/
qt6-bb10
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove useless QMetaType benchmarks 

Cost of a type lookup for core built-in types is really small, just few
cpu instructions, but the benchmark was testing create() and destroy()
functions (in a different fashion) which by definition allocate and
de-allocate memory. These memory operations are significantly more
expensive which obfuscate the results.

Change-Id: I33c679f57e6c2b57e98328f076dfe249ab7bcde8
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
Reviewed-by: Stephen Kelly <steveire@gmail.com>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
bb10
Jędrzej Nowacki 2014-07-09 18:00:07 +02:00
parent dc4dfe4ffa
commit 21a58910b2
2 changed files with 7 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
tests/benchmarks/corelib/kernel/qmetatype/tst_qmetatype.cpp
View File

@ -70,16 +70,6 @@ private slots:
void isRegisteredCustom();
void isRegisteredNotRegistered();
void constructCoreType_data();
void constructCoreType();
void constructCoreTypeStaticLess_data();
void constructCoreTypeStaticLess();
void constructCoreTypeCopy_data();
void constructCoreTypeCopy();
void constructCustomType_data();
void constructCustomType();
void constructInPlace_data();
void constructInPlace();
void constructInPlaceCopy_data();
@ -250,91 +240,15 @@ void tst_QMetaType::isRegisteredNotRegistered()
}
}
void tst_QMetaType::constructCoreType_data()
void tst_QMetaType::constructInPlace_data()
{
QTest::addColumn<int>("typeId");
for (int i = QMetaType::FirstCoreType; i <= QMetaType::LastCoreType; ++i)
if (i != QMetaType::Void)
QTest::newRow(QMetaType::typeName(i)) << i;
// GUI types are tested in tst_QGuiMetaType.
}
// Tests how fast QMetaType can default-construct and destroy a Qt
// core type. The purpose of this benchmark is to measure the overhead
// of using type id-based creation compared to creating the type
// directly (i.e. "T *t = new T(); delete t;").
void tst_QMetaType::constructCoreType()
{
QFETCH(int, typeId);
QBENCHMARK {
for (int i = 0; i < 100000; ++i) {
void *data = QMetaType::create(typeId, (void *)0);
QMetaType::destroy(typeId, data);
}
}
}
void tst_QMetaType::constructCoreTypeStaticLess_data()
{
constructCoreType_data();
}
void tst_QMetaType::constructCoreTypeStaticLess()
{
QFETCH(int, typeId);
QBENCHMARK {
QMetaType type(typeId);
for (int i = 0; i < 100000; ++i) {
void *data = type.create((void *)0);
type.destroy(data);
}
}
}
void tst_QMetaType::constructCoreTypeCopy_data()
{
constructCoreType_data();
}
// Tests how fast QMetaType can copy-construct and destroy a Qt core
// type. The purpose of this benchmark is to measure the overhead of
// using type id-based creation compared to creating the type directly
// (i.e. "T *t = new T(other); delete t;").
void tst_QMetaType::constructCoreTypeCopy()
{
QFETCH(int, typeId);
QVariant other(typeId, (void *)0);
const void *copy = other.constData();
QBENCHMARK {
for (int i = 0; i < 100000; ++i) {
void *data = QMetaType::create(typeId, copy);
QMetaType::destroy(typeId, data);
}
}
}
void tst_QMetaType::constructCustomType_data()
{
QTest::addColumn<int>("typeId");
QTest::newRow("BigClass") << qMetaTypeId<BigClass>();
}
void tst_QMetaType::constructCustomType()
{
QFETCH(int, typeId);
QBENCHMARK {
for (int i = 0; i < 100000; ++i) {
void *data = QMetaType::create(typeId, (void *)0);
QMetaType::destroy(typeId, data);
}
}
}
void tst_QMetaType::constructInPlace_data()
{
constructCoreType_data();
QTest::newRow("custom") << qMetaTypeId<BigClass>();
// GUI types are tested in tst_QGuiMetaType.
}
void tst_QMetaType::constructInPlace()

60
tests/benchmarks/gui/kernel/qguimetatype/tst_qguimetatype.cpp
View File

@ -46,77 +46,27 @@ class tst_QGuiMetaType : public QObject
{
Q_OBJECT
public:
tst_QGuiMetaType();
virtual ~tst_QGuiMetaType();
private slots:
void constructGuiType_data();
void constructGuiType();
void constructGuiTypeCopy_data();
void constructGuiTypeCopy();
void constructInPlace_data();
void constructInPlace();
void constructInPlaceCopy_data();
void constructInPlaceCopy();
private:
void constructableGuiTypes();
};
tst_QGuiMetaType::tst_QGuiMetaType()
{
}
tst_QGuiMetaType::~tst_QGuiMetaType()
{
}
void tst_QGuiMetaType::constructGuiType_data()
void tst_QGuiMetaType::constructableGuiTypes()
{
QTest::addColumn<int>("typeId");
for (int i = QMetaType::FirstGuiType; i <= QMetaType::LastGuiType; ++i)
QTest::newRow(QMetaType::typeName(i)) << i;
}
// Tests how fast QMetaType can default-construct and destroy a Qt GUI
// type. The purpose of this benchmark is to measure the overhead of
// using type id-based creation compared to creating the type directly
// (i.e. "T *t = new T(); delete t;").
void tst_QGuiMetaType::constructGuiType()
{
QFETCH(int, typeId);
QBENCHMARK {
for (int i = 0; i < 100000; ++i) {
void *data = QMetaType::create(typeId, (void *)0);
QMetaType::destroy(typeId, data);
}
}
}
void tst_QGuiMetaType::constructGuiTypeCopy_data()
{
constructGuiType_data();
}
// Tests how fast QMetaType can copy-construct and destroy a Qt GUI
// type. The purpose of this benchmark is to measure the overhead of
// using type id-based creation compared to creating the type directly
// (i.e. "T *t = new T(other); delete t;").
void tst_QGuiMetaType::constructGuiTypeCopy()
{
QFETCH(int, typeId);
QVariant other(typeId, (void *)0);
const void *copy = other.constData();
QBENCHMARK {
for (int i = 0; i < 100000; ++i) {
void *data = QMetaType::create(typeId, copy);
QMetaType::destroy(typeId, data);
}
}
}
void tst_QGuiMetaType::constructInPlace_data()
{
constructGuiType_data();
constructableGuiTypes();
}
void tst_QGuiMetaType::constructInPlace()
@ -137,7 +87,7 @@ void tst_QGuiMetaType::constructInPlace()
void tst_QGuiMetaType::constructInPlaceCopy_data()
{
constructGuiType_data();
constructableGuiTypes();
}
void tst_QGuiMetaType::constructInPlaceCopy()