Blender  V3.3
atomic_test.cc
Go to the documentation of this file.
1 /* Apache License, Version 2.0 */
2 
3 #include <limits>
4 
5 #include "atomic_ops.h"
6 #include "testing/testing.h"
7 
8 #ifdef __GNUC__
9 # if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 /* gcc4.6+ only */
10 # pragma GCC diagnostic error "-Wsign-compare"
11 # endif
12 # if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408
13 # pragma GCC diagnostic error "-Wsign-conversion"
14 # endif
15 #endif
16 
17 /* -------------------------------------------------------------------- */
22 {
23  {
24  uint64_t value = 1;
26  EXPECT_EQ(value, 3);
27  }
28 
29  {
30  uint64_t value = 0x1020304050607080;
31  EXPECT_EQ(atomic_add_and_fetch_uint64(&value, 0x0807060504030201), 0x1827364554637281);
32  EXPECT_EQ(value, 0x1827364554637281);
33  }
34 
35  {
36  uint64_t value = 0x9020304050607080;
37  EXPECT_EQ(atomic_add_and_fetch_uint64(&value, 0x0807060504030201), 0x9827364554637281);
38  EXPECT_EQ(value, 0x9827364554637281);
39  }
40 }
41 
43 {
44  {
45  uint64_t value = 3;
47  EXPECT_EQ(value, 1);
48  }
49 
50  {
51  uint64_t value = 0x1827364554637281;
52  EXPECT_EQ(atomic_sub_and_fetch_uint64(&value, 0x0807060504030201), 0x1020304050607080);
53  EXPECT_EQ(value, 0x1020304050607080);
54  }
55 
56  {
57  uint64_t value = 0x9827364554637281;
58  EXPECT_EQ(atomic_sub_and_fetch_uint64(&value, 0x0807060504030201), 0x9020304050607080);
59  EXPECT_EQ(value, 0x9020304050607080);
60  }
61 
62  {
63  uint64_t value = 1;
64  EXPECT_EQ(atomic_sub_and_fetch_uint64(&value, 2), 0xffffffffffffffff);
65  EXPECT_EQ(value, 0xffffffffffffffff);
66  }
67 }
68 
70 {
71  {
72  uint64_t value = 1;
74  EXPECT_EQ(value, 3);
75  }
76 
77  {
78  uint64_t value = 0x1020304050607080;
79  EXPECT_EQ(atomic_fetch_and_add_uint64(&value, 0x0807060504030201), 0x1020304050607080);
80  EXPECT_EQ(value, 0x1827364554637281);
81  }
82 
83  {
84  uint64_t value = 0x9020304050607080;
85  EXPECT_EQ(atomic_fetch_and_add_uint64(&value, 0x0807060504030201), 0x9020304050607080);
86  EXPECT_EQ(value, 0x9827364554637281);
87  }
88 }
89 
91 {
92  {
93  uint64_t value = 3;
95  EXPECT_EQ(value, 1);
96  }
97 
98  {
99  uint64_t value = 0x1827364554637281;
100  EXPECT_EQ(atomic_fetch_and_sub_uint64(&value, 0x0807060504030201), 0x1827364554637281);
101  EXPECT_EQ(value, 0x1020304050607080);
102  }
103 
104  {
105  uint64_t value = 0x9827364554637281;
106  EXPECT_EQ(atomic_fetch_and_sub_uint64(&value, 0x0807060504030201), 0x9827364554637281);
107  EXPECT_EQ(value, 0x9020304050607080);
108  }
109 
110  {
111  uint64_t value = 1;
112  EXPECT_EQ(atomic_fetch_and_sub_uint64(&value, 2), 1);
113  EXPECT_EQ(value, 0xffffffffffffffff);
114  }
115 }
116 
118 {
119  {
120  uint64_t value = 1;
121  EXPECT_EQ(atomic_cas_uint64(&value, 1, 2), 1);
122  EXPECT_EQ(value, 2);
123  }
124 
125  {
126  uint64_t value = 1;
127  EXPECT_EQ(atomic_cas_uint64(&value, 2, 3), 1);
128  EXPECT_EQ(value, 1);
129  }
130 
131  {
132  uint64_t value = 0x1234567890abcdef;
133  EXPECT_EQ(atomic_cas_uint64(&value, 0x1234567890abcdef, 0xfedcba0987654321),
134  0x1234567890abcdef);
135  EXPECT_EQ(value, 0xfedcba0987654321);
136  }
137 
138  {
139  uint64_t value = 0x1234567890abcdef;
140  EXPECT_EQ(atomic_cas_uint64(&value, 0xdeadbeefefefefef, 0xfedcba0987654321),
141  0x1234567890abcdef);
142  EXPECT_EQ(value, 0x1234567890abcdef);
143  }
144 }
145 
147 {
148  /* Make sure alias is implemented. */
149  {
150  uint64_t value = 2;
151  EXPECT_EQ(atomic_load_uint64(&value), 2);
152  }
153 
154  /* Make sure alias is using proper bitness. */
155  {
156  const uint64_t uint64_t_max = std::numeric_limits<uint64_t>::max();
157  uint64_t value = uint64_t_max;
158  EXPECT_EQ(atomic_load_uint64(&value), uint64_t_max);
159  }
160 }
161 
163 {
164  /* Make sure alias is implemented. */
165  {
166  uint64_t value = 0;
167  atomic_store_uint64(&value, 2);
168  EXPECT_EQ(value, 2);
169  }
170 
171  /* Make sure alias is using proper bitness. */
172  {
173  const uint64_t uint64_t_max = std::numeric_limits<uint64_t>::max();
174  uint64_t value = 0;
175  atomic_store_uint64(&value, uint64_t_max);
176  EXPECT_EQ(value, uint64_t_max);
177  }
178 }
179 
182 /* -------------------------------------------------------------------- */
187 {
188  {
189  int64_t value = 1;
190  EXPECT_EQ(atomic_add_and_fetch_int64(&value, 2), 3);
191  EXPECT_EQ(value, 3);
192  }
193 
194  {
195  int64_t value = 0x1020304050607080;
196  EXPECT_EQ(atomic_add_and_fetch_int64(&value, 0x0807060504030201), 0x1827364554637281);
197  EXPECT_EQ(value, 0x1827364554637281);
198  }
199 
200  {
201  int64_t value = -0x1020304050607080;
202  EXPECT_EQ(atomic_add_and_fetch_int64(&value, -0x0807060504030201), -0x1827364554637281);
203  EXPECT_EQ(value, -0x1827364554637281);
204  }
205 }
206 
208 {
209  {
210  int64_t value = 3;
211  EXPECT_EQ(atomic_sub_and_fetch_int64(&value, 2), 1);
212  EXPECT_EQ(value, 1);
213  }
214 
215  {
216  int64_t value = 0x1827364554637281;
217  EXPECT_EQ(atomic_sub_and_fetch_int64(&value, 0x0807060504030201), 0x1020304050607080);
218  EXPECT_EQ(value, 0x1020304050607080);
219  }
220 
221  {
222  int64_t value = -0x1827364554637281;
223  EXPECT_EQ(atomic_sub_and_fetch_int64(&value, -0x0807060504030201), -0x1020304050607080);
224  EXPECT_EQ(value, -0x1020304050607080);
225  }
226 
227  {
228  int64_t value = 1;
229  EXPECT_EQ(atomic_sub_and_fetch_int64(&value, 2), -1);
230  EXPECT_EQ(value, -1);
231  }
232 }
233 
235 {
236  {
237  int64_t value = 1;
238  EXPECT_EQ(atomic_fetch_and_add_int64(&value, 2), 1);
239  EXPECT_EQ(value, 3);
240  }
241 
242  {
243  int64_t value = 0x1020304050607080;
244  EXPECT_EQ(atomic_fetch_and_add_int64(&value, 0x0807060504030201), 0x1020304050607080);
245  EXPECT_EQ(value, 0x1827364554637281);
246  }
247 
248  {
249  int64_t value = -0x1020304050607080;
250  EXPECT_EQ(atomic_fetch_and_add_int64(&value, -0x0807060504030201), -0x1020304050607080);
251  EXPECT_EQ(value, -0x1827364554637281);
252  }
253 }
254 
256 {
257  {
258  int64_t value = 3;
259  EXPECT_EQ(atomic_fetch_and_sub_int64(&value, 2), 3);
260  EXPECT_EQ(value, 1);
261  }
262 
263  {
264  int64_t value = 0x1827364554637281;
265  EXPECT_EQ(atomic_fetch_and_sub_int64(&value, 0x0807060504030201), 0x1827364554637281);
266  EXPECT_EQ(value, 0x1020304050607080);
267  }
268 
269  {
270  int64_t value = -0x1827364554637281;
271  EXPECT_EQ(atomic_fetch_and_sub_int64(&value, -0x0807060504030201), -0x1827364554637281);
272  EXPECT_EQ(value, -0x1020304050607080);
273  }
274 
275  {
276  int64_t value = 1;
277  EXPECT_EQ(atomic_fetch_and_sub_int64(&value, 2), 1);
278  EXPECT_EQ(value, -1);
279  }
280 }
281 
283 {
284  {
285  int64_t value = 1;
286  EXPECT_EQ(atomic_cas_int64(&value, 1, 2), 1);
287  EXPECT_EQ(value, 2);
288  }
289 
290  {
291  int64_t value = 1;
292  EXPECT_EQ(atomic_cas_int64(&value, 2, 3), 1);
293  EXPECT_EQ(value, 1);
294  }
295 
296  // 0xfedcba0987654321 is -0x012345f6789abcdf
297  // 0xdeadbeefefefefef is -0x2152411010101011
298 
299  {
300  int64_t value = 0x1234567890abcdef;
301  EXPECT_EQ(atomic_cas_int64(&value, 0x1234567890abcdef, -0x012345f6789abcdf),
302  0x1234567890abcdef);
303  EXPECT_EQ(value, -0x012345f6789abcdf);
304  }
305 
306  {
307  int64_t value = 0x1234567890abcdef;
308  EXPECT_EQ(atomic_cas_int64(&value, 0x2152411010101011, -0x012345f6789abcdf),
309  0x1234567890abcdef);
310  EXPECT_EQ(value, 0x1234567890abcdef);
311  }
312 }
313 
315 {
316  /* Make sure alias is implemented. */
317  {
318  int64_t value = 2;
319  EXPECT_EQ(atomic_load_int64(&value), 2);
320  }
321 
322  /* Make sure alias is using proper bitness. */
323  {
324  const int64_t int64_t_max = std::numeric_limits<int64_t>::max();
325  int64_t value = int64_t_max;
326  EXPECT_EQ(atomic_load_int64(&value), int64_t_max);
327  }
328 }
329 
331 {
332  /* Make sure alias is implemented. */
333  {
334  int64_t value = 0;
335  atomic_store_int64(&value, 2);
336  EXPECT_EQ(value, 2);
337  }
338 
339  /* Make sure alias is using proper bitness. */
340  {
341  const int64_t int64_t_max = std::numeric_limits<int64_t>::max();
342  int64_t value = 0;
343  atomic_store_int64(&value, int64_t_max);
344  EXPECT_EQ(value, int64_t_max);
345  }
346 }
347 
350 /* -------------------------------------------------------------------- */
355 {
356  {
357  uint32_t value = 1;
358  EXPECT_EQ(atomic_add_and_fetch_uint32(&value, 2), 3);
359  EXPECT_EQ(value, 3);
360  }
361 
362  {
363  uint32_t value = 0x10203040;
364  EXPECT_EQ(atomic_add_and_fetch_uint32(&value, 0x04030201), 0x14233241);
365  EXPECT_EQ(value, 0x14233241);
366  }
367 
368  {
369  uint32_t value = 0x90203040;
370  EXPECT_EQ(atomic_add_and_fetch_uint32(&value, 0x04030201), 0x94233241);
371  EXPECT_EQ(value, 0x94233241);
372  }
373 }
374 
376 {
377  {
378  uint32_t value = 3;
379  EXPECT_EQ(atomic_sub_and_fetch_uint32(&value, 2), 1);
380  EXPECT_EQ(value, 1);
381  }
382 
383  {
384  uint32_t value = 0x14233241;
385  EXPECT_EQ(atomic_sub_and_fetch_uint32(&value, 0x04030201), 0x10203040);
386  EXPECT_EQ(value, 0x10203040);
387  }
388 
389  {
390  uint32_t value = 0x94233241;
391  EXPECT_EQ(atomic_sub_and_fetch_uint32(&value, 0x04030201), 0x90203040);
392  EXPECT_EQ(value, 0x90203040);
393  }
394 
395  {
396  uint32_t value = 1;
397  EXPECT_EQ(atomic_sub_and_fetch_uint32(&value, 2), 0xffffffff);
398  EXPECT_EQ(value, 0xffffffff);
399  }
400 }
401 
403 {
404  {
405  uint32_t value = 1;
406  EXPECT_EQ(atomic_cas_uint32(&value, 1, 2), 1);
407  EXPECT_EQ(value, 2);
408  }
409 
410  {
411  uint32_t value = 1;
412  EXPECT_EQ(atomic_cas_uint32(&value, 2, 3), 1);
413  EXPECT_EQ(value, 1);
414  }
415 
416  {
417  uint32_t value = 0x12345678;
418  EXPECT_EQ(atomic_cas_uint32(&value, 0x12345678, 0x87654321), 0x12345678);
419  EXPECT_EQ(value, 0x87654321);
420  }
421 
422  {
423  uint32_t value = 0x12345678;
424  EXPECT_EQ(atomic_cas_uint32(&value, 0xdeadbeef, 0x87654321), 0x12345678);
425  EXPECT_EQ(value, 0x12345678);
426  }
427 }
428 
430 {
431  /* Make sure alias is implemented. */
432  {
433  uint32_t value = 2;
434  EXPECT_EQ(atomic_load_uint32(&value), 2);
435  }
436 
437  /* Make sure alias is using proper bitness. */
438  {
439  const uint32_t uint32_t_max = std::numeric_limits<uint32_t>::max();
440  uint32_t value = uint32_t_max;
441  EXPECT_EQ(atomic_load_uint32(&value), uint32_t_max);
442  }
443 }
444 
446 {
447  /* Make sure alias is implemented. */
448  {
449  uint32_t value = 0;
450  atomic_store_uint32(&value, 2);
451  EXPECT_EQ(value, 2);
452  }
453 
454  /* Make sure alias is using proper bitness. */
455  {
456  const uint32_t uint32_t_max = std::numeric_limits<uint32_t>::max();
457  uint32_t value = 0;
458  atomic_store_uint32(&value, uint32_t_max);
459  EXPECT_EQ(value, uint32_t_max);
460  }
461 }
462 
464 {
465  {
466  uint32_t value = 1;
467  EXPECT_EQ(atomic_fetch_and_add_uint32(&value, 2), 1);
468  EXPECT_EQ(value, 3);
469  }
470 
471  {
472  uint32_t value = 0x10203040;
473  EXPECT_EQ(atomic_fetch_and_add_uint32(&value, 0x04030201), 0x10203040);
474  EXPECT_EQ(value, 0x14233241);
475  }
476 
477  {
478  uint32_t value = 0x90203040;
479  EXPECT_EQ(atomic_fetch_and_add_uint32(&value, 0x04030201), 0x90203040);
480  EXPECT_EQ(value, 0x94233241);
481  }
482 }
483 
485 {
486  {
487  uint32_t value = 12;
488  EXPECT_EQ(atomic_fetch_and_or_uint32(&value, 5), 12);
489  EXPECT_EQ(value, 13);
490  }
491 
492  {
493  uint32_t value = 0x12345678;
494  EXPECT_EQ(atomic_fetch_and_or_uint32(&value, 0x87654321), 0x12345678);
495  EXPECT_EQ(value, 0x97755779);
496  }
497 
498  {
499  uint32_t value = 0x92345678;
500  EXPECT_EQ(atomic_fetch_and_or_uint32(&value, 0x87654321), 0x92345678);
501  EXPECT_EQ(value, 0x97755779);
502  }
503 }
504 
506 {
507  {
508  uint32_t value = 12;
509  EXPECT_EQ(atomic_fetch_and_and_uint32(&value, 5), 12);
510  EXPECT_EQ(value, 4);
511  }
512 
513  {
514  uint32_t value = 0x12345678;
515  EXPECT_EQ(atomic_fetch_and_and_uint32(&value, 0x87654321), 0x12345678);
516  EXPECT_EQ(value, 0x02244220);
517  }
518 
519  {
520  uint32_t value = 0x92345678;
521  EXPECT_EQ(atomic_fetch_and_and_uint32(&value, 0x87654321), 0x92345678);
522  EXPECT_EQ(value, 0x82244220);
523  }
524 }
525 
528 /* -------------------------------------------------------------------- */
533 {
534  {
535  int32_t value = 1;
536  EXPECT_EQ(atomic_add_and_fetch_int32(&value, 2), 3);
537  EXPECT_EQ(value, 3);
538  }
539 
540  {
541  int32_t value = 0x10203040;
542  EXPECT_EQ(atomic_add_and_fetch_int32(&value, 0x04030201), 0x14233241);
543  EXPECT_EQ(value, 0x14233241);
544  }
545 
546  {
547  int32_t value = -0x10203040;
548  EXPECT_EQ(atomic_add_and_fetch_int32(&value, -0x04030201), -0x14233241);
549  EXPECT_EQ(value, -0x14233241);
550  }
551 }
552 
554 {
555  {
556  int32_t value = 3;
557  EXPECT_EQ(atomic_sub_and_fetch_int32(&value, 2), 1);
558  EXPECT_EQ(value, 1);
559  }
560 
561  {
562  int32_t value = 0x14233241;
563  EXPECT_EQ(atomic_sub_and_fetch_int32(&value, 0x04030201), 0x10203040);
564  EXPECT_EQ(value, 0x10203040);
565  }
566 
567  {
568  int32_t value = -0x14233241;
569  EXPECT_EQ(atomic_sub_and_fetch_int32(&value, -0x04030201), -0x10203040);
570  EXPECT_EQ(value, -0x10203040);
571  }
572 
573  {
574  int32_t value = 1;
575  EXPECT_EQ(atomic_sub_and_fetch_int32(&value, 2), 0xffffffff);
576  EXPECT_EQ(value, 0xffffffff);
577  }
578 }
579 
581 {
582  {
583  int32_t value = 1;
584  EXPECT_EQ(atomic_cas_int32(&value, 1, 2), 1);
585  EXPECT_EQ(value, 2);
586  }
587 
588  {
589  int32_t value = 1;
590  EXPECT_EQ(atomic_cas_int32(&value, 2, 3), 1);
591  EXPECT_EQ(value, 1);
592  }
593 
594  // 0x87654321 is -0x789abcdf
595  // 0xdeadbeef is -0x21524111
596 
597  {
598  int32_t value = 0x12345678;
599  EXPECT_EQ(atomic_cas_int32(&value, 0x12345678, -0x789abcdf), 0x12345678);
600  EXPECT_EQ(value, -0x789abcdf);
601  }
602 
603  {
604  int32_t value = 0x12345678;
605  EXPECT_EQ(atomic_cas_int32(&value, -0x21524111, -0x789abcdf), 0x12345678);
606  EXPECT_EQ(value, 0x12345678);
607  }
608 }
609 
611 {
612  /* Make sure alias is implemented. */
613  {
614  int32_t value = 2;
615  EXPECT_EQ(atomic_load_int32(&value), 2);
616  }
617 
618  /* Make sure alias is using proper bitness. */
619  {
620  const int32_t int32_t_max = std::numeric_limits<int32_t>::max();
621  int32_t value = int32_t_max;
622  EXPECT_EQ(atomic_load_int32(&value), int32_t_max);
623  }
624 }
625 
627 {
628  /* Make sure alias is implemented. */
629  {
630  int32_t value = 0;
631  atomic_store_int32(&value, 2);
632  EXPECT_EQ(value, 2);
633  }
634 
635  /* Make sure alias is using proper bitness. */
636  {
637  const int32_t int32_t_max = std::numeric_limits<int32_t>::max();
638  int32_t value = 0;
639  atomic_store_int32(&value, int32_t_max);
640  EXPECT_EQ(value, int32_t_max);
641  }
642 }
643 
645 {
646  {
647  int32_t value = 1;
648  EXPECT_EQ(atomic_fetch_and_add_int32(&value, 2), 1);
649  EXPECT_EQ(value, 3);
650  }
651 
652  {
653  int32_t value = 0x10203040;
654  EXPECT_EQ(atomic_fetch_and_add_int32(&value, 0x04030201), 0x10203040);
655  EXPECT_EQ(value, 0x14233241);
656  }
657 
658  {
659  int32_t value = -0x10203040;
660  EXPECT_EQ(atomic_fetch_and_add_int32(&value, -0x04030201), -0x10203040);
661  EXPECT_EQ(value, -0x14233241);
662  }
663 }
664 
666 {
667  {
668  int32_t value = 12;
669  EXPECT_EQ(atomic_fetch_and_or_int32(&value, 5), 12);
670  EXPECT_EQ(value, 13);
671  }
672 
673  // 0x87654321 is -0x789abcdf
674 
675  {
676  int32_t value = 0x12345678;
677  EXPECT_EQ(atomic_fetch_and_or_int32(&value, -0x789abcdf), 0x12345678);
678  EXPECT_EQ(value, 0x97755779);
679  }
680 }
681 
683 {
684  {
685  int32_t value = 12;
686  EXPECT_EQ(atomic_fetch_and_and_int32(&value, 5), 12);
687  EXPECT_EQ(value, 4);
688  }
689 
690  {
691  int32_t value = 0x12345678;
692  EXPECT_EQ(atomic_fetch_and_and_int32(&value, -0x789abcdf), 0x12345678);
693  EXPECT_EQ(value, 0x02244220);
694  }
695 }
696 
699 /* -------------------------------------------------------------------- */
704 {
705  {
706  int16_t value = 12;
707  EXPECT_EQ(atomic_fetch_and_or_int16(&value, 5), 12);
708  EXPECT_EQ(value, 13);
709  }
710 
711  {
712  int16_t value = 0x1234;
713  EXPECT_EQ(atomic_fetch_and_or_int16(&value, -0x5678), 0x1234);
714  EXPECT_EQ(value, -0x4444);
715  }
716 }
717 
719 {
720  {
721  int16_t value = 12;
722  EXPECT_EQ(atomic_fetch_and_and_int16(&value, 5), 12);
723  EXPECT_EQ(value, 4);
724  }
725 
726  {
727  int16_t value = 0x1234;
728  EXPECT_EQ(atomic_fetch_and_and_int16(&value, -0x789A), 0x1234);
729  EXPECT_EQ(value, 0x224);
730  }
731 }
732 
735 /* -------------------------------------------------------------------- */
740 {
741  {
742  uint8_t value = 12;
743  EXPECT_EQ(atomic_fetch_and_or_uint8(&value, 5), 12);
744  EXPECT_EQ(value, 13);
745  }
746 }
747 
749 {
750  {
751  uint8_t value = 12;
752  EXPECT_EQ(atomic_fetch_and_and_uint8(&value, 5), 12);
753  EXPECT_EQ(value, 4);
754  }
755 }
756 
763 {
764  {
765  int8_t value = 12;
766  EXPECT_EQ(atomic_fetch_and_or_int8(&value, 5), 12);
767  EXPECT_EQ(value, 13);
768  }
769 }
770 
772 {
773  {
774  int8_t value = 12;
775  EXPECT_EQ(atomic_fetch_and_and_int8(&value, 5), 12);
776  EXPECT_EQ(value, 4);
777  }
778 }
779 
782 /* -------------------------------------------------------------------- */
787 {
788  {
789  char value = 12;
790  EXPECT_EQ(atomic_fetch_and_or_char(&value, 5), 12);
791  EXPECT_EQ(value, 13);
792  }
793 }
794 
796 {
797  {
798  char value = 12;
799  EXPECT_EQ(atomic_fetch_and_and_char(&value, 5), 12);
800  EXPECT_EQ(value, 4);
801  }
802 }
803 
806 /* -------------------------------------------------------------------- */
811 {
812  /* Make sure alias is implemented. */
813  {
814  size_t value = 1;
815  EXPECT_EQ(atomic_add_and_fetch_z(&value, 2), 3);
816  EXPECT_EQ(value, 3);
817  }
818 
819  /* Make sure alias is using proper bitness. */
820  {
821  const size_t size_t_max = std::numeric_limits<size_t>::max();
822  size_t value = size_t_max - 10;
823  EXPECT_EQ(atomic_add_and_fetch_z(&value, 2), size_t_max - 8);
824  EXPECT_EQ(value, size_t_max - 8);
825  }
826 }
827 
829 {
830  /* Make sure alias is implemented. */
831  {
832  size_t value = 3;
833  EXPECT_EQ(atomic_sub_and_fetch_z(&value, 2), 1);
834  EXPECT_EQ(value, 1);
835  }
836 
837  /* Make sure alias is using proper bitness. */
838  {
839  const size_t size_t_max = std::numeric_limits<size_t>::max();
840  size_t value = size_t_max - 10;
841  EXPECT_EQ(atomic_sub_and_fetch_z(&value, 2), size_t_max - 12);
842  EXPECT_EQ(value, size_t_max - 12);
843  }
844 }
845 
847 {
848  /* Make sure alias is implemented. */
849  {
850  size_t value = 1;
851  EXPECT_EQ(atomic_fetch_and_add_z(&value, 2), 1);
852  EXPECT_EQ(value, 3);
853  }
854 
855  /* Make sure alias is using proper bitness. */
856  {
857  const size_t size_t_max = std::numeric_limits<size_t>::max();
858  size_t value = size_t_max - 10;
859  EXPECT_EQ(atomic_fetch_and_add_z(&value, 2), size_t_max - 10);
860  EXPECT_EQ(value, size_t_max - 8);
861  }
862 }
863 
865 {
866  /* Make sure alias is implemented. */
867  {
868  size_t value = 3;
869  EXPECT_EQ(atomic_fetch_and_sub_z(&value, 2), 3);
870  EXPECT_EQ(value, 1);
871  }
872 
873  /* Make sure alias is using proper bitness. */
874  {
875  const size_t size_t_max = std::numeric_limits<size_t>::max();
876  size_t value = size_t_max - 10;
877  EXPECT_EQ(atomic_fetch_and_sub_z(&value, 2), size_t_max - 10);
878  EXPECT_EQ(value, size_t_max - 12);
879  }
880 }
881 
883 {
884  /* Make sure alias is implemented. */
885  {
886  size_t value = 1;
887  EXPECT_EQ(atomic_cas_z(&value, 1, 2), 1);
888  EXPECT_EQ(value, 2);
889  }
890 
891  /* Make sure alias is using proper bitness. */
892  {
893  const size_t size_t_max = std::numeric_limits<size_t>::max();
894  size_t value = 1;
895  EXPECT_EQ(atomic_cas_z(&value, 1, size_t_max), 1);
896  EXPECT_EQ(value, size_t_max);
897  }
898 }
899 
901 {
902  /* Make sure alias is implemented. */
903  {
904  size_t value = 2;
905  EXPECT_EQ(atomic_load_z(&value), 2);
906  }
907 
908  /* Make sure alias is using proper bitness. */
909  {
910  const size_t size_t_max = std::numeric_limits<size_t>::max();
911  size_t value = size_t_max;
912  EXPECT_EQ(atomic_load_z(&value), size_t_max);
913  }
914 }
915 
917 {
918  /* Make sure alias is implemented. */
919  {
920  size_t value = 0;
921  atomic_store_z(&value, 2);
922  EXPECT_EQ(value, 2);
923  }
924 
925  /* Make sure alias is using proper bitness. */
926  {
927  const size_t size_t_max = std::numeric_limits<size_t>::max();
928  size_t value = 0;
929  atomic_store_z(&value, size_t_max);
930  EXPECT_EQ(value, size_t_max);
931  }
932 }
933 
935 {
936  const size_t size_t_max = std::numeric_limits<size_t>::max();
937 
938  size_t value = 12;
939 
941  EXPECT_EQ(value, 12);
942 
943  EXPECT_EQ(atomic_fetch_and_update_max_z(&value, 24), 12);
944  EXPECT_EQ(value, 24);
945 
946  EXPECT_EQ(atomic_fetch_and_update_max_z(&value, size_t_max), 24);
947  EXPECT_EQ(value, size_t_max);
948 }
949 
952 /* -------------------------------------------------------------------- */
957 {
958  /* Make sure alias is implemented. */
959  {
960  unsigned int value = 1;
961  EXPECT_EQ(atomic_add_and_fetch_u(&value, 2), 3);
962  EXPECT_EQ(value, 3);
963  }
964 
965  /* Make sure alias is using proper bitness. */
966  {
967  const unsigned int uint_max = std::numeric_limits<unsigned int>::max();
968  unsigned int value = uint_max - 10;
969  EXPECT_EQ(atomic_add_and_fetch_u(&value, 2), uint_max - 8);
970  EXPECT_EQ(value, uint_max - 8);
971  }
972 }
973 
975 {
976  /* Make sure alias is implemented. */
977  {
978  unsigned int value = 3;
979  EXPECT_EQ(atomic_sub_and_fetch_u(&value, 2), 1);
980  EXPECT_EQ(value, 1);
981  }
982 
983  /* Make sure alias is using proper bitness. */
984  {
985  const unsigned int uint_max = std::numeric_limits<unsigned int>::max();
986  unsigned int value = uint_max - 10;
987  EXPECT_EQ(atomic_sub_and_fetch_u(&value, 2), uint_max - 12);
988  EXPECT_EQ(value, uint_max - 12);
989  }
990 }
991 
993 {
994  /* Make sure alias is implemented. */
995  {
996  unsigned int value = 1;
997  EXPECT_EQ(atomic_fetch_and_add_u(&value, 2), 1);
998  EXPECT_EQ(value, 3);
999  }
1000 
1001  /* Make sure alias is using proper bitness. */
1002  {
1003  const unsigned int uint_max = std::numeric_limits<unsigned int>::max();
1004  unsigned int value = uint_max - 10;
1005  EXPECT_EQ(atomic_fetch_and_add_u(&value, 2), uint_max - 10);
1006  EXPECT_EQ(value, uint_max - 8);
1007  }
1008 }
1009 
1011 {
1012  /* Make sure alias is implemented. */
1013  {
1014  unsigned int value = 3;
1015  EXPECT_EQ(atomic_fetch_and_sub_u(&value, 2), 3);
1016  EXPECT_EQ(value, 1);
1017  }
1018 
1019  /* Make sure alias is using proper bitness. */
1020  {
1021  const unsigned int uint_max = std::numeric_limits<unsigned int>::max();
1022  unsigned int value = uint_max - 10;
1023  EXPECT_EQ(atomic_fetch_and_sub_u(&value, 2), uint_max - 10);
1024  EXPECT_EQ(value, uint_max - 12);
1025  }
1026 }
1027 
1029 {
1030  /* Make sure alias is implemented. */
1031  {
1032  unsigned int value = 1;
1033  EXPECT_EQ(atomic_cas_u(&value, 1, 2), 1);
1034  EXPECT_EQ(value, 2);
1035  }
1036 
1037  /* Make sure alias is using proper bitness. */
1038  {
1039  const unsigned int uint_max = std::numeric_limits<unsigned int>::max();
1040  unsigned int value = 1;
1041  EXPECT_EQ(atomic_cas_u(&value, 1, uint_max), 1);
1042  EXPECT_EQ(value, uint_max);
1043  }
1044 }
1045 
1048 /* -------------------------------------------------------------------- */
1052 #define INT_AS_PTR(a) reinterpret_cast<void *>((a))
1053 
1055 {
1056  {
1057  void *value = INT_AS_PTR(0x7f);
1058  EXPECT_EQ(atomic_cas_ptr(&value, INT_AS_PTR(0x7f), INT_AS_PTR(0xef)), INT_AS_PTR(0x7f));
1059  EXPECT_EQ(value, INT_AS_PTR(0xef));
1060  }
1061 }
1062 
1064 {
1065  {
1066  void *value = INT_AS_PTR(0x7f);
1067  void *dest = atomic_load_ptr(&value);
1068  EXPECT_EQ(dest, INT_AS_PTR(0x7f));
1069  }
1070 }
1071 
1073 {
1074  {
1075  void *value = INT_AS_PTR(0x7f);
1076  void *dest = nullptr;
1077  atomic_store_ptr(&dest, value);
1078  EXPECT_EQ(dest, INT_AS_PTR(0x7f));
1079  }
1080 }
1081 
1082 #undef INT_AS_PTR
1083 
1086 /* -------------------------------------------------------------------- */
1091 {
1092  {
1093  float value = 1.234f;
1094  EXPECT_EQ(atomic_cas_float(&value, 1.234f, 2.71f), 1.234f);
1095  EXPECT_EQ(value, 2.71f);
1096  }
1097 }
1098 
1100 {
1101  {
1102  float value = 1.23f;
1103  EXPECT_NEAR(atomic_add_and_fetch_fl(&value, 2.71f), 3.94f, 1e-8f);
1104  EXPECT_NEAR(value, 3.94f, 1e-8f);
1105  }
1106 }
1107 
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
Provides wrapper around system-specific atomic primitives, and some extensions (faked-atomic operatio...
ATOMIC_INLINE unsigned int atomic_fetch_and_sub_u(unsigned int *p, unsigned int x)
ATOMIC_INLINE uint32_t atomic_fetch_and_or_uint32(uint32_t *p, uint32_t x)
ATOMIC_INLINE int32_t atomic_add_and_fetch_int32(int32_t *p, int32_t x)
ATOMIC_INLINE int16_t atomic_fetch_and_or_int16(int16_t *p, int16_t b)
ATOMIC_INLINE void atomic_store_uint64(uint64_t *p, uint64_t v)
ATOMIC_INLINE size_t atomic_load_z(const size_t *v)
ATOMIC_INLINE size_t atomic_add_and_fetch_z(size_t *p, size_t x)
ATOMIC_INLINE uint64_t atomic_fetch_and_sub_uint64(uint64_t *p, uint64_t x)
ATOMIC_INLINE int64_t atomic_sub_and_fetch_int64(int64_t *p, int64_t x)
ATOMIC_INLINE uint8_t atomic_fetch_and_and_uint8(uint8_t *p, uint8_t b)
ATOMIC_INLINE uint64_t atomic_load_uint64(const uint64_t *v)
ATOMIC_INLINE size_t atomic_sub_and_fetch_z(size_t *p, size_t x)
ATOMIC_INLINE int64_t atomic_cas_int64(int64_t *v, int64_t old, int64_t _new)
ATOMIC_INLINE size_t atomic_fetch_and_sub_z(size_t *p, size_t x)
ATOMIC_INLINE uint32_t atomic_fetch_and_add_uint32(uint32_t *p, uint32_t x)
ATOMIC_INLINE uint8_t atomic_fetch_and_or_uint8(uint8_t *p, uint8_t b)
ATOMIC_INLINE int32_t atomic_load_int32(const int32_t *v)
ATOMIC_INLINE float atomic_add_and_fetch_fl(float *p, const float x)
ATOMIC_INLINE int64_t atomic_load_int64(const int64_t *v)
ATOMIC_INLINE int32_t atomic_fetch_and_or_int32(int32_t *p, int32_t x)
ATOMIC_INLINE char atomic_fetch_and_or_char(char *p, char b)
ATOMIC_INLINE uint32_t atomic_fetch_and_and_uint32(uint32_t *p, uint32_t x)
ATOMIC_INLINE void atomic_store_int64(int64_t *p, int64_t v)
ATOMIC_INLINE int64_t atomic_fetch_and_add_int64(int64_t *p, int64_t x)
ATOMIC_INLINE unsigned int atomic_add_and_fetch_u(unsigned int *p, unsigned int x)
ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x)
ATOMIC_INLINE void * atomic_load_ptr(void *const *v)
ATOMIC_INLINE void atomic_store_int32(int32_t *p, int32_t v)
ATOMIC_INLINE int32_t atomic_fetch_and_add_int32(int32_t *p, int32_t x)
ATOMIC_INLINE uint64_t atomic_cas_uint64(uint64_t *v, uint64_t old, uint64_t _new)
ATOMIC_INLINE uint64_t atomic_fetch_and_add_uint64(uint64_t *p, uint64_t x)
ATOMIC_INLINE void * atomic_cas_ptr(void **v, void *old, void *_new)
ATOMIC_INLINE uint32_t atomic_sub_and_fetch_uint32(uint32_t *p, uint32_t x)
ATOMIC_INLINE char atomic_fetch_and_and_char(char *p, char b)
ATOMIC_INLINE int16_t atomic_fetch_and_and_int16(int16_t *p, int16_t b)
ATOMIC_INLINE unsigned int atomic_cas_u(unsigned int *v, unsigned int old, unsigned int _new)
ATOMIC_INLINE size_t atomic_cas_z(size_t *v, size_t old, size_t _new)
ATOMIC_INLINE void atomic_store_z(size_t *p, size_t v)
ATOMIC_INLINE float atomic_cas_float(float *v, float old, float _new)
ATOMIC_INLINE int64_t atomic_add_and_fetch_int64(int64_t *p, int64_t x)
ATOMIC_INLINE uint64_t atomic_add_and_fetch_uint64(uint64_t *p, uint64_t x)
ATOMIC_INLINE size_t atomic_fetch_and_add_z(size_t *p, size_t x)
ATOMIC_INLINE uint32_t atomic_load_uint32(const uint32_t *v)
ATOMIC_INLINE uint64_t atomic_sub_and_fetch_uint64(uint64_t *p, uint64_t x)
ATOMIC_INLINE void atomic_store_uint32(uint32_t *p, uint32_t v)
ATOMIC_INLINE int32_t atomic_cas_int32(int32_t *v, int32_t old, int32_t _new)
ATOMIC_INLINE int32_t atomic_fetch_and_and_int32(int32_t *p, int32_t x)
ATOMIC_INLINE size_t atomic_fetch_and_update_max_z(size_t *p, size_t x)
ATOMIC_INLINE int8_t atomic_fetch_and_or_int8(int8_t *p, int8_t b)
ATOMIC_INLINE void atomic_store_ptr(void **p, void *v)
ATOMIC_INLINE int32_t atomic_sub_and_fetch_int32(int32_t *p, int32_t x)
ATOMIC_INLINE unsigned int atomic_sub_and_fetch_u(unsigned int *p, unsigned int x)
ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b)
ATOMIC_INLINE unsigned int atomic_fetch_and_add_u(unsigned int *p, unsigned int x)
ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x)
ATOMIC_INLINE uint32_t atomic_cas_uint32(uint32_t *v, uint32_t old, uint32_t _new)
#define INT_AS_PTR(a)
TEST(atomic, atomic_add_and_fetch_uint64)
Definition: atomic_test.cc:21
SyclQueue void * dest
signed short int16_t
Definition: stdint.h:76
unsigned int uint32_t
Definition: stdint.h:80
__int64 int64_t
Definition: stdint.h:89
signed int int32_t
Definition: stdint.h:77
unsigned char uint8_t
Definition: stdint.h:78
unsigned __int64 uint64_t
Definition: stdint.h:90
signed char int8_t
Definition: stdint.h:75
float max