1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
5 **
6 ** This file is part of the test suite of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file. Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42
43 #include <QtTest/QtTest>
44
45 #include <QAtomicInt>
46 #include <QCoreApplication>
47
48 #include <limits.h>
49
50 //TESTED_CLASS=
51 //TESTED_FILES=
52
53 class tst_QAtomicInt : public QObject
54 {
55 Q_OBJECT
56
57 public:
58 tst_QAtomicInt();
59 ~tst_QAtomicInt();
60
61 private slots:
62 void warningFree();
63
64 // QAtomicInt members
65 void constructor_data();
66 void constructor();
67 void copy_constructor_data();
68 void copy_constructor();
69 void equality_operator_data();
70 void equality_operator();
71 void inequality_operator_data();
72 void inequality_operator();
73 void not_operator_data();
74 void not_operator();
75 void cast_operator_data();
76 void cast_operator();
77 void assignment_operator_data();
78 void assignment_operator();
79
80 void isReferenceCountingNative();
81 void isReferenceCountingWaitFree();
82 void ref_data();
83 void ref();
84 void deref_data();
85 void deref();
86
87 void isTestAndSetNative();
88 void isTestAndSetWaitFree();
89 void testAndSet_data();
90 void testAndSet();
91
92 void isFetchAndStoreNative();
93 void isFetchAndStoreWaitFree();
94 void fetchAndStore_data();
95 void fetchAndStore();
96
97 void isFetchAndAddNative();
98 void isFetchAndAddWaitFree();
99 void fetchAndAdd_data();
100 void fetchAndAdd();
101
102 // stress tests
103 void testAndSet_loop();
104 void fetchAndAdd_loop();
105 void fetchAndAdd_threadedLoop();
106
107 private:
108 static void warningFreeHelper();
109 };
110
tst_QAtomicInt()111 tst_QAtomicInt::tst_QAtomicInt()
112 { }
113
~tst_QAtomicInt()114 tst_QAtomicInt::~tst_QAtomicInt()
115 { }
116
warningFreeHelper()117 void tst_QAtomicInt::warningFreeHelper()
118 {
119 qFatal("This code is bogus, and shouldn't be run. We're looking for compiler warnings only.");
120
121 QBasicAtomicInt i = Q_BASIC_ATOMIC_INITIALIZER(0);
122
123 int expectedValue = 0;
124 int newValue = 0;
125 int valueToAdd = 0;
126
127 i.ref();
128 i.deref();
129
130 i.testAndSetRelaxed(expectedValue, newValue);
131 i.testAndSetAcquire(expectedValue, newValue);
132 i.testAndSetRelease(expectedValue, newValue);
133 i.testAndSetOrdered(expectedValue, newValue);
134
135 i.fetchAndStoreRelaxed(newValue);
136 i.fetchAndStoreAcquire(newValue);
137 i.fetchAndStoreRelease(newValue);
138 i.fetchAndStoreOrdered(newValue);
139
140 i.fetchAndAddRelaxed(valueToAdd);
141 i.fetchAndAddAcquire(valueToAdd);
142 i.fetchAndAddRelease(valueToAdd);
143 i.fetchAndAddOrdered(valueToAdd);
144 }
145
warningFree()146 void tst_QAtomicInt::warningFree()
147 {
148 // This is a compile time check for warnings.
149 // No need for actual work here.
150
151 void (*foo)() = &warningFreeHelper;
152 (void)foo;
153 }
154
constructor_data()155 void tst_QAtomicInt::constructor_data()
156 {
157 QTest::addColumn<int>("value");
158
159 QTest::newRow("0") << 31337;
160 QTest::newRow("1") << 0;
161 QTest::newRow("2") << 1;
162 QTest::newRow("3") << -1;
163 QTest::newRow("4") << 2;
164 QTest::newRow("5") << -2;
165 QTest::newRow("6") << 3;
166 QTest::newRow("7") << -3;
167 QTest::newRow("8") << INT_MAX;
168 QTest::newRow("9") << INT_MIN+1;
169 }
170
constructor()171 void tst_QAtomicInt::constructor()
172 {
173 QFETCH(int, value);
174 QAtomicInt atomic1(value);
175 QCOMPARE(int(atomic1), value);
176 QAtomicInt atomic2 = value;
177 QCOMPARE(int(atomic2), value);
178 }
179
copy_constructor_data()180 void tst_QAtomicInt::copy_constructor_data()
181 { constructor_data(); }
182
copy_constructor()183 void tst_QAtomicInt::copy_constructor()
184 {
185 QFETCH(int, value);
186 QAtomicInt atomic1(value);
187 QCOMPARE(int(atomic1), value);
188
189 QAtomicInt atomic2(atomic1);
190 QCOMPARE(int(atomic2), value);
191 QAtomicInt atomic3 = atomic1;
192 QCOMPARE(int(atomic3), value);
193 QAtomicInt atomic4(atomic2);
194 QCOMPARE(int(atomic4), value);
195 QAtomicInt atomic5 = atomic2;
196 QCOMPARE(int(atomic5), value);
197 }
198
equality_operator_data()199 void tst_QAtomicInt::equality_operator_data()
200 {
201 QTest::addColumn<int>("value1");
202 QTest::addColumn<int>("value2");
203 QTest::addColumn<int>("result");
204
205 QTest::newRow("success0") << 1 << 1 << 1;
206 QTest::newRow("success1") << -1 << -1 << 1;
207 QTest::newRow("failure0") << 0 << 1 << 0;
208 QTest::newRow("failure1") << 1 << 0 << 0;
209 QTest::newRow("failure2") << 0 << -1 << 0;
210 QTest::newRow("failure3") << -1 << 0 << 0;
211 }
212
equality_operator()213 void tst_QAtomicInt::equality_operator()
214 {
215 QFETCH(int, value1);
216 QFETCH(int, value2);
217 QAtomicInt x = value1;
218 QTEST(x == value2 ? 1 : 0, "result");
219 }
220
inequality_operator_data()221 void tst_QAtomicInt::inequality_operator_data()
222 {
223 QTest::addColumn<int>("value1");
224 QTest::addColumn<int>("value2");
225 QTest::addColumn<int>("result");
226
227 QTest::newRow("failure0") << 1 << 1 << 0;
228 QTest::newRow("failure1") << -1 << -1 << 0;
229 QTest::newRow("success0") << 0 << 1 << 1;
230 QTest::newRow("success1") << 1 << 0 << 1;
231 QTest::newRow("success2") << 0 << -1 << 1;
232 QTest::newRow("success3") << -1 << 0 << 1;
233 }
234
inequality_operator()235 void tst_QAtomicInt::inequality_operator()
236 {
237 QFETCH(int, value1);
238 QFETCH(int, value2);
239 QAtomicInt x = value1;
240 QTEST(x != value2 ? 1 : 0, "result");
241 }
242
not_operator_data()243 void tst_QAtomicInt::not_operator_data()
244 { constructor_data(); }
245
not_operator()246 void tst_QAtomicInt::not_operator()
247 {
248 QFETCH(int, value);
249 QAtomicInt atomic = value;
250 QCOMPARE(!atomic, !value);
251 }
252
cast_operator_data()253 void tst_QAtomicInt::cast_operator_data()
254 { constructor_data(); }
255
cast_operator()256 void tst_QAtomicInt::cast_operator()
257 {
258 QFETCH(int, value);
259 QAtomicInt atomic = value;
260 int copy = atomic;
261 QCOMPARE(copy, value);
262 }
263
assignment_operator_data()264 void tst_QAtomicInt::assignment_operator_data()
265 {
266 QTest::addColumn<int>("value");
267 QTest::addColumn<int>("newval");
268
269 QTest::newRow("value0") << 0 << 1;
270 QTest::newRow("value1") << 1 << 0;
271 QTest::newRow("value2") << 0 << -1;
272 QTest::newRow("value3") << -1 << 0;
273 QTest::newRow("value4") << -1 << 1;
274 QTest::newRow("value5") << 1 << -1;
275 }
276
assignment_operator()277 void tst_QAtomicInt::assignment_operator()
278 {
279 QFETCH(int, value);
280 QFETCH(int, newval);
281
282 {
283 QAtomicInt atomic1 = value;
284 atomic1 = newval;
285 QCOMPARE(int(atomic1), newval);
286 atomic1 = value;
287 QCOMPARE(int(atomic1), value);
288 QAtomicInt atomic2 = newval;
289 atomic1 = atomic2;
290 QCOMPARE(atomic1, atomic2);
291 }
292 }
293
isReferenceCountingNative()294 void tst_QAtomicInt::isReferenceCountingNative()
295 {
296 #if defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE)
297 // the runtime test should say the same thing
298 QVERIFY(QAtomicInt::isReferenceCountingNative());
299
300 # if (defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE) \
301 || defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE))
302 # error "Define only one of Q_ATOMIC_INT_REFERENCE_COUNTING_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
303 # endif
304 #elif defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE)
305 // could be either, just want to make sure the function is implemented
306 QVERIFY(QAtomicInt::isReferenceCountingNative() || !QAtomicInt::isReferenceCountingNative());
307
308 # if (defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE) \
309 || defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE))
310 # error "Define only one of Q_ATOMIC_INT_REFERENCE_COUNTING_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
311 # endif
312 #elif defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE)
313 // the runtime test should say the same thing
314 QVERIFY(!QAtomicInt::isReferenceCountingNative());
315
316 # if (defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE) \
317 || defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE))
318 # error "Define only one of Q_ATOMIC_INT_REFERENCE_COUNTING_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
319 # endif
320 #else
321 # error "Q_ATOMIC_INT_REFERENCE_COUNTING_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE is not defined"
322 #endif
323 }
324
isReferenceCountingWaitFree()325 void tst_QAtomicInt::isReferenceCountingWaitFree()
326 {
327 #if defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_WAIT_FREE)
328 // the runtime test should say the same thing
329 QVERIFY(QAtomicInt::isReferenceCountingWaitFree());
330
331 // enforce some invariants
332 QVERIFY(QAtomicInt::isReferenceCountingNative());
333 # if defined(Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE)
334 # error "Reference counting cannot be wait-free and unsupported at the same time!"
335 # endif
336 #else
337 // the runtime test should say the same thing
338 QVERIFY(!QAtomicInt::isReferenceCountingWaitFree());
339 #endif
340 }
341
ref_data()342 void tst_QAtomicInt::ref_data()
343 {
344 QTest::addColumn<int>("value");
345 QTest::addColumn<int>("result");
346 QTest::addColumn<int>("expected");
347
348 QTest::newRow("data0") << 0 << 1 << 1;
349 QTest::newRow("data1") << -1 << 0 << 0;
350 QTest::newRow("data2") << 1 << 1 << 2;
351 }
352
ref()353 void tst_QAtomicInt::ref()
354 {
355 QFETCH(int, value);
356 QAtomicInt x = value;
357 QTEST(x.ref() ? 1 : 0, "result");
358 QTEST(int(x), "expected");
359 }
360
deref_data()361 void tst_QAtomicInt::deref_data()
362 {
363 QTest::addColumn<int>("value");
364 QTest::addColumn<int>("result");
365 QTest::addColumn<int>("expected");
366
367 QTest::newRow("data0") << 0 << 1 << -1;
368 QTest::newRow("data1") << 1 << 0 << 0;
369 QTest::newRow("data2") << 2 << 1 << 1;
370 }
371
deref()372 void tst_QAtomicInt::deref()
373 {
374 QFETCH(int, value);
375 QAtomicInt x = value;
376 QTEST(x.deref() ? 1 : 0, "result");
377 QTEST(int(x), "expected");
378 }
379
isTestAndSetNative()380 void tst_QAtomicInt::isTestAndSetNative()
381 {
382 #if defined(Q_ATOMIC_INT_TEST_AND_SET_IS_ALWAYS_NATIVE)
383 // the runtime test should say the same thing
384 QVERIFY(QAtomicInt::isTestAndSetNative());
385
386 # if (defined(Q_ATOMIC_INT_TEST_AND_SET_IS_SOMETIMES_NATIVE) \
387 || defined(Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE))
388 # error "Define only one of Q_ATOMIC_INT_TEST_AND_SET_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
389 # endif
390 #elif defined(Q_ATOMIC_INT_TEST_AND_SET_IS_SOMETIMES_NATIVE)
391 // could be either, just want to make sure the function is implemented
392 QVERIFY(QAtomicInt::isTestAndSetNative() || !QAtomicInt::isTestAndSetNative());
393
394 # if (defined(Q_ATOMIC_INT_TEST_AND_SET_IS_ALWAYS_NATIVE) \
395 || defined(Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE))
396 # error "Define only one of Q_ATOMIC_INT_TEST_AND_SET_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
397 # endif
398 #elif defined(Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE)
399 // the runtime test should say the same thing
400 QVERIFY(!QAtomicInt::isTestAndSetNative());
401
402 # if (defined(Q_ATOMIC_INT_TEST_AND_SET_IS_ALWAYS_NATIVE) \
403 || defined(Q_ATOMIC_INT_TEST_AND_SET_IS_SOMETIMES_NATIVE))
404 # error "Define only one of Q_ATOMIC_INT_TEST_AND_SET_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
405 # endif
406 #else
407 # error "Q_ATOMIC_INT_TEST_AND_SET_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE is not defined"
408 #endif
409 }
410
isTestAndSetWaitFree()411 void tst_QAtomicInt::isTestAndSetWaitFree()
412 {
413 #if defined(Q_ATOMIC_INT_TEST_AND_SET_IS_WAIT_FREE)
414 // the runtime test should say the same thing
415 QVERIFY(QAtomicInt::isTestAndSetWaitFree());
416
417 // enforce some invariants
418 QVERIFY(QAtomicInt::isTestAndSetNative());
419 # if defined(Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE)
420 # error "Reference counting cannot be wait-free and unsupported at the same time!"
421 # endif
422 #else
423 // the runtime test should say the same thing
424 QVERIFY(!QAtomicInt::isTestAndSetWaitFree());
425 #endif
426 }
427
testAndSet_data()428 void tst_QAtomicInt::testAndSet_data()
429 {
430 QTest::addColumn<int>("value");
431 QTest::addColumn<int>("expected");
432 QTest::addColumn<int>("newval");
433 QTest::addColumn<int>("result");
434
435 // these should succeed
436 QTest::newRow("success0") << 0 << 0 << 0 << 1;
437 QTest::newRow("success1") << 0 << 0 << 1 << 1;
438 QTest::newRow("success2") << 0 << 0 << -1 << 1;
439 QTest::newRow("success3") << 1 << 1 << 0 << 1;
440 QTest::newRow("success4") << 1 << 1 << 1 << 1;
441 QTest::newRow("success5") << 1 << 1 << -1 << 1;
442 QTest::newRow("success6") << -1 << -1 << 0 << 1;
443 QTest::newRow("success7") << -1 << -1 << 1 << 1;
444 QTest::newRow("success8") << -1 << -1 << -1 << 1;
445 QTest::newRow("success9") << INT_MIN+1 << INT_MIN+1 << INT_MIN+1 << 1;
446 QTest::newRow("successA") << INT_MIN+1 << INT_MIN+1 << 1 << 1;
447 QTest::newRow("successB") << INT_MIN+1 << INT_MIN+1 << -1 << 1;
448 QTest::newRow("successC") << INT_MAX << INT_MAX << INT_MAX << 1;
449 QTest::newRow("successD") << INT_MAX << INT_MAX << 1 << 1;
450 QTest::newRow("successE") << INT_MAX << INT_MAX << -1 << 1;
451
452 // these should fail
453 QTest::newRow("failure0") << 0 << 1 << ~0 << 0;
454 QTest::newRow("failure1") << 0 << -1 << ~0 << 0;
455 QTest::newRow("failure2") << 1 << 0 << ~0 << 0;
456 QTest::newRow("failure3") << -1 << 0 << ~0 << 0;
457 QTest::newRow("failure4") << 1 << -1 << ~0 << 0;
458 QTest::newRow("failure5") << -1 << 1 << ~0 << 0;
459 QTest::newRow("failure6") << INT_MIN+1 << INT_MAX << ~0 << 0;
460 QTest::newRow("failure7") << INT_MAX << INT_MIN+1 << ~0 << 0;
461 }
462
testAndSet()463 void tst_QAtomicInt::testAndSet()
464 {
465 QFETCH(int, value);
466 QFETCH(int, expected);
467 QFETCH(int, newval);
468
469 {
470 QAtomicInt atomic = value;
471 QTEST(atomic.testAndSetRelaxed(expected, newval) ? 1 : 0, "result");
472 }
473
474 {
475 QAtomicInt atomic = value;
476 QTEST(atomic.testAndSetAcquire(expected, newval) ? 1 : 0, "result");
477 }
478
479 {
480 QAtomicInt atomic = value;
481 QTEST(atomic.testAndSetRelease(expected, newval) ? 1 : 0, "result");
482 }
483
484 {
485 QAtomicInt atomic = value;
486 QTEST(atomic.testAndSetOrdered(expected, newval) ? 1 : 0, "result");
487 }
488 }
489
isFetchAndStoreNative()490 void tst_QAtomicInt::isFetchAndStoreNative()
491 {
492 #if defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_ALWAYS_NATIVE)
493 // the runtime test should say the same thing
494 QVERIFY(QAtomicInt::isFetchAndStoreNative());
495
496 # if (defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_SOMETIMES_NATIVE) \
497 || defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE))
498 # error "Define only one of Q_ATOMIC_INT_FETCH_AND_STORE_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
499 # endif
500 #elif defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_SOMETIMES_NATIVE)
501 // could be either, just want to make sure the function is implemented
502 QVERIFY(QAtomicInt::isFetchAndStoreNative() || !QAtomicInt::isFetchAndStoreNative());
503
504 # if (defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_ALWAYS_NATIVE) \
505 || defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE))
506 # error "Define only one of Q_ATOMIC_INT_FETCH_AND_STORE_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
507 # endif
508 #elif defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE)
509 // the runtime test should say the same thing
510 QVERIFY(!QAtomicInt::isFetchAndStoreNative());
511
512 # if (defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_ALWAYS_NATIVE) \
513 || defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_SOMETIMES_NATIVE))
514 # error "Define only one of Q_ATOMIC_INT_FETCH_AND_STORE_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
515 # endif
516 #else
517 # error "Q_ATOMIC_INT_FETCH_AND_STORE_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE is not defined"
518 #endif
519 }
520
isFetchAndStoreWaitFree()521 void tst_QAtomicInt::isFetchAndStoreWaitFree()
522 {
523 #if defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_WAIT_FREE)
524 // the runtime test should say the same thing
525 QVERIFY(QAtomicInt::isFetchAndStoreWaitFree());
526
527 // enforce some invariants
528 QVERIFY(QAtomicInt::isFetchAndStoreNative());
529 # if defined(Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE)
530 # error "Reference counting cannot be wait-free and unsupported at the same time!"
531 # endif
532 #else
533 // the runtime test should say the same thing
534 QVERIFY(!QAtomicInt::isFetchAndStoreWaitFree());
535 #endif
536 }
537
fetchAndStore_data()538 void tst_QAtomicInt::fetchAndStore_data()
539 {
540 QTest::addColumn<int>("value");
541 QTest::addColumn<int>("newval");
542
543 QTest::newRow("data0") << 0 << 1;
544 QTest::newRow("data1") << 1 << 2;
545 QTest::newRow("data2") << 3 << 8;
546 }
547
fetchAndStore()548 void tst_QAtomicInt::fetchAndStore()
549 {
550 QFETCH(int, value);
551 QFETCH(int, newval);
552
553 {
554 QAtomicInt atomic = value;
555 QCOMPARE(atomic.fetchAndStoreRelaxed(newval), value);
556 QCOMPARE(int(atomic), newval);
557 }
558
559 {
560 QAtomicInt atomic = value;
561 QCOMPARE(atomic.fetchAndStoreAcquire(newval), value);
562 QCOMPARE(int(atomic), newval);
563 }
564
565 {
566 QAtomicInt atomic = value;
567 QCOMPARE(atomic.fetchAndStoreRelease(newval), value);
568 QCOMPARE(int(atomic), newval);
569 }
570
571 {
572 QAtomicInt atomic = value;
573 QCOMPARE(atomic.fetchAndStoreOrdered(newval), value);
574 QCOMPARE(int(atomic), newval);
575 }
576 }
577
isFetchAndAddNative()578 void tst_QAtomicInt::isFetchAndAddNative()
579 {
580 #if defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_ALWAYS_NATIVE)
581 // the runtime test should say the same thing
582 QVERIFY(QAtomicInt::isFetchAndAddNative());
583
584 # if (defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_SOMETIMES_NATIVE) \
585 || defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE))
586 # error "Define only one of Q_ATOMIC_INT_FETCH_AND_ADD_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
587 # endif
588 #elif defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_SOMETIMES_NATIVE)
589 // could be either, just want to make sure the function is implemented
590 QVERIFY(QAtomicInt::isFetchAndAddNative() || !QAtomicInt::isFetchAndAddNative());
591
592 # if (defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_ALWAYS_NATIVE) \
593 || defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE))
594 # error "Define only one of Q_ATOMIC_INT_FETCH_AND_ADD_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
595 # endif
596 #elif defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE)
597 // the runtime test should say the same thing
598 QVERIFY(!QAtomicInt::isFetchAndAddNative());
599
600 # if (defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_ALWAYS_NATIVE) \
601 || defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_SOMETIMES_NATIVE))
602 # error "Define only one of Q_ATOMIC_INT_FETCH_AND_ADD_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE"
603 # endif
604 #else
605 # error "Q_ATOMIC_INT_FETCH_AND_ADD_IS_{ALWAYS,SOMTIMES,NOT}_NATIVE is not defined"
606 #endif
607 }
608
isFetchAndAddWaitFree()609 void tst_QAtomicInt::isFetchAndAddWaitFree()
610 {
611 #if defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_WAIT_FREE)
612 // the runtime test should say the same thing
613 QVERIFY(QAtomicInt::isFetchAndAddWaitFree());
614
615 // enforce some invariants
616 QVERIFY(QAtomicInt::isFetchAndAddNative());
617 # if defined(Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE)
618 # error "Reference counting cannot be wait-free and unsupported at the same time!"
619 # endif
620 #else
621 // the runtime test should say the same thing
622 QVERIFY(!QAtomicInt::isFetchAndAddWaitFree());
623 #endif
624 }
625
fetchAndAdd_data()626 void tst_QAtomicInt::fetchAndAdd_data()
627 {
628 QTest::addColumn<int>("value1");
629 QTest::addColumn<int>("value2");
630
631 QTest::newRow("0+1") << 0 << 1;
632 QTest::newRow("1+0") << 1 << 0;
633 QTest::newRow("1+2") << 1 << 2;
634 QTest::newRow("2+1") << 2 << 1;
635 QTest::newRow("10+21") << 10 << 21;
636 QTest::newRow("31+40") << 31 << 40;
637 QTest::newRow("51+62") << 51 << 62;
638 QTest::newRow("72+81") << 72 << 81;
639 QTest::newRow("810+721") << 810 << 721;
640 QTest::newRow("631+540") << 631 << 540;
641 QTest::newRow("451+362") << 451 << 362;
642 QTest::newRow("272+181") << 272 << 181;
643 QTest::newRow("1810+8721") << 1810 << 8721;
644 QTest::newRow("3631+6540") << 3631 << 6540;
645 QTest::newRow("5451+4362") << 5451 << 4362;
646 QTest::newRow("7272+2181") << 7272 << 2181;
647
648 QTest::newRow("0+-1") << 0 << -1;
649 QTest::newRow("1+0") << 1 << 0;
650 QTest::newRow("1+-2") << 1 << -2;
651 QTest::newRow("2+-1") << 2 << -1;
652 QTest::newRow("10+-21") << 10 << -21;
653 QTest::newRow("31+-40") << 31 << -40;
654 QTest::newRow("51+-62") << 51 << -62;
655 QTest::newRow("72+-81") << 72 << -81;
656 QTest::newRow("810+-721") << 810 << -721;
657 QTest::newRow("631+-540") << 631 << -540;
658 QTest::newRow("451+-362") << 451 << -362;
659 QTest::newRow("272+-181") << 272 << -181;
660 QTest::newRow("1810+-8721") << 1810 << -8721;
661 QTest::newRow("3631+-6540") << 3631 << -6540;
662 QTest::newRow("5451+-4362") << 5451 << -4362;
663 QTest::newRow("7272+-2181") << 7272 << -2181;
664
665 QTest::newRow("0+1") << 0 << 1;
666 QTest::newRow("-1+0") << -1 << 0;
667 QTest::newRow("-1+2") << -1 << 2;
668 QTest::newRow("-2+1") << -2 << 1;
669 QTest::newRow("-10+21") << -10 << 21;
670 QTest::newRow("-31+40") << -31 << 40;
671 QTest::newRow("-51+62") << -51 << 62;
672 QTest::newRow("-72+81") << -72 << 81;
673 QTest::newRow("-810+721") << -810 << 721;
674 QTest::newRow("-631+540") << -631 << 540;
675 QTest::newRow("-451+362") << -451 << 362;
676 QTest::newRow("-272+181") << -272 << 181;
677 QTest::newRow("-1810+8721") << -1810 << 8721;
678 QTest::newRow("-3631+6540") << -3631 << 6540;
679 QTest::newRow("-5451+4362") << -5451 << 4362;
680 QTest::newRow("-7272+2181") << -7272 << 2181;
681 }
682
fetchAndAdd()683 void tst_QAtomicInt::fetchAndAdd()
684 {
685 QFETCH(int, value1);
686 QFETCH(int, value2);
687 int result;
688
689 {
690 QAtomicInt atomic = value1;
691 result = atomic.fetchAndAddRelaxed(value2);
692 QCOMPARE(result, value1);
693 QCOMPARE(int(atomic), value1 + value2);
694 }
695
696 {
697 QAtomicInt atomic = value1;
698 result = atomic.fetchAndAddAcquire(value2);
699 QCOMPARE(result, value1);
700 QCOMPARE(int(atomic), value1 + value2);
701 }
702
703 {
704 QAtomicInt atomic = value1;
705 result = atomic.fetchAndAddRelease(value2);
706 QCOMPARE(result, value1);
707 QCOMPARE(int(atomic), value1 + value2);
708 }
709
710 {
711 QAtomicInt atomic = value1;
712 result = atomic.fetchAndAddOrdered(value2);
713 QCOMPARE(result, value1);
714 QCOMPARE(int(atomic), value1 + value2);
715 }
716 }
717
testAndSet_loop()718 void tst_QAtomicInt::testAndSet_loop()
719 {
720 QTime stopWatch;
721 stopWatch.start();
722
723 int iterations = 10000000;
724
725 QAtomicInt val=0;
726 for (int i = 0; i < iterations; ++i) {
727 QVERIFY(val.testAndSetRelaxed(val, val+1));
728 if ((i % 1000) == 999) {
729 if (stopWatch.elapsed() > 60 * 1000) {
730 // This test shouldn't run for more than two minutes.
731 qDebug("Interrupted test after %d iterations (%.2f iterations/sec)",
732 i, (i * 1000.0) / double(stopWatch.elapsed()));
733 break;
734 }
735 }
736 }
737 }
738
fetchAndAdd_loop()739 void tst_QAtomicInt::fetchAndAdd_loop()
740 {
741 int iterations = 10000000;
742 #if defined (Q_OS_HPUX)
743 iterations = 1000000;
744 #endif
745
746 QAtomicInt val=0;
747 for (int i = 0; i < iterations; ++i) {
748 const int prev = val.fetchAndAddRelaxed(1);
749 QCOMPARE(prev, int(val) -1);
750 }
751 }
752
753 class FetchAndAddThread : public QThread
754 {
755 public:
run()756 void run()
757 {
758
759 for (int i = 0; i < iterations; ++i)
760 val->fetchAndAddAcquire(1);
761
762 for (int i = 0; i < iterations; ++i)
763 val->fetchAndAddAcquire(-1);
764
765 }
766 QAtomicInt *val;
767 int iterations;
768 };
769
770
fetchAndAdd_threadedLoop()771 void tst_QAtomicInt::fetchAndAdd_threadedLoop()
772 {
773 QAtomicInt val;
774 FetchAndAddThread t1;
775 t1.val = &val;
776 t1.iterations = 1000000;
777
778 FetchAndAddThread t2;
779 t2.val = &val;
780 t2.iterations = 2000000;
781
782 t1.start();
783 t2.start();
784 t1.wait();
785 t2.wait();
786
787 QCOMPARE(int(val), 0);
788 }
789
790 QTEST_MAIN(tst_QAtomicInt)
791 #include "tst_qatomicint.moc"
792