1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up old QVector benchmark

Browse Source 
Purge comments showing assember from an antique g++ version,
skip #if-ery that's always been on, so makes no difference,
rename two single-letter variables shared between files,
move some extern declarations to a header,
wrap parts of a source file in QT_{BEGIN,END}_NAMESPACE,
add a TODO against an antique commented out #if-ery kludge.

Change-Id: Ic4781960e0c9838027c21d3d392a50f29598132c
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
This commit is contained in:
Edward Welbourne 2021-07-08 15:38:22 +02:00 committed by Volker Hilsheimer
parent 406bb11a4e
commit a87411cefa
3 changed files with 68 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

253
tests/benchmarks/corelib/tools/qvector/main.cpp
View File

@ -34,148 +34,10 @@
#include <vector>
/*
Code generated by g++ 4.3.3. The lines marked with '!' are the ones that get
executed inside the loop. Using the external 's' causes some load making the
loop resembling a 'simple inner loop' in 'real' applications.
qvector_mutable_read_access:
.L166:
! movl -16(%ebp), %edx
! movl (%edx), %eax
! subl $1, %eax
! je .L165
movl 4(%edx), %eax
movl %eax, 8(%esp)
movl 8(%edx), %eax
movl %esi, (%esp)
movl %eax, 4(%esp)
call _ZN4myns7QVectorIdE7reallocEii
.L165:
! movl -16(%ebp), %eax
! fldl s
! faddl 16(%eax,%ebx,8)
! addl $1, %ebx
! cmpl $10000, %ebx
! fstpl s
! jne .L166
qvector_const_read_access:
movl -16(%ebp), %edx
xorl %eax, %eax
.L183:
! fldl s
! faddl 16(%edx,%eax,8)
! addl $1, %eax
! cmpl $10000, %eax
! fstpl s
! jne .L183
stdvector_const_read_access and stdvector_mutable_read_access and
qrawvector_const_read_access and qrawvector_mutable_read_access:
xorl %eax, %eax
.L64:
! fldl s
! faddl (%ebx,%eax,8)
! addl $1, %eax
! cmpl $10000, %eax
! fstpl s
! jne .L64
Behaviour varies with small modifications, but total is more or
less stable:
qrawvector_mutable_read_access, using size() instead of N:
.L145:
! faddl (%edx,%eax,8)
! addl $1, %eax
! cmpl %ecx, %eax
! fstl s
! jne .L145
! fstp %st(0)
qrawvector_mutable_read_access, counting backward:
.L145:
! faddl (%edx,%eax,8)
! subl $1, %eax
! cmpl $-1, %eax
! fstl s
! jne .L145
qrawvector_mutable_read_access, counting backward, using size():
.L146:
! faddl (%edx)
! addl $1, %eax
! subl $8, %edx
! cmpl %ecx, %eax
! fstl s
! jne .L146
/* Using 'extern accumulate' causes some load making the loop resembling a
'simple inner loop' in 'real' applications.
*/
/*
////////////////////////////////////////////////////////////////////
time ./tst_vector qvector_const_read_access
real 0m12.912s
user 0m12.401s
sys 0m0.016s
time ./tst_vector qvector_mutable_read_access
real 0m38.566s
user 0m36.754s
sys 0m0.008s
time ./tst_vector stdvector_mutable_read_access
real 0m12.736s
user 0m12.665s
sys 0m0.004s
////////////////////////////////////////////////////////////////////
time ./tst_vector qvector_fill_and_return
real 0m28.778s
user 0m28.522s
sys 0m0.012s
time ./tst_vector stdvector_fill_and_return
real 0m26.675s
user 0m26.558s
sys 0m0.012s
time ./tst_vector qrawvector_fill_and_return
real 0m23.370s
user 0m23.269s
sys 0m0.008s
*/
#define TEST_RETURN 1
#if TEST_RETURN
/* QRawVector::mutateToVector() hacks a semblance of a Qt 5 QVector.
However, Qt 6's QVector is Qt 6's QList and completely different in internal
@ -184,8 +46,8 @@ sys 0m0.008s
Qt6-compatible way, this test is suppressed, see QTBUG-95061.
*/
#define TEST_RAW 0
#endif
// TODO: is this still a thing ? (Dates from g++ 4.3.3 in 2009.)
// For some reason, both 'plain' and '-callgrind' create strange results
// (like varying instruction count for the same assembly code)
// So replace it by a plain loop and measure wall clock time.
@ -204,25 +66,18 @@ private slots:
void qvector_const_read_access();
void qvector_mutable_read_access();
void qvector_pop_back();
#ifdef TEST_RETURN
void qvector_fill_and_return();
#endif
// Purre Standard solution
void stdvector() { qWarning() << "std::vector results: "; }
void stdvector_const_read_access();
void stdvector_mutable_read_access();
void stdvector_pop_back();
#ifdef TEST_RETURN
void stdvector_fill_and_return();
#endif
// Build using std, pass as QVector
void mixedvector() { qWarning() << "mixed results: "; }
#ifdef TEST_RETURN
void mixedvector_fill_and_return();
#endif
// Alternative implementation
void qrawvector_separator() { qWarning() << "QRawVector results: "; }
@ -233,17 +88,14 @@ private slots:
#endif
};
const int N = 1000000;
extern double s;
void tst_QVector::calibration()
{
QVector<double> v(N);
for (int i = 0; i != N; ++i)
QVector<double> v(million);
for (int i = 0; i < million; ++i)
v[i] = i;
QBENCHMARK {
for (int i = 0; i != N; ++i)
s += i;
for (int i = 0; i < million; ++i)
accumulate += i;
}
}
@ -251,172 +103,151 @@ void tst_QVector::calibration()
void tst_QVector::qvector_const_read_access()
{
QVector<double> v(N);
for (int i = 0; i != N; ++i)
QVector<double> v(million);
for (int i = 0; i < million; ++i)
v[i] = i;
const QVector<double> &vc = v;
QBENCHMARK {
for (int i = 0; i != N; ++i)
s += vc[i];
for (int i = 0; i < million; ++i)
accumulate += vc[i];
}
}
void tst_QVector::qvector_mutable_read_access()
{
QVector<double> v(N);
for (int i = 0; i != N; ++i)
QVector<double> v(million);
for (int i = 0; i < million; ++i)
v[i] = i;
QBENCHMARK {
for (int i = 0; i != N; ++i)
s += v[i];
for (int i = 0; i < million; ++i)
accumulate += v[i];
}
}
#ifdef TEST_RETURN
extern QVector<double> qvector_fill_and_return_helper();
void tst_QVector::qvector_fill_and_return()
{
QBENCHMARK {
QVector<double> v = qvector_fill_and_return_helper();
s += v[1];
accumulate += v[1];
}
}
#endif
///////////////////// QRawVector /////////////////////
void tst_QVector::qrawvector_const_read_access()
{
QRawVector<double> v(N);
for (int i = 0; i != N; ++i)
QRawVector<double> v(million);
for (int i = 0; i < million; ++i)
v[i] = i;
const QRawVector<double> &vc = v;
QBENCHMARK {
for (int i = vc.size(); --i >= 0;)
s += vc[i];
accumulate += vc[i];
}
}
void tst_QVector::qrawvector_mutable_read_access()
{
QRawVector<double> v(N);
for (int i = 0; i != N; ++i)
QRawVector<double> v(million);
for (int i = 0; i < million; ++i)
v[i] = i;
QBENCHMARK {
for (int i = 0; i != N; ++i)
s += v[i];
for (int i = 0; i < million; ++i)
accumulate += v[i];
}
}
void tst_QVector::qvector_pop_back()
{
const int c1 = 100000;
QVERIFY(N % c1 == 0);
QVERIFY(million % c1 == 0);
QVector<int> v;
v.resize(N);
v.resize(million);
QBENCHMARK {
for (int i = 0; i < c1; ++i)
v.pop_back();
if (v.size() == 0)
v.resize(N);
v.resize(million);
}
}
#if TEST_RAW
extern QVector<double> qrawvector_fill_and_return_helper();
void tst_QVector::qrawvector_fill_and_return()
{
QBENCHMARK {
QVector<double> v = qrawvector_fill_and_return_helper();
s += v[1];
accumulate += v[1];
}
}
#endif
///////////////////// std::vector /////////////////////
void tst_QVector::stdvector_const_read_access()
{
std::vector<double> v(N);
for (int i = 0; i != N; ++i)
std::vector<double> v(million);
for (int i = 0; i < million; ++i)
v[i] = i;
const std::vector<double> &vc = v;
QBENCHMARK {
for (int i = 0; i != N; ++i)
s += vc[i];
for (int i = 0; i < million; ++i)
accumulate += vc[i];
}
}
void tst_QVector::stdvector_mutable_read_access()
{
std::vector<double> v(N);
for (int i = 0; i != N; ++i)
std::vector<double> v(million);
for (int i = 0; i < million; ++i)
v[i] = i;
QBENCHMARK {
for (int i = 0; i != N; ++i)
s += v[i];
for (int i = 0; i < million; ++i)
accumulate += v[i];
}
}
void tst_QVector::stdvector_pop_back()
{
const int c1 = 100000;
QVERIFY(N % c1 == 0);
const int size = million / 10;
QVERIFY(million % size == 0);
std::vector<int> v;
v.resize(N);
v.resize(million);
QBENCHMARK {
for (int i = 0; i < c1; ++i)
for (int i = 0; i < size; ++i)
v.pop_back();
if (v.size() == 0)
v.resize(N);
v.resize(million);
}
}
#ifdef TEST_RETURN
extern std::vector<double> stdvector_fill_and_return_helper();
void tst_QVector::stdvector_fill_and_return()
{
QBENCHMARK {
std::vector<double> v = stdvector_fill_and_return_helper();
s += v[1];
accumulate += v[1];
}
}
#endif
///////////////////// mixed vector /////////////////////
#ifdef TEST_RETURN
extern QVector<double> mixedvector_fill_and_return_helper();
void tst_QVector::mixedvector_fill_and_return()
{
QBENCHMARK {
std::vector<double> v = stdvector_fill_and_return_helper();
s += v[1];
accumulate += v[1];
}
}
#endif
QTEST_MAIN(tst_QVector)
#include "main.moc"

28
tests/benchmarks/corelib/tools/qvector/outofline.cpp
View File

@ -1,6 +1,6 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Copyright (C) 2021 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtTest module of the Qt Toolkit.
@ -27,32 +27,32 @@
****************************************************************************/
#include <QList>
#include <vector>
#include "qrawvector.h"
#include <vector>
const int N = 1000000;
double s = 0;
// Used as accumulator in tests:
double accumulate = 0;
QVector<double> qvector_fill_and_return_helper()
{
QVector<double> v(N);
for (int i = 0; i != N; ++i)
QVector<double> v(million);
for (int i = 0; i != million; ++i)
v[i] = i;
return v;
}
QVector<double> qrawvector_fill_and_return_helper()
{
QRawVector<double> v(N);
for (int i = 0; i != N; ++i)
QRawVector<double> v(million);
for (int i = 0; i != million; ++i)
v[i] = i;
return v.mutateToVector();
}
QVector<double> mixedvector_fill_and_return_helper()
{
std::vector<double> v(N);
for (int i = 0; i != N; ++i)
std::vector<double> v(million);
for (int i = 0; i != million; ++i)
v[i] = i;
return QVector<double>(v.begin(), v.end());
}
@ -60,8 +60,8 @@ QVector<double> mixedvector_fill_and_return_helper()
std::vector<double> stdvector_fill_and_return_helper()
{
std::vector<double> v(N);
for (int i = 0; i != N; ++i)
std::vector<double> v(million);
for (int i = 0; i != million; ++i)
v[i] = i;
return v;
}
@ -80,6 +80,8 @@ QVectorData *QVectorData::allocate(int size, int alignment)
return static_cast<QVectorData *>(alignment > alignmentThreshold() ? qMallocAligned(size, alignment) : ::malloc(size));
}
QT_BEGIN_NAMESPACE
QVectorData *QVectorData::reallocate(QVectorData *x, int newsize, int oldsize, int alignment)
{
if (alignment > alignmentThreshold())
@ -99,3 +101,5 @@ int QVectorData::grow(int sizeOfHeader, int size, int sizeOfT)
{
return qCalculateGrowingBlockSize(size, sizeOfT, sizeOfHeader).elementCount;
}
QT_END_NAMESPACE

12
tests/benchmarks/corelib/tools/qvector/qrawvector.h
View File

@ -1,6 +1,6 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Copyright (C) 2021 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
@ -41,8 +41,16 @@
#include <stdlib.h>
#include <string.h>
QT_BEGIN_NAMESPACE
const int million = 1000000;
extern double accumulate;
// Defined in outofline.cpp
extern QVector<double> qvector_fill_and_return_helper();
extern QVector<double> qrawvector_fill_and_return_helper();
extern std::vector<double> stdvector_fill_and_return_helper();
extern QVector<double> mixedvector_fill_and_return_helper();
QT_BEGIN_NAMESPACE
struct QVectorData
{