Optimized LockFreeQueue by Reducing Object Construction

Author: an-tao

trantor/net/InetAddress.cc

@@ -14,8 +14,7 @@
 #ifdef _WIN32
 struct in6_addr_uint
 {
-    union
-    {
+    union {
         u_char Byte[16];
         u_short Word[8];
         uint32_t __s6_addr32[4];

trantor/net/InetAddress.h

@@ -100,8 +100,7 @@ class InetAddress
     }
 
   private:
-    union
-    {
+    union {
         struct sockaddr_in addr_;
         struct sockaddr_in6 addr6_;
     };

trantor/net/inner/AresResolver.cc

@@ -234,9 +234,7 @@ void AresResolver::ares_hostcallback_(void* data,
 }
 
 #ifdef _WIN32
-int AresResolver::ares_sock_createcallback_(SOCKET sockfd,
-                                            int type,
-                                            void* data)
+int AresResolver::ares_sock_createcallback_(SOCKET sockfd, int type, void* data)
 #else
 int AresResolver::ares_sock_createcallback_(int sockfd, int type, void* data)
 #endif

trantor/net/inner/AresResolver.h

@@ -126,9 +126,7 @@ class AresResolver : public Resolver,
                                    int timeouts,
                                    struct hostent* hostent);
 #ifdef _WIN32
-    static int ares_sock_createcallback_(SOCKET sockfd,
-                                         int type,
-                                         void* data);
+    static int ares_sock_createcallback_(SOCKET sockfd, int type, void* data);
 #else
     static int ares_sock_createcallback_(int sockfd, int type, void* data);
 #endif

trantor/utils/LockFreeQueue.h

@@ -16,6 +16,7 @@
 #include <trantor/utils/NonCopyable.h>
 #include <atomic>
 #include <type_traits>
+#include <memory>
 #include <assert.h>
 namespace trantor
 {
@@ -27,8 +28,6 @@ class MpscQueue : public NonCopyable
     MpscQueue()
         : head_(new BufferNode), tail_(head_.load(std::memory_order_relaxed))
     {
-        BufferNode *front = head_.load(std::memory_order_relaxed);
-        front->next.store(NULL, std::memory_order_relaxed);
     }
 
     ~MpscQueue()
@@ -43,40 +42,29 @@ class MpscQueue : public NonCopyable
 
     void enqueue(T &&input)
     {
-        BufferNode *node{new BufferNode};
-        node->data = std::move(input);
-        node->next.store(NULL, std::memory_order_relaxed);
-
+        BufferNode *node{new BufferNode(std::move(input))};
         BufferNode *prevhead{head_.exchange(node, std::memory_order_acq_rel)};
-        prevhead->next.store(node, std::memory_order_release);
+        prevhead->next_.store(node, std::memory_order_release);
     }
 
     void enqueue(const T &input)
     {
-        BufferNode *node{new BufferNode};
-        node->data = input;
-        node->next.store(NULL, std::memory_order_relaxed);
-
+        BufferNode *node{new BufferNode(input)};
         BufferNode *prevhead{head_.exchange(node, std::memory_order_acq_rel)};
-        prevhead->next.store(node, std::memory_order_release);
+        prevhead->next_.store(node, std::memory_order_release);
     }
 
     bool dequeue(T &output)
     {
         BufferNode *tail = tail_.load(std::memory_order_relaxed);
-        BufferNode *next = tail->next.load(std::memory_order_acquire);
+        BufferNode *next = tail->next_.load(std::memory_order_acquire);
 
-        if (next == NULL)
+        if (next == nullptr)
         {
             return false;
         }
-#ifdef __linux__
-        output = std::move(next->data);
-#else
-        output = next->data;
-        /// Immediately destroy some RAII objects in the next->data
-        next->data = T();
-#endif
+        output = std::move(*(next->dataPtr_));
+        delete next->dataPtr_;
         tail_.store(next, std::memory_order_release);
         delete tail;
         return true;
@@ -85,8 +73,15 @@ class MpscQueue : public NonCopyable
   private:
     struct BufferNode
     {
-        T data;
-        std::atomic<BufferNode *> next;
+        BufferNode() = default;
+        BufferNode(const T &data) : dataPtr_(new T(data))
+        {
+        }
+        BufferNode(T &&data) : dataPtr_(new T(std::move(data)))
+        {
+        }
+        T *dataPtr_;
+        std::atomic<BufferNode *> next_{nullptr};
     };
 
     std::atomic<BufferNode *> head_;