Clean up old QVector benchmark

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>

3 files changed, 68 insertions, 225 deletions

diff --git a/tests/benchmarks/corelib/tools/qvector/main.cpp b/tests/benchmarks/corelib/tools/qvector/main.cpp
index 6d1354cb6a..150f448493 100644
--- a/tests/benchmarks/corelib/tools/qvector/main.cpp
+++ b/tests/benchmarks/corelib/tools/qvector/main.cpp
@@ -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"
diff --git a/tests/benchmarks/corelib/tools/qvector/outofline.cpp b/tests/benchmarks/corelib/tools/qvector/outofline.cpp
index daa630efe1..ec2110120e 100644
--- a/tests/benchmarks/corelib/tools/qvector/outofline.cpp
+++ b/tests/benchmarks/corelib/tools/qvector/outofline.cpp
@@ -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
diff --git a/tests/benchmarks/corelib/tools/qvector/qrawvector.h b/tests/benchmarks/corelib/tools/qvector/qrawvector.h
index 3d827c7921..df3c11b223 100644
--- a/tests/benchmarks/corelib/tools/qvector/qrawvector.h
+++ b/tests/benchmarks/corelib/tools/qvector/qrawvector.h
@@ -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
 {