feat(Core): replace ACE network with Boost.Asio (#6574)

src/common/Threading/MPSCQueue.h

@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3
+ * Copyright (C) 2021+ WarheadCore <https://github.com/WarheadCore>
+ */
+
+#ifndef MPSCQueue_h__
+#define MPSCQueue_h__
+
+#include <atomic>
+#include <utility>
+
+namespace Acore::Impl
+{
+    // C++ implementation of Dmitry Vyukov's lock free MPSC queue
+    // http://www.1024cores.net/home/lock-free-algorithms/queues/non-intrusive-mpsc-node-based-queue
+    template<typename T>
+    class MPSCQueueNonIntrusive
+    {
+    public:
+        MPSCQueueNonIntrusive() : _head(new Node()), _tail(_head.load(std::memory_order_relaxed))
+        {
+            Node* front = _head.load(std::memory_order_relaxed);
+            front->Next.store(nullptr, std::memory_order_relaxed);
+        }
+
+        ~MPSCQueueNonIntrusive()
+        {
+            T* output;
+            while (Dequeue(output))
+                delete output;
+
+            Node* front = _head.load(std::memory_order_relaxed);
+            delete front;
+        }
+
+        void Enqueue(T* input)
+        {
+            Node* node = new Node(input);
+            Node* prevHead = _head.exchange(node, std::memory_order_acq_rel);
+            prevHead->Next.store(node, std::memory_order_release);
+        }
+
+        bool Dequeue(T*& result)
+        {
+            Node* tail = _tail.load(std::memory_order_relaxed);
+            Node* next = tail->Next.load(std::memory_order_acquire);
+            if (!next)
+                return false;
+
+            result = next->Data;
+            _tail.store(next, std::memory_order_release);
+            delete tail;
+            return true;
+        }
+
+    private:
+        struct Node
+        {
+            Node() = default;
+            explicit Node(T* data) : Data(data)
+            {
+                Next.store(nullptr, std::memory_order_relaxed);
+            }
+
+            T* Data;
+            std::atomic<Node*> Next;
+        };
+
+        std::atomic<Node*> _head;
+        std::atomic<Node*> _tail;
+
+        MPSCQueueNonIntrusive(MPSCQueueNonIntrusive const&) = delete;
+        MPSCQueueNonIntrusive& operator=(MPSCQueueNonIntrusive const&) = delete;
+    };
+
+    // C++ implementation of Dmitry Vyukov's lock free MPSC queue
+    // http://www.1024cores.net/home/lock-free-algorithms/queues/intrusive-mpsc-node-based-queue
+    template<typename T, std::atomic<T*> T::* IntrusiveLink>
+    class MPSCQueueIntrusive
+    {
+    public:
+        MPSCQueueIntrusive() : _dummyPtr(reinterpret_cast<T*>(std::addressof(_dummy))), _head(_dummyPtr), _tail(_dummyPtr)
+        {
+            // _dummy is constructed from aligned_storage and is intentionally left uninitialized (it might not be default constructible)
+            // so we init only its IntrusiveLink here
+            std::atomic<T*>* dummyNext = new (&(_dummyPtr->*IntrusiveLink)) std::atomic<T*>();
+            dummyNext->store(nullptr, std::memory_order_relaxed);
+        }
+
+        ~MPSCQueueIntrusive()
+        {
+            T* output;
+            while (Dequeue(output))
+                delete output;
+        }
+
+        void Enqueue(T* input)
+        {
+            (input->*IntrusiveLink).store(nullptr, std::memory_order_release);
+            T* prevHead = _head.exchange(input, std::memory_order_acq_rel);
+            (prevHead->*IntrusiveLink).store(input, std::memory_order_release);
+        }
+
+        bool Dequeue(T*& result)
+        {
+            T* tail = _tail.load(std::memory_order_relaxed);
+            T* next = (tail->*IntrusiveLink).load(std::memory_order_acquire);
+            if (tail == _dummyPtr)
+            {
+                if (!next)
+                    return false;
+
+                _tail.store(next, std::memory_order_release);
+                tail = next;
+                next = (next->*IntrusiveLink).load(std::memory_order_acquire);
+            }
+
+            if (next)
+            {
+                _tail.store(next, std::memory_order_release);
+                result = tail;
+                return true;
+            }
+
+            T* head = _head.load(std::memory_order_acquire);
+            if (tail != head)
+                return false;
+
+            Enqueue(_dummyPtr);
+            next = (tail->*IntrusiveLink).load(std::memory_order_acquire);
+            if (next)
+            {
+                _tail.store(next, std::memory_order_release);
+                result = tail;
+                return true;
+            }
+            return false;
+        }
+
+    private:
+        std::aligned_storage_t<sizeof(T), alignof(T)> _dummy;
+        T* _dummyPtr;
+        std::atomic<T*> _head;
+        std::atomic<T*> _tail;
+
+        MPSCQueueIntrusive(MPSCQueueIntrusive const&) = delete;
+        MPSCQueueIntrusive& operator=(MPSCQueueIntrusive const&) = delete;
+    };
+}
+
+template<typename T, std::atomic<T*> T::* IntrusiveLink = nullptr>
+using MPSCQueue = std::conditional_t<IntrusiveLink != nullptr, Acore::Impl::MPSCQueueIntrusive<T, IntrusiveLink>, Acore::Impl::MPSCQueueNonIntrusive<T>>;
+
+#endif // MPSCQueue_h__

src/common/Threading/PCQueue.h

@@ -100,7 +100,7 @@ private:
     typename std::enable_if<std::is_pointer<E>::value>::type DeleteQueuedObject(E& obj) { delete obj; }
 
     template<typename E = T>
-    typename std::enable_if < !std::is_pointer<E>::value >::type DeleteQueuedObject(E const& /*packet*/) { }
+    typename std::enable_if<!std::is_pointer<E>::value>::type DeleteQueuedObject(E const& /*packet*/) { }
 };
 
 #endif

src/common/Threading/ProducerConsumerQueue.h

@@ -1,100 +0,0 @@
-/*
- * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3
- * Copyright (C) 2021+ WarheadCore <https://github.com/WarheadCore>
- */
-
-#ifndef _PCQ_H
-#define _PCQ_H
-
-#include <condition_variable>
-#include <mutex>
-#include <queue>
-#include <atomic>
-#include <type_traits>
-
-template <typename T>
-class ProducerConsumerQueue
-{
-private:
-    std::mutex _queueLock;
-    std::queue<T> _queue;
-    std::condition_variable _condition;
-    std::atomic<bool> _shutdown;
-
-public:
-
-    ProducerConsumerQueue<T>() : _shutdown(false) { }
-
-    void Push(const T& value)
-    {
-        std::lock_guard<std::mutex> lock(_queueLock);
-        _queue.push(std::move(value));
-
-        _condition.notify_one();
-    }
-
-    bool Empty()
-    {
-        std::lock_guard<std::mutex> lock(_queueLock);
-
-        return _queue.empty();
-    }
-
-    bool Pop(T& value)
-    {
-        std::lock_guard<std::mutex> lock(_queueLock);
-
-        if (_queue.empty() || _shutdown)
-            return false;
-
-        value = _queue.front();
-
-        _queue.pop();
-
-        return true;
-    }
-
-    void WaitAndPop(T& value)
-    {
-        std::unique_lock<std::mutex> lock(_queueLock);
-
-        // we could be using .wait(lock, predicate) overload here but it is broken
-        // https://connect.microsoft.com/VisualStudio/feedback/details/1098841
-        while (_queue.empty() && !_shutdown)
-            _condition.wait(lock);
-
-        if (_queue.empty() || _shutdown)
-            return;
-
-        value = _queue.front();
-
-        _queue.pop();
-    }
-
-    void Cancel()
-    {
-        std::unique_lock<std::mutex> lock(_queueLock);
-
-        while (!_queue.empty())
-        {
-            T& value = _queue.front();
-
-            DeleteQueuedObject(value);
-
-            _queue.pop();
-        }
-
-        _shutdown = true;
-
-        _condition.notify_all();
-    }
-
-private:
-    template<typename E = T>
-    typename std::enable_if<std::is_pointer<E>::value>::type DeleteQueuedObject(E& obj) { delete obj; }
-
-    template<typename E = T>
-    typename std::enable_if<!std::is_pointer<E>::value>::type DeleteQueuedObject(E const& /*packet*/) { }
-};
-
-#endif