feat: Memory management refactoring and MSVC compilation fixes

.github/workflows/c-cpp.yml

@@ -2,7 +2,7 @@ name: C/C++ CI
 
 on:
   push:
-    branches: [ master, develop, issue-* ]
+    branches: [ master, develop, issue-*, feature/* ]
   pull_request:
     branches: [ master, develop ]
 

include/libipc/buffer.h

@@ -5,12 +5,12 @@
 #include <vector>
 #include <type_traits>
 
-#include "libipc/export.h"
+#include "libipc/imp/export.h"
 #include "libipc/def.h"
 
 namespace ipc {
 
-class IPC_EXPORT buffer {
+class LIBIPC_EXPORT buffer {
 public:
     using destructor_t = void (*)(void*, std::size_t);
 
@@ -59,8 +59,8 @@ class IPC_EXPORT buffer {
         };
     }
 
-    friend IPC_EXPORT bool operator==(buffer const & b1, buffer const & b2);
-    friend IPC_EXPORT bool operator!=(buffer const & b1, buffer const & b2);
+    friend LIBIPC_EXPORT bool operator==(buffer const & b1, buffer const & b2);
+    friend LIBIPC_EXPORT bool operator!=(buffer const & b1, buffer const & b2);
 
 private:
     class buffer_;

include/libipc/concur/intrusive_stack.h

@@ -0,0 +1,66 @@
+/**
+ * \file libconcur/intrusive_stack.h
+ * \author mutouyun (orz@orzz.org)
+ * \brief Define concurrent intrusive stack.
+ */
+#pragma once
+
+#include <atomic>
+
+namespace ipc {
+namespace concur {
+
+/// \brief Intrusive stack node.
+/// \tparam T The type of the value.
+template <typename T>
+struct intrusive_node {
+  T value;
+  std::atomic<intrusive_node *> next;
+};
+
+/// \brief Intrusive stack.
+/// \tparam T The type of the value.
+/// \tparam Node The type of the node.
+template <typename T, typename Node = intrusive_node<T>>
+class intrusive_stack {
+public:
+  using node = Node;
+
+private:
+  std::atomic<node *> top_{nullptr};
+
+public:
+  intrusive_stack(intrusive_stack const &) = delete;
+  intrusive_stack(intrusive_stack &&) = delete;
+  intrusive_stack &operator=(intrusive_stack const &) = delete;
+  intrusive_stack &operator=(intrusive_stack &&) = delete;
+
+  constexpr intrusive_stack() noexcept = default;
+
+  bool empty() const noexcept {
+    return top_.load(std::memory_order_acquire) == nullptr;
+  }
+
+  void push(node *n) noexcept {
+    node *old_top = top_.load(std::memory_order_acquire);
+    do {
+      n->next.store(old_top, std::memory_order_relaxed);
+    } while (!top_.compare_exchange_weak(old_top, n, std::memory_order_release
+                                                   , std::memory_order_acquire));
+  }
+
+  node *pop() noexcept {
+    node *old_top = top_.load(std::memory_order_acquire);
+    do {
+      if (old_top == nullptr) {
+        return nullptr;
+      }
+    } while (!top_.compare_exchange_weak(old_top, old_top->next.load(std::memory_order_relaxed)
+                                                , std::memory_order_release
+                                                , std::memory_order_acquire));
+    return old_top;
+  }
+};
+
+} // namespace concur
+} // namespace ipc

include/libipc/condition.h

@@ -2,14 +2,14 @@
 
 #include <cstdint>  // std::uint64_t
 
-#include "libipc/export.h"
+#include "libipc/imp/export.h"
 #include "libipc/def.h"
 #include "libipc/mutex.h"
 
 namespace ipc {
 namespace sync {
 
-class IPC_EXPORT condition {
+class LIBIPC_EXPORT condition {
     condition(condition const &) = delete;
     condition &operator=(condition const &) = delete;
 

include/libipc/def.h

@@ -26,25 +26,26 @@ using uint_t = typename uint<N>::type;
 // constants
 
 enum : std::uint32_t {
-    invalid_value   = (std::numeric_limits<std::uint32_t>::max)(),
-    default_timeout = 100, // ms
+  invalid_value   = (std::numeric_limits<std::uint32_t>::max)(),
+  default_timeout = 100, // ms
 };
 
 enum : std::size_t {
-    data_length     = 64,
-    large_msg_limit = data_length,
-    large_msg_align = 1024,
-    large_msg_cache = 32,
+  central_cache_default_size = 1024 * 1024, ///< 1MB
+  data_length     = 64,
+  large_msg_limit = data_length,
+  large_msg_align = 1024,
+  large_msg_cache = 32,
 };
 
 enum class relat { // multiplicity of the relationship
-    single,
-    multi
+  single,
+  multi
 };
 
 enum class trans { // transmission
-    unicast,
-    broadcast
+  unicast,
+  broadcast
 };
 
 // producer-consumer policy flag
@@ -57,17 +58,17 @@ struct relat_trait;
 
 template <relat Rp, relat Rc, trans Ts>
 struct relat_trait<wr<Rp, Rc, Ts>> {
-    constexpr static bool is_multi_producer = (Rp == relat::multi);
-    constexpr static bool is_multi_consumer = (Rc == relat::multi);
-    constexpr static bool is_broadcast      = (Ts == trans::broadcast);
+  constexpr static bool is_multi_producer = (Rp == relat::multi);
+  constexpr static bool is_multi_consumer = (Rc == relat::multi);
+  constexpr static bool is_broadcast      = (Ts == trans::broadcast);
 };
 
 template <template <typename> class Policy, typename Flag>
 struct relat_trait<Policy<Flag>> : relat_trait<Flag> {};
 
 // the prefix tag of a channel
 struct prefix {
-    char const *str;
+  char const *str;
 };
 
 } // namespace ipc

include/libipc/imp/aligned.h

@@ -0,0 +1,74 @@
+/**
+ * \file libipc/aligned.h
+ * \author mutouyun (orz@orzz.org)
+ * \brief Defines the type suitable for use as uninitialized storage for types of given type.
+ */
+#pragma once
+
+#include <array>
+#include <cstddef>
+
+#include "libipc/imp/byte.h"
+
+namespace ipc {
+
+/**
+ * \brief The type suitable for use as uninitialized storage for types of given type.
+ *        std::aligned_storage is deprecated in C++23, so we define our own.
+ * \tparam T The type to be aligned.
+ * \tparam AlignT The alignment of the type.
+ * \see https://en.cppreference.com/w/cpp/types/aligned_storage
+ *      https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1413r3.pdf
+ */
+template <typename T, std::size_t AlignT = alignof(T)>
+class aligned {
+  alignas(AlignT) std::array<ipc::byte, sizeof(T)> storage_;
+
+public:
+  /**
+   * \brief Returns a pointer to the aligned storage.
+   * \return A pointer to the aligned storage.
+   */
+  T *ptr() noexcept {
+    return reinterpret_cast<T *>(storage_.data());
+  }
+
+  /**
+   * \brief Returns a pointer to the aligned storage.
+   * \return A pointer to the aligned storage.
+   */
+  T const *ptr() const noexcept {
+    return reinterpret_cast<const T *>(storage_.data());
+  }
+
+  /**
+   * \brief Returns a reference to the aligned storage.
+   * \return A reference to the aligned storage.
+   */
+  T &ref() noexcept {
+    return *ptr();
+  }
+
+  /**
+   * \brief Returns a reference to the aligned storage.
+   * \return A reference to the aligned storage.
+   */
+  T const &ref() const noexcept {
+    return *ptr();
+  }
+};
+
+/**
+ * \brief Rounds up the given value to the given alignment.
+ * \tparam T The type of the value.
+ * \param value The value to be rounded up.
+ * \param alignment The alignment to be rounded up to.
+ * \return The rounded up value.
+ * \see https://stackoverflow.com/questions/3407012/c-rounding-up-to-the-nearest-multiple-of-a-number
+*/
+template <typename T>
+constexpr T round_up(T value, T alignment) noexcept {
+  return (value + alignment - 1) & ~(alignment - 1);
+}
+
+} // namespace ipc