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

Fix the benchmark for QList::removeAll()

Browse Source 
The benchmark was making assumptions about number of
constructor/assignment operator calls, which are not valid in Qt 6,
after the implementation of QList has changed. Considering that we
already check number of constructions, copy constructions, etc., in
tst_qlist.cpp, remove the checks from the benchmark.

As a driveby, fix the following warning:
"warning: parameter 'i' shadows member inherited from type 'MyBase'"

Pick-to: 6.2
Fixes: QTBUG-95096
Change-Id: Ida68fa5803641c8fa84f8309c0093986ed4c0a2b
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
This commit is contained in:
Sona Kurazyan 2021-12-07 14:16:27 +01:00
parent b886a7ca65
commit 0fbeac0115
1 changed files with 28 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
tests/benchmarks/corelib/tools/qlist/tst_bench_qlist.cpp
View File

@ -35,88 +35,42 @@ static const int N = 1000;
struct MyBase
{
MyBase(int i_)
: isCopy(false)
{
++liveCount;
MyBase(int i_) : i(i_) { }
i = i_;
}
MyBase(const MyBase &other)
: isCopy(true)
{
if (isCopy)
++copyCount;
++liveCount;
i = other.i;
}
MyBase(const MyBase &other) : i(other.i) { }
MyBase &operator=(const MyBase &other)
{
if (!isCopy) {
isCopy = true;
++copyCount;
} else {
++errorCount;
}
i = other.i;
return *this;
}
~MyBase()
{
if (isCopy) {
if (!copyCount)
++errorCount;
else
--copyCount;
}
if (!liveCount)
++errorCount;
else
--liveCount;
}
bool operator==(const MyBase &other) const
{ return i == other.i; }
protected:
ushort i;
bool isCopy;
public:
static int errorCount;
static int liveCount;
static int copyCount;
int i;
};
int MyBase::errorCount = 0;
int MyBase::liveCount = 0;
int MyBase::copyCount = 0;
struct MyPrimitive : public MyBase
{
MyPrimitive(int i = -1) : MyBase(i)
{ ++errorCount; }
MyPrimitive(const MyPrimitive &other) : MyBase(other)
{ ++errorCount; }
MyPrimitive(int i_ = -1) : MyBase(i_) { }
MyPrimitive(const MyPrimitive &other) : MyBase(other) { }
MyPrimitive &operator=(const MyPrimitive &other)
{ ++errorCount; MyBase::operator=(other); return *this; }
~MyPrimitive()
{ ++errorCount; }
{
MyBase::operator=(other);
return *this;
}
};
struct MyMovable : public MyBase
{
MyMovable(int i = -1) : MyBase(i) {}
MyMovable(int i_ = -1) : MyBase(i_) {}
};
struct MyComplex : public MyBase
{
MyComplex(int i = -1) : MyBase(i) {}
MyComplex(int i_ = -1) : MyBase(i_) {}
};
QT_BEGIN_NAMESPACE
@ -283,50 +237,29 @@ private:
template <class T>
void tst_QList::removeAll_impl() const
{
QSKIP("QTBUG-95096: known to be broken (for some test-cases) since Qt 6.0");
QFETCH(QList<int>, i10);
QFETCH(int, itemsToRemove);
constexpr int valueToRemove = 5;
constexpr bool isComplex = QTypeInfo<T>::isComplex;
MyBase::errorCount = 0;
MyBase::liveCount = 0;
MyBase::copyCount = 0;
{
QList<T> list;
QCOMPARE(MyBase::liveCount, 0);
QCOMPARE(MyBase::copyCount, 0);
for (int i = 0; i < 10 * N; ++i) {
T t(i10.at(i % 10));
list.append(t);
}
QCOMPARE(MyBase::liveCount, isComplex ? list.size() : 0);
QCOMPARE(MyBase::copyCount, isComplex ? list.size() : 0);
T t(valueToRemove);
QCOMPARE(MyBase::liveCount, isComplex ? list.size() + 1 : 1);
QCOMPARE(MyBase::copyCount, isComplex ? list.size() : 0);
int removedCount = 0; // make compiler happy by setting to 0
QList<T> l;
QBENCHMARK {
l = list;
removedCount = l.removeAll(t);
}
QCOMPARE(removedCount, itemsToRemove * N);
QCOMPARE(l.size() + removedCount, list.size());
QVERIFY(!l.contains(valueToRemove));
QCOMPARE(MyBase::liveCount,
isComplex ? l.isDetached() ? list.size() + l.size() + 1 : list.size() + 1 : 1);
QCOMPARE(MyBase::copyCount,
isComplex ? l.isDetached() ? list.size() + l.size() : list.size() : 0);
QList<T> list;
for (int i = 0; i < 10 * N; ++i) {
T t(i10.at(i % 10));
list.append(t);
}
if (isComplex)
QCOMPARE(MyBase::errorCount, 0);
T t(valueToRemove);
qsizetype removedCount = 0; // make compiler happy by setting to 0
QList<T> l;
QBENCHMARK {
l = list;
removedCount = l.removeAll(t);
}
QCOMPARE(removedCount, itemsToRemove * N);
QCOMPARE(l.size() + removedCount, list.size());
QVERIFY(!l.contains(valueToRemove));
}
void tst_QList::removeAll_primitive_data()