IGNIETFERRO-1105 Get rid of TAtomic in unittests

ref:f4d9cf527b4f26efcc95307ca7b07d1c42ebd11b

4 files changed, 58 insertions, 78 deletions

diff --git a/util/system/condvar_ut.cpp b/util/system/condvar_ut.cpp
index 5130a18d32..c6cce1c0a7 100644
--- a/util/system/condvar_ut.cpp
+++ b/util/system/condvar_ut.cpp
@@ -4,10 +4,10 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
-#include <util/system/atomic.h>
-#include <util/system/atomic_ops.h>
 #include <util/thread/pool.h>
 
+#include <atomic>
+
 class TCondVarTest: public TTestBase {
     UNIT_TEST_SUITE(TCondVarTest);
     UNIT_TEST(TestBasics)
@@ -15,27 +15,18 @@ class TCondVarTest: public TTestBase {
     UNIT_TEST_SUITE_END();
 
     struct TSharedData {
-        TSharedData()
-            : stopWaiting(false)
-            , in(0)
-            , out(0)
-            , waited(0)
-            , failed(false)
-        {
-        }
-
         TMutex mutex;
         TCondVar condVar1;
         TCondVar condVar2;
 
-        TAtomic stopWaiting;
+        std::atomic<bool> stopWaiting = false;
 
-        TAtomic in;
-        TAtomic out;
+        std::atomic<size_t> in = 0;
+        std::atomic<size_t> out = 0;
 
-        TAtomic waited;
+        std::atomic<size_t> waited = 0;
 
-        bool failed;
+        bool failed = false;
     };
 
     class TThreadTask: public IObjectInQueue {
@@ -65,13 +56,13 @@ class TCondVarTest: public TTestBase {
 
             if (Id_ < 2) {
                 TGuard<TMutex> guard(Data_.mutex);
-                while (!AtomicGet(Data_.stopWaiting)) {
+                while (!Data_.stopWaiting.load()) {
                     bool res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1));
                     FAIL_ASSERT(res == true);
                 }
             } else {
                 usleep(100000);
-                AtomicSet(Data_.stopWaiting, true);
+                Data_.stopWaiting.store(true);
 
                 TGuard<TMutex> guard(Data_.mutex);
                 Data_.condVar1.Signal();
@@ -85,12 +76,12 @@ class TCondVarTest: public TTestBase {
             if (Id_ < 2) {
                 TGuard<TMutex> guard(Data_.mutex);
                 const auto res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1), [&] {
-                    return AtomicGet(Data_.stopWaiting);
+                    return Data_.stopWaiting.load();
                 });
                 FAIL_ASSERT(res == true);
             } else {
                 usleep(100000);
-                AtomicSet(Data_.stopWaiting, true);
+                Data_.stopWaiting.store(true);
 
                 TGuard<TMutex> guard(Data_.mutex);
                 Data_.condVar1.Signal();
@@ -101,55 +92,55 @@ class TCondVarTest: public TTestBase {
         void RunSyncronize() {
             for (size_t i = 0; i < 10; ++i) {
                 TGuard<TMutex> guard(Data_.mutex);
-                AtomicIncrement(Data_.in);
-                if (AtomicGet(Data_.in) == TotalIds_) {
-                    AtomicSet(Data_.out, 0);
+                ++Data_.in;
+                if (Data_.in.load() == TotalIds_) {
+                    Data_.out.store(0);
                     Data_.condVar1.BroadCast();
                 } else {
-                    AtomicIncrement(Data_.waited);
-                    while (AtomicGet(Data_.in) < TotalIds_) {
+                    ++Data_.waited;
+                    while (Data_.in.load() < TotalIds_) {
                         bool res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1));
                         FAIL_ASSERT(res == true);
                     }
                 }
 
-                AtomicIncrement(Data_.out);
-                if (AtomicGet(Data_.out) == TotalIds_) {
-                    AtomicSet(Data_.in, 0);
+                ++Data_.out;
+                if (Data_.out.load() == TotalIds_) {
+                    Data_.in.store(0);
                     Data_.condVar2.BroadCast();
                 } else {
-                    while (AtomicGet(Data_.out) < TotalIds_) {
+                    while (Data_.out.load() < TotalIds_) {
                         bool res = Data_.condVar2.WaitT(Data_.mutex, TDuration::Seconds(1));
                         FAIL_ASSERT(res == true);
                     }
                 }
             }
 
-            FAIL_ASSERT(AtomicGet(Data_.waited) == (TotalIds_ - 1) * 10);
+            FAIL_ASSERT(Data_.waited.load() == (TotalIds_ - 1) * 10);
         }
 
         void RunSyncronizeWithPredicate() {
             for (size_t i = 0; i < 10; ++i) {
                 TGuard<TMutex> guard(Data_.mutex);
-                AtomicIncrement(Data_.in);
-                if (AtomicGet(Data_.in) == TotalIds_) {
-                    AtomicSet(Data_.out, 0);
+                ++Data_.in;
+                if (Data_.in.load() == TotalIds_) {
+                    Data_.out.store(0);
                     Data_.condVar1.BroadCast();
                 } else {
-                    AtomicIncrement(Data_.waited);
+                    ++Data_.waited;
                     const auto res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1), [&] {
-                        return AtomicGet(Data_.in) >= TotalIds_;
+                        return Data_.in.load() >= TotalIds_;
                     });
                     FAIL_ASSERT(res == true);
                 }
 
-                AtomicIncrement(Data_.out);
-                if (AtomicGet(Data_.out) == TotalIds_) {
-                    AtomicSet(Data_.in, 0);
+                ++Data_.out;
+                if (Data_.out.load() == TotalIds_) {
+                    Data_.in.store(0);
                     Data_.condVar2.BroadCast();
                 } else {
                     const auto res = Data_.condVar2.WaitT(Data_.mutex, TDuration::Seconds(1), [&] {
-                        return AtomicGet(Data_.out) >= TotalIds_;
+                        return Data_.out.load() >= TotalIds_;
                     });
                     FAIL_ASSERT(res == true);
                 }
@@ -162,7 +153,7 @@ class TCondVarTest: public TTestBase {
     private:
         PFunc Func_;
         size_t Id_;
-        TAtomicBase TotalIds_;
+        size_t TotalIds_;
         TSharedData& Data_;
     };
 
diff --git a/util/system/event_ut.cpp b/util/system/event_ut.cpp
index 2506cb7a91..448f1e1350 100644
--- a/util/system/event_ut.cpp
+++ b/util/system/event_ut.cpp
@@ -1,21 +1,16 @@
 #include "event.h"
-#include "atomic.h"
 
 #include <library/cpp/testing/unittest/registar.h>
 
 #include <util/thread/pool.h>
 
+#include <atomic>
+
 namespace {
     struct TSharedData {
-        TSharedData()
-            : Counter(0)
-            , failed(false)
-        {
-        }
-
-        TAtomic Counter;
+        std::atomic<size_t> Counter = 0;
         TManualEvent event;
-        bool failed;
+        bool failed = false;
     };
 
     struct TThreadTask: public IObjectInQueue {
@@ -31,7 +26,7 @@ namespace {
 
             if (Id_ == 0) {
                 usleep(100);
-                bool cond = Data_.Counter == 0;
+                bool cond = Data_.Counter.load() == 0;
                 if (!cond) {
                     Data_.failed = true;
                 }
@@ -39,7 +34,7 @@ namespace {
             } else {
                 while (!Data_.event.WaitT(TDuration::Seconds(100))) {
                 }
-                AtomicAdd(Data_.Counter, Id_);
+                Data_.Counter += Id_;
             }
         }
 
@@ -91,7 +86,7 @@ Y_UNIT_TEST_SUITE(EventTest) {
             UNIT_ASSERT(queue.Add(new TThreadTask(data, i)));
         }
         queue.Stop();
-        UNIT_ASSERT(data.Counter == 10);
+        UNIT_ASSERT(data.Counter.load() == 10);
         UNIT_ASSERT(!data.failed);
     }
 
diff --git a/util/system/interrupt_signals_ut.cpp b/util/system/interrupt_signals_ut.cpp
index bec54fec61..2a7f0bddd7 100644
--- a/util/system/interrupt_signals_ut.cpp
+++ b/util/system/interrupt_signals_ut.cpp
@@ -1,20 +1,20 @@
 #include "interrupt_signals.h"
 
-#include "atomic.h"
-
 #include <util/datetime/base.h>
 
 #include <library/cpp/testing/unittest/registar.h>
 
+#include <atomic>
+
 #ifdef _win_
     #include <windows.h>
 #endif
 
 Y_UNIT_TEST_SUITE(TTestInterruptSignals) {
-    static TAtomic HandledSigNum = 0;
+    static std::atomic<size_t> HandledSigNum = 0;
 
     static void Handler(int signum) {
-        AtomicSet(HandledSigNum, signum);
+        HandledSigNum.store(signum);
     }
 
     Y_UNIT_TEST(Test1) {
@@ -31,7 +31,7 @@ Y_UNIT_TEST_SUITE(TTestInterruptSignals) {
                 UNIT_FAIL("GenerateConsoleCtrlEvent failed: " << LastSystemErrorText());
             }
             Sleep(TDuration::MilliSeconds(100));
-            UNIT_ASSERT_VALUES_EQUAL(HandledSigNum, posixSigNum);
+            UNIT_ASSERT_VALUES_EQUAL(HandledSigNum.load(), posixSigNum);
         }
         */
         for (int signum : {SIGINT, SIGTERM}) {
@@ -40,7 +40,7 @@ Y_UNIT_TEST_SUITE(TTestInterruptSignals) {
 #endif
             std::raise(signum);
             Sleep(TDuration::MilliSeconds(100)); // give it time to handle an async signal
-            UNIT_ASSERT_VALUES_EQUAL(HandledSigNum, signum);
+            UNIT_ASSERT_VALUES_EQUAL(HandledSigNum.load(), signum);
         }
     }
 }
diff --git a/util/system/rwlock_ut.cpp b/util/system/rwlock_ut.cpp
index 2b384c05b3..5dd225af67 100644
--- a/util/system/rwlock_ut.cpp
+++ b/util/system/rwlock_ut.cpp
@@ -1,11 +1,12 @@
 #include "rwlock.h"
-#include "atomic.h"
 
 #include <library/cpp/testing/unittest/registar.h>
 
 #include <util/thread/pool.h>
 #include <util/random/random.h>
 
+#include <atomic>
+
 class TRWMutexTest: public TTestBase {
     UNIT_TEST_SUITE(TRWMutexTest);
     UNIT_TEST(TestReaders)
@@ -13,17 +14,10 @@ class TRWMutexTest: public TTestBase {
     UNIT_TEST_SUITE_END();
 
     struct TSharedData {
-        TSharedData()
-            : writersIn(0)
-            , readersIn(0)
-            , failed(false)
-        {
-        }
-
-        TAtomic writersIn;
-        TAtomic readersIn;
+        std::atomic<size_t> writersIn = 0;
+        std::atomic<size_t> readersIn = 0;
 
-        bool failed;
+        bool failed = false;
 
         TRWMutex mutex;
     };
@@ -53,11 +47,11 @@ class TRWMutexTest: public TTestBase {
         void RunReaders() {
             Data_.mutex.AcquireRead();
 
-            AtomicIncrement(Data_.readersIn);
+            ++Data_.readersIn;
             usleep(100);
-            FAIL_ASSERT(Data_.readersIn == long(Total_));
+            FAIL_ASSERT(Data_.readersIn.load() == Total_);
             usleep(100);
-            AtomicDecrement(Data_.readersIn);
+            --Data_.readersIn;
 
             Data_.mutex.ReleaseRead();
         }
@@ -67,10 +61,10 @@ class TRWMutexTest: public TTestBase {
                 for (size_t i = 0; i < 10; ++i) {
                     Data_.mutex.AcquireRead();
 
-                    AtomicIncrement(Data_.readersIn);
-                    FAIL_ASSERT(Data_.writersIn == 0);
+                    ++Data_.readersIn;
+                    FAIL_ASSERT(Data_.writersIn.load() == 0);
                     usleep(RandomNumber<ui32>() % 5);
-                    AtomicDecrement(Data_.readersIn);
+                    --Data_.readersIn;
 
                     Data_.mutex.ReleaseRead();
                 }
@@ -78,10 +72,10 @@ class TRWMutexTest: public TTestBase {
                 for (size_t i = 0; i < 10; ++i) {
                     Data_.mutex.AcquireWrite();
 
-                    AtomicIncrement(Data_.writersIn);
-                    FAIL_ASSERT(Data_.readersIn == 0 && Data_.writersIn == 1);
+                    ++Data_.writersIn;
+                    FAIL_ASSERT(Data_.readersIn.load() == 0 && Data_.writersIn.load() == 1);
                     usleep(RandomNumber<ui32>() % 5);
-                    AtomicDecrement(Data_.writersIn);
+                    --Data_.writersIn;
 
                     Data_.mutex.ReleaseWrite();
                 }