From f18c27ec29449840157ece7a9a57f5f817623933 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sun, 27 Feb 2022 17:13:28 +0800
Subject: [PATCH] =?UTF-8?q?=E5=BC=80=E5=A7=8B=E9=87=8D=E6=9E=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CMakeLists.txt                              |  72 ++-
 include/libipc/buffer.h                     |  68 --
 include/libipc/condition.h                  |  39 --
 include/libipc/def.h                        |  69 +-
 include/libipc/detect_plat.h                | 155 +++++
 include/libipc/export.h                     |  70 +-
 include/libipc/ipc.h                        | 173 -----
 include/libipc/mutex.h                      |  39 --
 include/libipc/pool_alloc.h                 | 103 ---
 include/libipc/rw_lock.h                    | 171 -----
 include/libipc/semaphore.h                  |  37 --
 include/libipc/shm.h                        |  59 --
 include/libipc/spin_lock.h                  | 179 ++++++
 performance.xlsx                            | Bin 75641 -> 0 bytes
 src/CMakeLists.txt                          |  19 +-
 src/libipc/buffer.cpp                       |  87 ---
 src/libipc/circ/elem_array.h                | 136 ----
 src/libipc/circ/elem_def.h                  |  77 ---
 src/libipc/ipc.cpp                          | 669 +-------------------
 src/libipc/memory/alloc.h                   | 424 -------------
 src/libipc/memory/allocator_wrapper.h       | 121 ----
 src/libipc/memory/resource.h                |  90 ---
 src/libipc/memory/wrapper.h                 | 327 ----------
 src/libipc/platform/detail.h                | 136 ----
 src/libipc/platform/linux/a0/LICENSE        |  24 -
 src/libipc/platform/linux/a0/README.md      | 213 -------
 src/libipc/platform/linux/a0/atomic.h       |  36 --
 src/libipc/platform/linux/a0/clock.h        |  60 --
 src/libipc/platform/linux/a0/empty.h        |  13 -
 src/libipc/platform/linux/a0/err.c          |  50 --
 src/libipc/platform/linux/a0/err.h          |  33 -
 src/libipc/platform/linux/a0/err_macro.h    |  52 --
 src/libipc/platform/linux/a0/ftx.h          | 111 ----
 src/libipc/platform/linux/a0/inline.h       |   8 -
 src/libipc/platform/linux/a0/mtx.c          | 420 ------------
 src/libipc/platform/linux/a0/mtx.h          |  57 --
 src/libipc/platform/linux/a0/strconv.c      |  64 --
 src/libipc/platform/linux/a0/strconv.h      |  31 -
 src/libipc/platform/linux/a0/thread_local.h |  10 -
 src/libipc/platform/linux/a0/tid.c          |  30 -
 src/libipc/platform/linux/a0/tid.h          |  16 -
 src/libipc/platform/linux/a0/time.c         | 124 ----
 src/libipc/platform/linux/a0/time.h         |  97 ---
 src/libipc/platform/linux/a0/unused.h       |   7 -
 src/libipc/platform/linux/condition.h       |  66 --
 src/libipc/platform/linux/get_wait_time.h   |  46 --
 src/libipc/platform/linux/mutex.h           | 204 ------
 src/libipc/platform/linux/sync_obj_impl.h   |  69 --
 src/libipc/platform/platform.c              |  13 -
 src/libipc/platform/platform.cpp            |   9 -
 src/libipc/platform/posix/condition.h       | 141 -----
 src/libipc/platform/posix/get_error.h       |  14 -
 src/libipc/platform/posix/get_wait_time.h   |  39 --
 src/libipc/platform/posix/mutex.h           | 237 -------
 src/libipc/platform/posix/semaphore_impl.h  | 100 ---
 src/libipc/platform/posix/shm_posix.cpp     | 197 ------
 src/libipc/platform/win/condition.h         | 119 ----
 src/libipc/platform/win/get_sa.h            |  35 -
 src/libipc/platform/win/mutex.h             |  96 ---
 src/libipc/platform/win/semaphore.h         |  74 ---
 src/libipc/platform/win/shm_win.cpp         | 135 ----
 src/libipc/platform/win/to_tchar.h          |  74 ---
 src/libipc/policy.h                         |  25 -
 src/libipc/pool_alloc.cpp                   |  17 -
 src/libipc/prod_cons.h                      | 315 ---------
 src/libipc/queue.h                          | 198 ------
 src/libipc/shm.cpp                          | 103 ---
 src/libipc/sync/condition.cpp               |  72 ---
 src/libipc/sync/mutex.cpp                   |  72 ---
 src/libipc/sync/semaphore.cpp               |  66 --
 src/libipc/utility/concept.h                |  29 -
 src/libipc/utility/id_pool.h                | 103 ---
 src/libipc/utility/log.h                    |  39 --
 src/libipc/utility/pimpl.h                  |  64 --
 src/libipc/utility/scope_guard.h            |  64 --
 src/libipc/utility/utility.h                |  64 --
 src/libipc/waiter.h                         |  81 ---
 test/CMakeLists.txt                         |  15 +-
 test/test.h                                 |  86 ---
 test/test_detect_plat.cpp                   |  79 +++
 test/test_ipc.cpp                           | 183 ------
 test/test_mem.cpp                           | 218 -------
 test/test_platform.cpp                      |  31 -
 test/test_queue.cpp                         | 299 ---------
 test/test_shm.cpp                           | 102 ---
 test/test_sync.cpp                          | 208 ------
 test/test_thread_utility.cpp                | 203 ------
 test/test_waiter.cpp                        |  68 --
 test/thread_pool.h                          | 123 ----
 89 files changed, 503 insertions(+), 8868 deletions(-)
 delete mode 100755 include/libipc/buffer.h
 delete mode 100644 include/libipc/condition.h
 create mode 100644 include/libipc/detect_plat.h
 delete mode 100755 include/libipc/ipc.h
 delete mode 100644 include/libipc/mutex.h
 delete mode 100755 include/libipc/pool_alloc.h
 delete mode 100755 include/libipc/rw_lock.h
 delete mode 100644 include/libipc/semaphore.h
 delete mode 100755 include/libipc/shm.h
 create mode 100644 include/libipc/spin_lock.h
 delete mode 100644 performance.xlsx
 delete mode 100755 src/libipc/buffer.cpp
 delete mode 100755 src/libipc/circ/elem_array.h
 delete mode 100755 src/libipc/circ/elem_def.h
 delete mode 100755 src/libipc/memory/alloc.h
 delete mode 100755 src/libipc/memory/allocator_wrapper.h
 delete mode 100755 src/libipc/memory/resource.h
 delete mode 100755 src/libipc/memory/wrapper.h
 delete mode 100755 src/libipc/platform/detail.h
 delete mode 100644 src/libipc/platform/linux/a0/LICENSE
 delete mode 100644 src/libipc/platform/linux/a0/README.md
 delete mode 100644 src/libipc/platform/linux/a0/atomic.h
 delete mode 100644 src/libipc/platform/linux/a0/clock.h
 delete mode 100644 src/libipc/platform/linux/a0/empty.h
 delete mode 100644 src/libipc/platform/linux/a0/err.c
 delete mode 100644 src/libipc/platform/linux/a0/err.h
 delete mode 100644 src/libipc/platform/linux/a0/err_macro.h
 delete mode 100644 src/libipc/platform/linux/a0/ftx.h
 delete mode 100644 src/libipc/platform/linux/a0/inline.h
 delete mode 100644 src/libipc/platform/linux/a0/mtx.c
 delete mode 100644 src/libipc/platform/linux/a0/mtx.h
 delete mode 100644 src/libipc/platform/linux/a0/strconv.c
 delete mode 100644 src/libipc/platform/linux/a0/strconv.h
 delete mode 100644 src/libipc/platform/linux/a0/thread_local.h
 delete mode 100644 src/libipc/platform/linux/a0/tid.c
 delete mode 100644 src/libipc/platform/linux/a0/tid.h
 delete mode 100644 src/libipc/platform/linux/a0/time.c
 delete mode 100644 src/libipc/platform/linux/a0/time.h
 delete mode 100644 src/libipc/platform/linux/a0/unused.h
 delete mode 100644 src/libipc/platform/linux/condition.h
 delete mode 100644 src/libipc/platform/linux/get_wait_time.h
 delete mode 100644 src/libipc/platform/linux/mutex.h
 delete mode 100644 src/libipc/platform/linux/sync_obj_impl.h
 delete mode 100644 src/libipc/platform/platform.c
 delete mode 100644 src/libipc/platform/platform.cpp
 delete mode 100644 src/libipc/platform/posix/condition.h
 delete mode 100644 src/libipc/platform/posix/get_error.h
 delete mode 100644 src/libipc/platform/posix/get_wait_time.h
 delete mode 100644 src/libipc/platform/posix/mutex.h
 delete mode 100644 src/libipc/platform/posix/semaphore_impl.h
 delete mode 100644 src/libipc/platform/posix/shm_posix.cpp
 delete mode 100644 src/libipc/platform/win/condition.h
 delete mode 100644 src/libipc/platform/win/get_sa.h
 delete mode 100644 src/libipc/platform/win/mutex.h
 delete mode 100644 src/libipc/platform/win/semaphore.h
 delete mode 100755 src/libipc/platform/win/shm_win.cpp
 delete mode 100755 src/libipc/platform/win/to_tchar.h
 delete mode 100755 src/libipc/policy.h
 delete mode 100755 src/libipc/pool_alloc.cpp
 delete mode 100755 src/libipc/prod_cons.h
 delete mode 100755 src/libipc/queue.h
 delete mode 100755 src/libipc/shm.cpp
 delete mode 100644 src/libipc/sync/condition.cpp
 delete mode 100644 src/libipc/sync/mutex.cpp
 delete mode 100644 src/libipc/sync/semaphore.cpp
 delete mode 100755 src/libipc/utility/concept.h
 delete mode 100755 src/libipc/utility/id_pool.h
 delete mode 100755 src/libipc/utility/log.h
 delete mode 100755 src/libipc/utility/pimpl.h
 delete mode 100644 src/libipc/utility/scope_guard.h
 delete mode 100755 src/libipc/utility/utility.h
 delete mode 100644 src/libipc/waiter.h
 delete mode 100755 test/test.h
 create mode 100644 test/test_detect_plat.cpp
 delete mode 100755 test/test_ipc.cpp
 delete mode 100755 test/test_mem.cpp
 delete mode 100644 test/test_platform.cpp
 delete mode 100755 test/test_queue.cpp
 delete mode 100755 test/test_shm.cpp
 delete mode 100644 test/test_sync.cpp
 delete mode 100755 test/test_thread_utility.cpp
 delete mode 100755 test/test_waiter.cpp
 delete mode 100755 test/thread_pool.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6d9b2a5..1eb24a0 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,29 +10,31 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DNDEBUG")
 if(NOT MSVC)
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
 endif()
 
+add_definitions(-DLIBIPC_CPP_14 -DLIBIPC_CPP_17)
+
 if (MSVC)
-    set(CompilerFlags
-        CMAKE_CXX_FLAGS
-        CMAKE_CXX_FLAGS_DEBUG
-        CMAKE_CXX_FLAGS_RELEASE
-        CMAKE_C_FLAGS
-        CMAKE_C_FLAGS_DEBUG
-        CMAKE_C_FLAGS_RELEASE
-        )
-    if (LIBIPC_USE_STATIC_CRT)
-        foreach(CompilerFlag ${CompilerFlags})
-            string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
-            string(REPLACE "/MDd" "/MTd" ${CompilerFlag} "${${CompilerFlag}}")
-        endforeach()
-    else()
-        foreach(CompilerFlag ${CompilerFlags})
-            string(REPLACE "/MT" "/MD" ${CompilerFlag} "${${CompilerFlag}}")
-            string(REPLACE "/MTd" "/MDd" ${CompilerFlag} "${${CompilerFlag}}")
-        endforeach()
-    endif()
+  set(CompilerFlags
+      CMAKE_CXX_FLAGS
+      CMAKE_CXX_FLAGS_DEBUG
+      CMAKE_CXX_FLAGS_RELEASE
+      CMAKE_C_FLAGS
+      CMAKE_C_FLAGS_DEBUG
+      CMAKE_C_FLAGS_RELEASE
+      )
+  if (LIBIPC_USE_STATIC_CRT)
+      foreach(CompilerFlag ${CompilerFlags})
+        string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
+        string(REPLACE "/MDd" "/MTd" ${CompilerFlag} "${${CompilerFlag}}")
+      endforeach()
+  else()
+      foreach(CompilerFlag ${CompilerFlags})
+        string(REPLACE "/MT" "/MD" ${CompilerFlag} "${${CompilerFlag}}")
+        string(REPLACE "/MTd" "/MDd" ${CompilerFlag} "${${CompilerFlag}}")
+      endforeach()
+  endif()
 endif()
 
 set(LIBRARY_OUTPUT_PATH    ${CMAKE_BINARY_DIR}/bin)
@@ -45,23 +47,23 @@ add_definitions(-DUNICODE -D_UNICODE)
 add_subdirectory(src)
 
 if (LIBIPC_BUILD_TESTS)
-    set(GOOGLETEST_VERSION 1.10.0)
-    if (LIBIPC_USE_STATIC_CRT)
-        set(gtest_force_shared_crt OFF)
-    else()
-        set(gtest_force_shared_crt ON)
-    endif()
-    add_subdirectory(3rdparty/gtest)
-    add_subdirectory(test)
+  set(GOOGLETEST_VERSION 1.10.0)
+  if (LIBIPC_USE_STATIC_CRT)
+      set(gtest_force_shared_crt OFF)
+  else()
+      set(gtest_force_shared_crt ON)
+  endif()
+  add_subdirectory(3rdparty/gtest)
+  add_subdirectory(test)
 endif()
 
-if (LIBIPC_BUILD_DEMOS)
-    add_subdirectory(demo/chat)
-    add_subdirectory(demo/msg_que)
-    add_subdirectory(demo/send_recv)
-endif()
+# if (LIBIPC_BUILD_DEMOS)
+#   add_subdirectory(demo/chat)
+#   add_subdirectory(demo/msg_que)
+#   add_subdirectory(demo/send_recv)
+# endif()
 
 install(
-    DIRECTORY "include/"
-    DESTINATION "include"
+  DIRECTORY "include/"
+  DESTINATION "include"
 )
diff --git a/include/libipc/buffer.h b/include/libipc/buffer.h
deleted file mode 100755
index 3f8c229..0000000
--- a/include/libipc/buffer.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <tuple>
-#include <vector>
-#include <type_traits>
-
-#include "libipc/export.h"
-#include "libipc/def.h"
-
-namespace ipc {
-
-class IPC_EXPORT buffer {
-public:
-    using destructor_t = void (*)(void*, std::size_t);
-
-    buffer();
-
-    buffer(void* p, std::size_t s, destructor_t d);
-    buffer(void* p, std::size_t s, destructor_t d, void* additional);
-    buffer(void* p, std::size_t s);
-
-    template <std::size_t N>
-    explicit buffer(byte_t const (& data)[N])
-        : buffer(data, sizeof(data)) {
-    }
-    explicit buffer(char const & c);
-
-    buffer(buffer&& rhs);
-    ~buffer();
-
-    void swap(buffer& rhs);
-    buffer& operator=(buffer rhs);
-
-    bool empty() const noexcept;
-
-    void *       data()       noexcept;
-    void const * data() const noexcept;
-
-    template <typename T>
-    T get() const { return T(data()); }
-
-    std::size_t size() const noexcept;
-
-    std::tuple<void*, std::size_t> to_tuple() {
-        return std::make_tuple(data(), size());
-    }
-
-    std::tuple<void const *, std::size_t> to_tuple() const {
-        return std::make_tuple(data(), size());
-    }
-
-    std::vector<byte_t> to_vector() const {
-        return {
-            get<byte_t const *>(),
-            get<byte_t const *>() + size()
-        };
-    }
-
-    friend IPC_EXPORT bool operator==(buffer const & b1, buffer const & b2);
-    friend IPC_EXPORT bool operator!=(buffer const & b1, buffer const & b2);
-
-private:
-    class buffer_;
-    buffer_* p_;
-};
-
-} // namespace ipc
diff --git a/include/libipc/condition.h b/include/libipc/condition.h
deleted file mode 100644
index a4e2ac3..0000000
--- a/include/libipc/condition.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include <cstdint>  // std::uint64_t
-
-#include "libipc/export.h"
-#include "libipc/def.h"
-#include "libipc/mutex.h"
-
-namespace ipc {
-namespace sync {
-
-class IPC_EXPORT condition {
-    condition(condition const &) = delete;
-    condition &operator=(condition const &) = delete;
-
-public:
-    condition();
-    explicit condition(char const *name);
-    ~condition();
-
-    void const *native() const noexcept;
-    void *native() noexcept;
-
-    bool valid() const noexcept;
-
-    bool open(char const *name) noexcept;
-    void close() noexcept;
-
-    bool wait(ipc::sync::mutex &mtx, std::uint64_t tm = ipc::invalid_value) noexcept;
-    bool notify(ipc::sync::mutex &mtx) noexcept;
-    bool broadcast(ipc::sync::mutex &mtx) noexcept;
-
-private:
-    class condition_;
-    condition_* p_;
-};
-
-} // namespace sync
-} // namespace ipc
diff --git a/include/libipc/def.h b/include/libipc/def.h
index 8c1a72b..b3ebd6f 100755
--- a/include/libipc/def.h
+++ b/include/libipc/def.h
@@ -1,68 +1,19 @@
+/**
+ * @file def.h
+ * @author mutouyun (orz@orzz.org)
+ * @brief Define the trivial configuration information
+ * @date 2022-02-27
+ */
 #pragma once
 
 #include <cstddef>
 #include <cstdint>
-#include <limits>       // std::numeric_limits
-#include <new>
-#include <utility>
 
-namespace ipc {
+#define LIBIPC_NAMESPACE_BEG_ namespace ipc {
+#define LIBIPC_NAMESPACE_END_ }
 
-// types
-
-using byte_t = std::uint8_t;
-
-template <std::size_t N>
-struct uint;
-
-template <> struct uint<8 > { using type = std::uint8_t ; };
-template <> struct uint<16> { using type = std::uint16_t; };
-template <> struct uint<32> { using type = std::uint32_t; };
-template <> struct uint<64> { using type = std::uint64_t; };
-
-template <std::size_t N>
-using uint_t = typename uint<N>::type;
+LIBIPC_NAMESPACE_BEG_
 
 // constants
 
-enum : std::uint32_t {
-    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,
-};
-
-enum class relat { // multiplicity of the relationship
-    single,
-    multi
-};
-
-enum class trans { // transmission
-    unicast,
-    broadcast
-};
-
-// producer-consumer policy flag
-
-template <relat Rp, relat Rc, trans Ts>
-struct wr {};
-
-template <typename WR>
-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);
-};
-
-template <template <typename> class Policy, typename Flag>
-struct relat_trait<Policy<Flag>> : relat_trait<Flag> {};
-
-} // namespace ipc
+LIBIPC_NAMESPACE_END_
diff --git a/include/libipc/detect_plat.h b/include/libipc/detect_plat.h
new file mode 100644
index 0000000..196796f
--- /dev/null
+++ b/include/libipc/detect_plat.h
@@ -0,0 +1,155 @@
+/**
+ * @file detect_plat.h
+ * @author mutouyun (orz@orzz.org)
+ * @brief Define platform detection related interfaces
+ * @date 2022-02-27
+ */
+#pragma once
+
+// OS
+
+#if defined(WINCE) || defined(_WIN32_WCE)
+# define LIBIPC_OS_WINCE
+#elif defined(WIN64) || defined(_WIN64) || defined(__WIN64__) || \
+     (defined(__x86_64) && defined(__MSYS__))
+#define LIBIPC_OS_WIN64
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || \
+      defined(__NT__) || defined(__MSYS__)
+# define LIBIPC_OS_WIN32
+#elif defined(__linux__) || defined(__linux)
+# define LIBIPC_OS_LINUX
+#elif defined(__QNX__) || defined(__QNXNTO__)
+# define LIBIPC_OS_QNX
+#elif defined(ANDROID) || defined(__ANDROID__)
+# define LIBIPC_OS_ANDROID
+#else
+# error "This OS is unsupported."
+#endif
+
+#if defined(LIBIPC_OS_WIN32) || defined(LIBIPC_OS_WIN64) || \
+    defined(LIBIPC_OS_WINCE)
+# define LIBIPC_OS_WIN
+#endif
+
+// Compiler
+
+#if defined(_MSC_VER)
+# define LIBIPC_CC_MSVC
+#elif defined(__GNUC__)
+# define LIBIPC_CC_GNUC
+#else
+# error "This compiler is unsupported."
+#endif
+
+// Instruction set
+// @see https://sourceforge.net/p/predef/wiki/Architectures/
+
+#if defined(_M_X64) || defined(_M_AMD64) || \
+    defined(__x86_64__) || defined(__x86_64) || \
+    defined(__amd64__) || defined(__amd64)
+# define LIBIPC_INSTR_X64
+#elif defined(_M_IA64) || defined(__IA64__) || defined(_IA64) || \
+      defined(__ia64__) || defined(__ia64)
+# define LIBIPC_INSTR_I64
+#elif defined(_M_IX86) || defined(_X86_) || defined(__i386__) || defined(__i386)
+# define LIBIPC_INSTR_X86
+#elif defined(_M_ARM64) || defined(__arm64__) || defined(__aarch64__)
+# define LIBIPC_INSTR_ARM64
+#elif defined(_M_ARM) || defined(_ARM) || defined(__arm__) || defined(__arm)
+# define LIBIPC_INSTR_ARM32
+#else
+# error "This instruction set is unsupported."
+#endif
+
+#if defined(LIBIPC_INSTR_X86) || defined(LIBIPC_INSTR_X64)
+# define LIBIPC_INSTR_X86_64
+#elif defined(LIBIPC_INSTR_ARM32) || defined(LIBIPC_INSTR_ARM64)
+# define LIBIPC_INSTR_ARM
+#endif
+
+// Byte order
+
+#if defined(__BYTE_ORDER__)
+# define LIBIPC_ENDIAN_BIG   (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+# define LIBIPC_ENDIAN_LIT   (!LIBIPC_ENDIAN_BIG)
+#else
+# define LIBIPC_ENDIAN_BIG   (0)
+# define LIBIPC_ENDIAN_LIT   (1)
+#endif
+
+// C++ version
+
+#if (__cplusplus >= 202002L) && !defined(LIBIPC_CPP_20)
+# define LIBIPC_CPP_20
+#endif
+#if (__cplusplus >= 201703L) && !defined(LIBIPC_CPP_17)
+# define LIBIPC_CPP_17
+#endif
+#if (__cplusplus >= 201402L) && !defined(LIBIPC_CPP_14)
+# define LIBIPC_CPP_14
+#endif
+
+#if !defined(LIBIPC_CPP_20) && \
+    !defined(LIBIPC_CPP_17) && \
+    !defined(LIBIPC_CPP_14)
+# error "This C++ version is unsupported."
+#endif
+
+// C++ attributes
+
+#if defined(__has_cpp_attribute)
+# if __has_cpp_attribute(fallthrough)
+#   define LIBIPC_FALLTHROUGH [[fallthrough]]
+# endif
+# if __has_cpp_attribute(maybe_unused)
+#   define LIBIPC_UNUSED [[maybe_unused]]
+# endif
+# if __has_cpp_attribute(likely)
+#   define LIBIPC_LIKELY(...) (__VA_ARGS__) [[likely]]
+# endif
+# if __has_cpp_attribute(unlikely)
+#   define LIBIPC_UNLIKELY(...) (__VA_ARGS__) [[unlikely]]
+# endif
+#endif
+
+#if !defined(LIBIPC_FALLTHROUGH)
+# if defined(LIBIPC_CC_GNUC)
+#   define LIBIPC_FALLTHROUGH __attribute__((__fallthrough__))
+# else
+#   define LIBIPC_FALLTHROUGH
+# endif
+#endif
+
+#if !defined(LIBIPC_UNUSED)
+# if defined(LIBIPC_CC_GNUC)
+#   define LIBIPC_UNUSED __attribute__((__unused__))
+# elif defined(LIBIPC_CC_MSVC_)
+#   define LIBIPC_UNUSED __pragma(warning(suppress: 4100 4101 4189))
+# else
+#   define LIBIPC_UNUSED
+# endif
+#endif
+
+#if !defined(LIBIPC_LIKELY)
+# if defined(__has_builtin)
+#   if __has_builtin(__builtin_expect)
+#     define LIBIPC_LIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 1))
+#   endif
+# endif
+#endif
+
+#if !defined(LIBIPC_LIKELY)
+# define LIBIPC_LIKELY(...) (__VA_ARGS__)
+#endif
+
+#if !defined(LIBIPC_UNLIKELY)
+# if defined(__has_builtin)
+#   if __has_builtin(__builtin_expect)
+#     define LIBIPC_UNLIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 0))
+#   endif
+# endif
+#endif
+
+#if !defined(LIBIPC_UNLIKELY)
+# define LIBIPC_UNLIKELY(...) (__VA_ARGS__)
+#endif
diff --git a/include/libipc/export.h b/include/libipc/export.h
index 6024f2f..40a6879 100755
--- a/include/libipc/export.h
+++ b/include/libipc/export.h
@@ -1,54 +1,46 @@
+/**
+ * @file export.h
+ * @author mutouyun (orz@orzz.org)
+ * @brief Define the symbol export interfaces
+ * @date 2022-02-27
+ */
 #pragma once
 
+#include "libipc/detect_plat.h"
+
 #if defined(Q_DECL_EXPORT) && defined(Q_DECL_IMPORT)
 
-#   define IPC_DECL_EXPORT Q_DECL_EXPORT
-#   define IPC_DECL_IMPORT Q_DECL_IMPORT
+# define LIBIPC_DECL_EXPORT Q_DECL_EXPORT
+# define LIBIPC_DECL_IMPORT Q_DECL_IMPORT
 
 #else // defined(Q_DECL_EXPORT) && defined(Q_DECL_IMPORT)
 
 /*
- * Compiler & system detection for IPC_DECL_EXPORT & IPC_DECL_IMPORT.
+ * Compiler & system detection for LIBIPC_DECL_EXPORT & LIBIPC_DECL_IMPORT.
  * Not using QtCore cause it shouldn't depend on Qt.
 */
-
-#if defined(_MSC_VER)
-#   define IPC_DECL_EXPORT      __declspec(dllexport)
-#   define IPC_DECL_IMPORT      __declspec(dllimport)
-#elif defined(__ARMCC__) || defined(__CC_ARM)
-#   if defined(ANDROID) || defined(__linux__) || defined(__linux)
-#       define IPC_DECL_EXPORT  __attribute__((visibility("default")))
-#       define IPC_DECL_IMPORT  __attribute__((visibility("default")))
-#   else
-#       define IPC_DECL_EXPORT  __declspec(dllexport)
-#       define IPC_DECL_IMPORT  __declspec(dllimport)
-#   endif
-#elif defined(__GNUC__)
-#   if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || \
-       defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
-#       define IPC_DECL_EXPORT  __declspec(dllexport)
-#       define IPC_DECL_IMPORT  __declspec(dllimport)
-#   else
-#       define IPC_DECL_EXPORT  __attribute__((visibility("default")))
-#       define IPC_DECL_IMPORT  __attribute__((visibility("default")))
-#   endif
-#else
-#   define IPC_DECL_EXPORT      __attribute__((visibility("default")))
-#   define IPC_DECL_IMPORT      __attribute__((visibility("default")))
-#endif
+# if defined(LIBIPC_CC_MSVC) || defined(LIBIPC_OS_WIN)
+#   define LIBIPC_DECL_EXPORT __declspec(dllexport)
+#   define LIBIPC_DECL_IMPORT __declspec(dllimport)
+# elif defined(LIBIPC_OS_ANDROID) || defined(LIBIPC_OS_LINUX) || defined(LIBIPC_CC_GNUC)
+#   define LIBIPC_DECL_EXPORT __attribute__((visibility("default")))
+#   define LIBIPC_DECL_IMPORT __attribute__((visibility("default")))
+# else
+#   define LIBIPC_DECL_EXPORT __attribute__((visibility("default")))
+#   define LIBIPC_DECL_IMPORT __attribute__((visibility("default")))
+# endif
 
 #endif // defined(Q_DECL_EXPORT) && defined(Q_DECL_IMPORT)
 
 /*
- * Define IPC_EXPORT for exporting function & class.
+ * Define LIBIPC_EXPORT for exporting function & class.
 */
-
-#ifndef IPC_EXPORT
-#if defined(LIBIPC_LIBRARY_SHARED_BUILDING__)
-#  define IPC_EXPORT IPC_DECL_EXPORT
-#elif defined(LIBIPC_LIBRARY_SHARED_USING__)
-#  define IPC_EXPORT IPC_DECL_IMPORT
-#else
-#  define IPC_EXPORT
-#endif
-#endif /*IPC_EXPORT*/
+#ifndef LIBIPC_EXPORT
+# if defined(LIBIPC_LIBRARY_SHARED_BUILDING__)
+#   define LIBIPC_EXPORT LIBIPC_DECL_EXPORT
+# elif defined(LIBIPC_LIBRARY_SHARED_USING__)
+#   define LIBIPC_EXPORT LIBIPC_DECL_IMPORT
+# else
+#   define LIBIPC_EXPORT
+# endif
+#endif /*LIBIPC_EXPORT*/
diff --git a/include/libipc/ipc.h b/include/libipc/ipc.h
deleted file mode 100755
index 0b4459f..0000000
--- a/include/libipc/ipc.h
+++ /dev/null
@@ -1,173 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "libipc/export.h"
-#include "libipc/def.h"
-#include "libipc/buffer.h"
-#include "libipc/shm.h"
-
-namespace ipc {
-
-using handle_t = void*;
-using buff_t   = buffer;
-
-enum : unsigned {
-    sender,
-    receiver
-};
-
-template <typename Flag>
-struct IPC_EXPORT chan_impl {
-    static bool connect   (ipc::handle_t * ph, char const * name, unsigned mode);
-    static bool reconnect (ipc::handle_t * ph, unsigned mode);
-    static void disconnect(ipc::handle_t h);
-    static void destroy   (ipc::handle_t h);
-
-    static char const * name(ipc::handle_t h);
-
-    static std::size_t recv_count(ipc::handle_t h);
-    static bool wait_for_recv(ipc::handle_t h, std::size_t r_count, std::uint64_t tm);
-
-    static bool   send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm);
-    static buff_t recv(ipc::handle_t h, std::uint64_t tm);
-    static buff_t try_recv(ipc::handle_t h);
-};
-
-template <typename Flag>
-class chan_wrapper {
-private:
-    using detail_t = chan_impl<Flag>;
-
-    ipc::handle_t h_ = nullptr;
-    unsigned mode_   = ipc::sender;
-    bool connected_  = false;
-
-public:
-    chan_wrapper() noexcept = default;
-
-    explicit chan_wrapper(char const * name, unsigned mode = ipc::sender)
-        : connected_{this->connect(name, mode)} {
-    }
-
-    chan_wrapper(chan_wrapper&& rhs) noexcept
-        : chan_wrapper{} {
-        swap(rhs);
-    }
-
-    ~chan_wrapper() {
-        detail_t::destroy(h_);
-    }
-
-    void swap(chan_wrapper& rhs) noexcept {
-        std::swap(h_        , rhs.h_);
-        std::swap(mode_     , rhs.mode_);
-        std::swap(connected_, rhs.connected_);
-    }
-
-    chan_wrapper& operator=(chan_wrapper rhs) noexcept {
-        swap(rhs);
-        return *this;
-    }
-
-    char const * name() const noexcept {
-        return detail_t::name(h_);
-    }
-
-    ipc::handle_t handle() const noexcept {
-        return h_;
-    }
-
-    bool valid() const noexcept {
-        return (handle() != nullptr);
-    }
-
-    unsigned mode() const noexcept {
-        return mode_;
-    }
-
-    chan_wrapper clone() const {
-        return chan_wrapper {name(), mode_};
-    }
-
-    /**
-     * Building handle, then try connecting with name & mode flags.
-    */
-    bool connect(char const * name, unsigned mode = ipc::sender | ipc::receiver) {
-        if (name == nullptr || name[0] == '\0') return false;
-        detail_t::disconnect(h_); // clear old connection
-        return connected_ = detail_t::connect(&h_, name, mode_ = mode);
-    }
-
-    /**
-     * Try connecting with new mode flags.
-    */
-    bool reconnect(unsigned mode) {
-        if (!valid()) return false;
-        if (connected_ && (mode_ == mode)) return true;
-        return connected_ = detail_t::reconnect(&h_, mode_ = mode);
-    }
-
-    void disconnect() {
-        if (!valid()) return;
-        detail_t::disconnect(h_);
-        connected_ = false;
-    }
-
-    std::size_t recv_count() const {
-        return detail_t::recv_count(h_);
-    }
-
-    bool wait_for_recv(std::size_t r_count, std::uint64_t tm = invalid_value) const {
-        return detail_t::wait_for_recv(h_, r_count, tm);
-    }
-
-    static bool wait_for_recv(char const * name, std::size_t r_count, std::uint64_t tm = invalid_value) {
-        return chan_wrapper(name).wait_for_recv(r_count, tm);
-    }
-
-    bool send(void const * data, std::size_t size, std::uint64_t tm = default_timeout) {
-        return detail_t::send(h_, data, size, tm);
-    }
-    bool send(buff_t const & buff, std::uint64_t tm = default_timeout) {
-        return this->send(buff.data(), buff.size(), tm);
-    }
-    bool send(std::string const & str, std::uint64_t tm = default_timeout) {
-        return this->send(str.c_str(), str.size() + 1, tm);
-    }
-
-    buff_t recv(std::uint64_t tm = invalid_value) {
-        return detail_t::recv(h_, tm);
-    }
-    buff_t try_recv() {
-        return detail_t::try_recv(h_);
-    }
-};
-
-template <relat Rp, relat Rc, trans Ts>
-using chan = chan_wrapper<ipc::wr<Rp, Rc, Ts>>;
-
-/**
- * class route
- *
- * You could use one producer/server/sender for sending messages to a route,
- * then all the consumers/clients/receivers which are receiving with this route,
- * would receive your sent messages.
- *
- * A route could only be used in 1 to N
- * (one producer/writer to multi consumers/readers)
-*/
-
-using route = chan<relat::single, relat::multi, trans::broadcast>;
-
-/**
- * class channel
- *
- * You could use multi producers/writers for sending messages to a channel,
- * then all the consumers/readers which are receiving with this channel,
- * would receive your sent messages.
-*/
-
-using channel = chan<relat::multi, relat::multi, trans::broadcast>;
-
-} // namespace ipc
diff --git a/include/libipc/mutex.h b/include/libipc/mutex.h
deleted file mode 100644
index 2d4781f..0000000
--- a/include/libipc/mutex.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include <cstdint>  // std::uint64_t
-#include <system_error>
-
-#include "libipc/export.h"
-#include "libipc/def.h"
-
-namespace ipc {
-namespace sync {
-
-class IPC_EXPORT mutex {
-    mutex(mutex const &) = delete;
-    mutex &operator=(mutex const &) = delete;
-
-public:
-    mutex();
-    explicit mutex(char const *name);
-    ~mutex();
-
-    void const *native() const noexcept;
-    void *native() noexcept;
-
-    bool valid() const noexcept;
-
-    bool open(char const *name) noexcept;
-    void close() noexcept;
-
-    bool lock(std::uint64_t tm = ipc::invalid_value) noexcept;
-    bool try_lock() noexcept(false); // std::system_error
-    bool unlock() noexcept;
-
-private:
-    class mutex_;
-    mutex_* p_;
-};
-
-} // namespace sync
-} // namespace ipc
diff --git a/include/libipc/pool_alloc.h b/include/libipc/pool_alloc.h
deleted file mode 100755
index a889be7..0000000
--- a/include/libipc/pool_alloc.h
+++ /dev/null
@@ -1,103 +0,0 @@
-#pragma once
-
-#include <new>
-#include <utility>
-
-#include "libipc/export.h"
-#include "libipc/def.h"
-
-namespace ipc {
-namespace mem {
-
-class IPC_EXPORT pool_alloc {
-public:
-    static void* alloc(std::size_t size);
-    static void  free (void* p, std::size_t size);
-};
-
-////////////////////////////////////////////////////////////////
-/// construct/destruct an object
-////////////////////////////////////////////////////////////////
-
-namespace detail {
-
-template <typename T>
-struct impl {
-    template <typename... P>
-    static T* construct(T* p, P&&... params) {
-        ::new (p) T(std::forward<P>(params)...);
-        return p;
-    }
-
-    static void destruct(T* p) {
-        reinterpret_cast<T*>(p)->~T();
-    }
-};
-
-template <typename T, size_t N>
-struct impl<T[N]> {
-    using type = T[N];
-
-    template <typename... P>
-    static type* construct(type* p, P&&... params) {
-        for (size_t i = 0; i < N; ++i) {
-            impl<T>::construct(&((*p)[i]), std::forward<P>(params)...);
-        }
-        return p;
-    }
-
-    static void destruct(type* p) {
-        for (size_t i = 0; i < N; ++i) {
-            impl<T>::destruct(&((*p)[i]));
-        }
-    }
-};
-
-} // namespace detail
-
-template <typename T, typename... P>
-T* construct(T* p, P&&... params) {
-    return detail::impl<T>::construct(p, std::forward<P>(params)...);
-}
-
-template <typename T, typename... P>
-T* construct(void* p, P&&... params) {
-    return construct(static_cast<T*>(p), std::forward<P>(params)...);
-}
-
-template <typename T>
-void destruct(T* p) {
-    return detail::impl<T>::destruct(p);
-}
-
-template <typename T>
-void destruct(void* p) {
-    destruct(static_cast<T*>(p));
-}
-
-////////////////////////////////////////////////////////////////
-/// general alloc/free
-////////////////////////////////////////////////////////////////
-
-inline void* alloc(std::size_t size) {
-    return pool_alloc::alloc(size);
-}
-
-template <typename T, typename... P>
-T* alloc(P&&... params) {
-    return construct<T>(pool_alloc::alloc(sizeof(T)), std::forward<P>(params)...);
-}
-
-inline void free(void* p, std::size_t size) {
-    pool_alloc::free(p, size);
-}
-
-template <typename T>
-void free(T* p) {
-    if (p == nullptr) return;
-    destruct(p);
-    pool_alloc::free(p, sizeof(T));
-}
-
-} // namespace mem
-} // namespace ipc
diff --git a/include/libipc/rw_lock.h b/include/libipc/rw_lock.h
deleted file mode 100755
index 31ed9de..0000000
--- a/include/libipc/rw_lock.h
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <thread>
-#include <chrono>
-#include <limits>
-#include <type_traits>
-#include <utility>
-
-////////////////////////////////////////////////////////////////
-/// Gives hint to processor that improves performance of spin-wait loops.
-////////////////////////////////////////////////////////////////
-
-#pragma push_macro("IPC_LOCK_PAUSE_")
-#undef  IPC_LOCK_PAUSE_
-
-#if defined(_MSC_VER)
-#include <windows.h>    // YieldProcessor
-/*
-    See: http://msdn.microsoft.com/en-us/library/windows/desktop/ms687419(v=vs.85).aspx
-    Not for intel c++ compiler, so ignore http://software.intel.com/en-us/forums/topic/296168
-*/
-#   define IPC_LOCK_PAUSE_() YieldProcessor()
-#elif defined(__GNUC__)
-#if defined(__i386__) || defined(__x86_64__)
-/*
-    See: Intel(R) 64 and IA-32 Architectures Software Developer's Manual V2
-         PAUSE-Spin Loop Hint, 4-57
-         http://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-software-developer-instruction-set-reference-manual-325383.html?wapkw=instruction+set+reference
-*/
-#   define IPC_LOCK_PAUSE_() __asm__ __volatile__("pause")
-#elif defined(__ia64__) || defined(__ia64)
-/*
-    See: Intel(R) Itanium(R) Architecture Developer's Manual, Vol.3
-         hint - Performance Hint, 3:145
-         http://www.intel.com/content/www/us/en/processors/itanium/itanium-architecture-vol-3-manual.html
-*/
-#   define IPC_LOCK_PAUSE_() __asm__ __volatile__ ("hint @pause")
-#elif defined(__arm__)
-/*
-    See: ARM Architecture Reference Manuals (YIELD)
-         http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.subset.architecture.reference/index.html
-*/
-#   define IPC_LOCK_PAUSE_() __asm__ __volatile__ ("yield")
-#endif
-#endif/*compilers*/
-
-#if !defined(IPC_LOCK_PAUSE_)
-/*
-    Just use a compiler fence, prevent compiler from optimizing loop
-*/
-#   define IPC_LOCK_PAUSE_() std::atomic_signal_fence(std::memory_order_seq_cst)
-#endif/*!defined(IPC_LOCK_PAUSE_)*/
-
-////////////////////////////////////////////////////////////////
-/// Yield to other threads
-////////////////////////////////////////////////////////////////
-
-namespace ipc {
-
-template <typename K>
-inline void yield(K& k) noexcept {
-    if (k < 4)  { /* Do nothing */ }
-    else
-    if (k < 16) { IPC_LOCK_PAUSE_(); }
-    else
-    if (k < 32) { std::this_thread::yield(); }
-    else {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-        return;
-    }
-    ++k;
-}
-
-template <std::size_t N = 32, typename K, typename F>
-inline void sleep(K& k, F&& f) {
-    if (k < static_cast<K>(N)) {
-        std::this_thread::yield();
-    }
-    else {
-        static_cast<void>(std::forward<F>(f)());
-        return;
-    }
-    ++k;
-}
-
-template <std::size_t N = 32, typename K>
-inline void sleep(K& k) {
-    sleep<N>(k, [] {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-    });
-}
-
-} // namespace ipc
-
-#pragma pop_macro("IPC_LOCK_PAUSE_")
-
-namespace ipc {
-
-class spin_lock {
-    std::atomic<unsigned> lc_ { 0 };
-
-public:
-    void lock(void) noexcept {
-        for (unsigned k = 0;
-             lc_.exchange(1, std::memory_order_acquire);
-             yield(k)) ;
-    }
-
-    void unlock(void) noexcept {
-        lc_.store(0, std::memory_order_release);
-    }
-};
-
-class rw_lock {
-    using lc_ui_t = unsigned;
-
-    std::atomic<lc_ui_t> lc_ { 0 };
-
-    enum : lc_ui_t {
-        w_mask = (std::numeric_limits<std::make_signed_t<lc_ui_t>>::max)(), // b 0111 1111
-        w_flag = w_mask + 1                                                 // b 1000 0000
-    };
-
-public:
-    rw_lock() = default;
-
-    rw_lock(const rw_lock&) = delete;
-    rw_lock& operator=(const rw_lock&) = delete;
-    rw_lock(rw_lock&&) = delete;
-    rw_lock& operator=(rw_lock&&) = delete;
-
-    void lock() noexcept {
-        for (unsigned k = 0;;) {
-            auto old = lc_.fetch_or(w_flag, std::memory_order_acq_rel);
-            if (!old) return;           // got w-lock
-            if (!(old & w_flag)) break; // other thread having r-lock
-            yield(k);                   // other thread having w-lock
-        }
-        // wait for reading finished
-        for (unsigned k = 0;
-             lc_.load(std::memory_order_acquire) & w_mask;
-             yield(k)) ;
-    }
-
-    void unlock() noexcept {
-        lc_.store(0, std::memory_order_release);
-    }
-
-    void lock_shared() noexcept {
-        auto old = lc_.load(std::memory_order_acquire);
-        for (unsigned k = 0;;) {
-            // if w_flag set, just continue
-            if (old & w_flag) {
-                yield(k);
-                old = lc_.load(std::memory_order_acquire);
-            }
-            // otherwise try cas lc + 1 (set r-lock)
-            else if (lc_.compare_exchange_weak(old, old + 1, std::memory_order_release)) {
-                return;
-            }
-            // set r-lock failed, old has been updated
-        }
-    }
-
-    void unlock_shared() noexcept {
-        lc_.fetch_sub(1, std::memory_order_release);
-    }
-};
-
-} // namespace ipc
diff --git a/include/libipc/semaphore.h b/include/libipc/semaphore.h
deleted file mode 100644
index 7f557e2..0000000
--- a/include/libipc/semaphore.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include <cstdint>  // std::uint64_t
-
-#include "libipc/export.h"
-#include "libipc/def.h"
-
-namespace ipc {
-namespace sync {
-
-class IPC_EXPORT semaphore {
-    semaphore(semaphore const &) = delete;
-    semaphore &operator=(semaphore const &) = delete;
-
-public:
-    semaphore();
-    explicit semaphore(char const *name, std::uint32_t count = 0);
-    ~semaphore();
-
-    void const *native() const noexcept;
-    void *native() noexcept;
-
-    bool valid() const noexcept;
-
-    bool open(char const *name, std::uint32_t count = 0) noexcept;
-    void close() noexcept;
-
-    bool wait(std::uint64_t tm = ipc::invalid_value) noexcept;
-    bool post(std::uint32_t count = 1) noexcept;
-
-private:
-    class semaphore_;
-    semaphore_* p_;
-};
-
-} // namespace sync
-} // namespace ipc
diff --git a/include/libipc/shm.h b/include/libipc/shm.h
deleted file mode 100755
index 12e3223..0000000
--- a/include/libipc/shm.h
+++ /dev/null
@@ -1,59 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-#include "libipc/export.h"
-
-namespace ipc {
-namespace shm {
-
-using id_t = void*;
-
-enum : unsigned {
-    create = 0x01,
-    open   = 0x02
-};
-
-IPC_EXPORT id_t         acquire(char const * name, std::size_t size, unsigned mode = create | open);
-IPC_EXPORT void *       get_mem(id_t id, std::size_t * size);
-IPC_EXPORT std::int32_t release(id_t id);
-IPC_EXPORT void         remove (id_t id);
-IPC_EXPORT void         remove (char const * name);
-
-IPC_EXPORT std::int32_t get_ref(id_t id);
-IPC_EXPORT void sub_ref(id_t id);
-
-class IPC_EXPORT handle {
-public:
-    handle();
-    handle(char const * name, std::size_t size, unsigned mode = create | open);
-    handle(handle&& rhs);
-
-    ~handle();
-
-    void swap(handle& rhs);
-    handle& operator=(handle rhs);
-
-    bool         valid() const noexcept;
-    std::size_t  size () const noexcept;
-    char const * name () const noexcept;
-
-    std::int32_t ref() const noexcept;
-    void sub_ref() noexcept;
-
-    bool acquire(char const * name, std::size_t size, unsigned mode = create | open);
-    std::int32_t release();
-
-    void* get() const;
-
-    void attach(id_t);
-    id_t detach();
-
-private:
-    class handle_;
-    handle_* p_;
-};
-
-} // namespace shm
-} // namespace ipc
diff --git a/include/libipc/spin_lock.h b/include/libipc/spin_lock.h
new file mode 100644
index 0000000..49c4acd
--- /dev/null
+++ b/include/libipc/spin_lock.h
@@ -0,0 +1,179 @@
+/**
+ * @file spin_lock.h
+ * @author mutouyun (orz@orzz.org)
+ * @brief Define spin locks
+ * @date 2022-02-27
+ */
+#pragma once
+
+#include <atomic>
+#include <thread>
+#include <chrono>
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+#include "libipc/detect_plat.h"
+#include "libipc/def.h"
+
+////////////////////////////////////////////////////////////////
+/// Gives hint to processor that improves performance of spin-wait loops.
+////////////////////////////////////////////////////////////////
+
+#pragma push_macro("LIBIPC_LOCK_PAUSE_")
+#undef LIBIPC_LOCK_PAUSE_
+
+#if defined(LIBIPC_CC_MSVC)
+# include <Windows.h>   // YieldProcessor
+/*
+ *  @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms687419(v=vs.85).aspx
+ *       Not for intel c++ compiler, so ignore http://software.intel.com/en-us/forums/topic/296168
+*/
+# define LIBIPC_LOCK_PAUSE_() YieldProcessor()
+#elif defined(LIBIPC_CC_GNUC)
+# if defined(LIBIPC_INSTR_X86_64)
+/*
+ *  @see Intel(R) 64 and IA-32 Architectures Software Developer's Manual V2
+ *       PAUSE-Spin Loop Hint, 4-57
+ *       http://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-software-developer-instruction-set-reference-manual-325383.html?wapkw=instruction+set+reference
+*/
+#   define LIBIPC_LOCK_PAUSE_() __asm__ __volatile__("pause")
+# elif defined(LIBIPC_INSTR_I64)
+/*
+ *  @see Intel(R) Itanium(R) Architecture Developer's Manual, Vol.3
+ *       hint - Performance Hint, 3:145
+ *       http://www.intel.com/content/www/us/en/processors/itanium/itanium-architecture-vol-3-manual.html
+*/
+#   define LIBIPC_LOCK_PAUSE_() __asm__ __volatile__ ("hint @pause")
+#elif defined(LIBIPC_INSTR_ARM)
+/*
+ *  @see ARM Architecture Reference Manuals (YIELD)
+ *       http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.subset.architecture.reference/index.html
+*/
+#   define LIBIPC_LOCK_PAUSE_() __asm__ __volatile__ ("yield")
+# endif
+#endif /*compilers*/
+
+#if !defined(LIBIPC_LOCK_PAUSE_)
+/*
+ *  Just use a compiler fence, prevent compiler from optimizing loop
+*/
+# define LIBIPC_LOCK_PAUSE_() std::atomic_signal_fence(std::memory_order_seq_cst)
+#endif /*!defined(LIBIPC_LOCK_PAUSE_)*/
+
+////////////////////////////////////////////////////////////////
+/// Yield to other threads
+////////////////////////////////////////////////////////////////
+
+LIBIPC_NAMESPACE_BEG_
+
+template <typename K>
+inline void yield(K &k) noexcept {
+  if (k < 4)  { /* Do nothing */ }
+  else
+  if (k < 16) { LIBIPC_LOCK_PAUSE_(); }
+  else
+  if (k < 32) { std::this_thread::yield(); }
+  else {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    return;
+  }
+  ++k;
+}
+
+template <std::size_t N = 32, typename K, typename F>
+inline void sleep(K &k, F &&f) {
+  if (k < static_cast<K>(N)) {
+    std::this_thread::yield();
+  }
+  else {
+    static_cast<void>(std::forward<F>(f)());
+    return;
+  }
+  ++k;
+}
+
+template <std::size_t N = 32, typename K>
+inline void sleep(K &k) {
+  sleep<N>(k, [] {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  });
+}
+
+} // namespace ipc
+
+#pragma pop_macro("LIBIPC_LOCK_PAUSE_")
+
+namespace ipc {
+
+class spin_lock {
+  std::atomic<unsigned> lc_ { 0 };
+
+public:
+  void lock(void) noexcept {
+    for (unsigned k = 0;
+      lc_.exchange(1, std::memory_order_acquire);
+      yield(k)) ;
+  }
+  void unlock(void) noexcept {
+    lc_.store(0, std::memory_order_release);
+  }
+};
+
+class rw_lock {
+  using lc_ui_t = unsigned;
+
+  std::atomic<lc_ui_t> lc_ { 0 };
+
+  enum : lc_ui_t {
+    w_mask = (std::numeric_limits<std::make_signed_t<lc_ui_t>>::max)(), // b 0111 1111
+    w_flag = w_mask + 1                                                 // b 1000 0000
+  };
+
+public:
+  rw_lock() = default;
+
+  rw_lock(const rw_lock &) = delete;
+  rw_lock &operator=(const rw_lock &) = delete;
+  rw_lock(rw_lock &&) = delete;
+  rw_lock &operator=(rw_lock &&) = delete;
+
+  void lock() noexcept {
+    for (unsigned k = 0;;) {
+      auto old = lc_.fetch_or(w_flag, std::memory_order_acq_rel);
+      if (!old) return;           // got w-lock
+      if (!(old & w_flag)) break; // other thread having r-lock
+      yield(k);                   // other thread having w-lock
+    }
+    // wait for reading finished
+    for (unsigned k = 0;
+         lc_.load(std::memory_order_acquire) & w_mask;
+         yield(k)) ;
+  }
+
+  void unlock() noexcept {
+    lc_.store(0, std::memory_order_release);
+  }
+
+  void lock_shared() noexcept {
+    auto old = lc_.load(std::memory_order_acquire);
+    for (unsigned k = 0;;) {
+      // if w_flag set, just continue
+      if (old & w_flag) {
+        yield(k);
+        old = lc_.load(std::memory_order_acquire);
+      }
+      // otherwise try cas lc + 1 (set r-lock)
+      else if (lc_.compare_exchange_weak(old, old + 1, std::memory_order_release)) {
+        return;
+      }
+      // set r-lock failed, old has been updated
+    }
+  }
+
+  void unlock_shared() noexcept {
+    lc_.fetch_sub(1, std::memory_order_release);
+  }
+};
+
+LIBIPC_NAMESPACE_END_
diff --git a/performance.xlsx b/performance.xlsx
deleted file mode 100644
index ac085e1064e0da6b11f68379234b7e5a2bcfd769..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 75641
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

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e1f439f..37efae1 100755
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,17 +1,9 @@
 project(ipc)
 
 aux_source_directory(${LIBIPC_PROJECT_DIR}/src/libipc SRC_FILES)
-aux_source_directory(${LIBIPC_PROJECT_DIR}/src/libipc/sync SRC_FILES)
-aux_source_directory(${LIBIPC_PROJECT_DIR}/src/libipc/platform SRC_FILES)
 
 file(GLOB HEAD_FILES
-  ${LIBIPC_PROJECT_DIR}/include/libipc/*.h
-  ${LIBIPC_PROJECT_DIR}/src/libipc/*.h
-  ${LIBIPC_PROJECT_DIR}/src/libipc/*.inc
-  ${LIBIPC_PROJECT_DIR}/src/libipc/circ/*.h
-  ${LIBIPC_PROJECT_DIR}/src/libipc/memory/*.h
-  ${LIBIPC_PROJECT_DIR}/src/libipc/platform/*.h
-  ${LIBIPC_PROJECT_DIR}/src/libipc/utility/*.h)
+  ${LIBIPC_PROJECT_DIR}/include/libipc/*.h)
 
 if (LIBIPC_BUILD_SHARED_LIBS)
   add_library(${PROJECT_NAME} SHARED ${SRC_FILES} ${HEAD_FILES})
@@ -33,14 +25,13 @@ set_target_properties(${PROJECT_NAME}
 
 # set version
 set_target_properties(${PROJECT_NAME}
-    PROPERTIES
-    VERSION 1.2.0
-    SOVERSION 3)
+  PROPERTIES
+  VERSION 2.0.0
+  SOVERSION 4)
 
 target_include_directories(${PROJECT_NAME}
   PUBLIC  ${LIBIPC_PROJECT_DIR}/include
-  PRIVATE ${LIBIPC_PROJECT_DIR}/src
-          $<$<BOOL:UNIX>:${LIBIPC_PROJECT_DIR}/src/libipc/platform/linux>)
+  PRIVATE ${LIBIPC_PROJECT_DIR}/src)
 
 if(NOT MSVC)
   target_link_libraries(${PROJECT_NAME} PUBLIC
diff --git a/src/libipc/buffer.cpp b/src/libipc/buffer.cpp
deleted file mode 100755
index 084b815..0000000
--- a/src/libipc/buffer.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include "libipc/buffer.h"
-#include "libipc/utility/pimpl.h"
-
-#include <cstring>
-
-namespace ipc {
-
-bool operator==(buffer const & b1, buffer const & b2) {
-    return (b1.size() == b2.size()) && (std::memcmp(b1.data(), b2.data(), b1.size()) == 0);
-}
-
-bool operator!=(buffer const & b1, buffer const & b2) {
-    return !(b1 == b2);
-}
-
-class buffer::buffer_ : public pimpl<buffer_> {
-public:
-    void*       p_;
-    std::size_t s_;
-    void*       a_;
-    buffer::destructor_t d_;
-
-    buffer_(void* p, std::size_t s, buffer::destructor_t d, void* a)
-        : p_(p), s_(s), a_(a), d_(d) {
-    }
-
-    ~buffer_() {
-        if (d_ == nullptr) return;
-        d_((a_ == nullptr) ? p_ : a_, s_);
-    }
-};
-
-buffer::buffer()
-    : buffer(nullptr, 0, nullptr, nullptr) {
-}
-
-buffer::buffer(void* p, std::size_t s, destructor_t d)
-    : p_(p_->make(p, s, d, nullptr)) {
-}
-
-buffer::buffer(void* p, std::size_t s, destructor_t d, void* additional)
-    : p_(p_->make(p, s, d, additional)) {
-}
-
-buffer::buffer(void* p, std::size_t s)
-    : buffer(p, s, nullptr) {
-}
-
-buffer::buffer(char const & c)
-    : buffer(const_cast<char*>(&c), 1) {
-}
-
-buffer::buffer(buffer&& rhs)
-    : buffer() {
-    swap(rhs);
-}
-
-buffer::~buffer() {
-    p_->clear();
-}
-
-void buffer::swap(buffer& rhs) {
-    std::swap(p_, rhs.p_);
-}
-
-buffer& buffer::operator=(buffer rhs) {
-    swap(rhs);
-    return *this;
-}
-
-bool buffer::empty() const noexcept {
-    return (impl(p_)->p_ == nullptr) || (impl(p_)->s_ == 0);
-}
-
-void* buffer::data() noexcept {
-    return impl(p_)->p_;
-}
-
-void const * buffer::data() const noexcept {
-    return impl(p_)->p_;
-}
-
-std::size_t buffer::size() const noexcept {
-    return impl(p_)->s_;
-}
-
-} // namespace ipc
diff --git a/src/libipc/circ/elem_array.h b/src/libipc/circ/elem_array.h
deleted file mode 100755
index 5febcba..0000000
--- a/src/libipc/circ/elem_array.h
+++ /dev/null
@@ -1,136 +0,0 @@
-#pragma once
-
-#include <atomic>   // std::atomic<?>
-#include <limits>
-#include <utility>
-#include <type_traits>
-
-#include "libipc/def.h"
-#include "libipc/rw_lock.h"
-
-#include "libipc/circ/elem_def.h"
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-namespace circ {
-
-template <typename Policy,
-          std::size_t DataSize,
-          std::size_t AlignSize = (ipc::detail::min)(DataSize, alignof(std::max_align_t))>
-class elem_array : public ipc::circ::conn_head<Policy> {
-public:
-    using base_t   = ipc::circ::conn_head<Policy>;
-    using policy_t = Policy;
-    using cursor_t = decltype(std::declval<policy_t>().cursor());
-    using elem_t   = typename policy_t::template elem_t<DataSize, AlignSize>;
-
-    enum : std::size_t {
-        head_size  = sizeof(base_t) + sizeof(policy_t),
-        data_size  = DataSize,
-        elem_max   = (std::numeric_limits<uint_t<8>>::max)() + 1, // default is 255 + 1
-        elem_size  = sizeof(elem_t),
-        block_size = elem_size * elem_max
-    };
-
-private:
-    policy_t head_;
-    elem_t   block_[elem_max] {};
-
-    /**
-     * @remarks 'warning C4348: redefinition of default parameter' with MSVC.
-     * @see
-     *  - https://stackoverflow.com/questions/12656239/redefinition-of-default-template-parameter
-     *  - https://developercommunity.visualstudio.com/content/problem/425978/incorrect-c4348-warning-in-nested-template-declara.html
-    */
-    template <typename P, bool/* = relat_trait<P>::is_multi_producer*/>
-    struct sender_checker;
-
-    template <typename P>
-    struct sender_checker<P, true> {
-        constexpr static bool connect() noexcept {
-            // always return true
-            return true;
-        }
-        constexpr static void disconnect() noexcept {}
-    };
-
-    template <typename P>
-    struct sender_checker<P, false> {
-        bool connect() noexcept {
-            return !flag_.test_and_set(std::memory_order_acq_rel);
-        }
-        void disconnect() noexcept {
-            flag_.clear();
-        }
-
-    private:
-        // in shm, it should be 0 whether it's initialized or not.
-        std::atomic_flag flag_ = ATOMIC_FLAG_INIT;
-    };
-
-    template <typename P, bool/* = relat_trait<P>::is_multi_consumer*/>
-    struct receiver_checker;
-
-    template <typename P>
-    struct receiver_checker<P, true> {
-        constexpr static cc_t connect(base_t &conn) noexcept {
-            return conn.connect();
-        }
-        constexpr static cc_t disconnect(base_t &conn, cc_t cc_id) noexcept {
-            return conn.disconnect(cc_id);
-        }
-    };
-
-    template <typename P>
-    struct receiver_checker<P, false> : protected sender_checker<P, false> {
-        cc_t connect(base_t &conn) noexcept {
-            return sender_checker<P, false>::connect() ? conn.connect() : 0;
-        }
-        cc_t disconnect(base_t &conn, cc_t cc_id) noexcept {
-            sender_checker<P, false>::disconnect();
-            return conn.disconnect(cc_id);
-        }
-    };
-
-    sender_checker  <policy_t, relat_trait<policy_t>::is_multi_producer> s_ckr_;
-    receiver_checker<policy_t, relat_trait<policy_t>::is_multi_consumer> r_ckr_;
-
-    // make these be private
-    using base_t::connect;
-    using base_t::disconnect;
-
-public:
-    bool connect_sender() noexcept {
-        return s_ckr_.connect();
-    }
-
-    void disconnect_sender() noexcept {
-        return s_ckr_.disconnect();
-    }
-
-    cc_t connect_receiver() noexcept {
-        return r_ckr_.connect(*this);
-    }
-
-    cc_t disconnect_receiver(cc_t cc_id) noexcept {
-        return r_ckr_.disconnect(*this, cc_id);
-    }
-
-    cursor_t cursor() const noexcept {
-        return head_.cursor();
-    }
-
-    template <typename F>
-    bool push(F&& f) {
-        return head_.push(std::forward<F>(f), block_);
-    }
-
-    template <typename F>
-    bool pop(cursor_t* cur, F&& f) {
-        if (cur == nullptr) return false;
-        return head_.pop(*cur, std::forward<F>(f), block_);
-    }
-};
-
-} // namespace circ
-} // namespace ipc
diff --git a/src/libipc/circ/elem_def.h b/src/libipc/circ/elem_def.h
deleted file mode 100755
index e14ef01..0000000
--- a/src/libipc/circ/elem_def.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <cstddef>
-#include <cstdint>
-#include <new>
-
-#include "libipc/def.h"
-#include "libipc/rw_lock.h"
-
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-namespace circ {
-
-using u1_t = ipc::uint_t<8>;
-using u2_t = ipc::uint_t<32>;
-
-/** only supports max 32 connections in broadcast mode */
-using cc_t = u2_t;
-
-constexpr u1_t index_of(u2_t c) noexcept {
-    return static_cast<u1_t>(c);
-}
-
-class conn_head_base {
-protected:
-    std::atomic<cc_t> cc_{0}; // connections
-    ipc::spin_lock lc_;
-    std::atomic<bool> constructed_{false};
-
-public:
-    void init() {
-        /* DCLP */
-        if (!constructed_.load(std::memory_order_acquire)) {
-            IPC_UNUSED_ auto guard = ipc::detail::unique_lock(lc_);
-            if (!constructed_.load(std::memory_order_relaxed)) {
-                ::new (this) conn_head_base;
-                constructed_.store(true, std::memory_order_release);
-            }
-        }
-    }
-
-    conn_head_base() = default;
-    conn_head_base(conn_head_base const &) = delete;
-    conn_head_base &operator=(conn_head_base const &) = delete;
-
-    cc_t connections(std::memory_order order = std::memory_order_acquire) const noexcept {
-        return this->cc_.load(order);
-    }
-};
-
-template <typename P>
-class conn_head : public conn_head_base {
-public:
-    cc_t connect() noexcept {
-        return this->cc_.fetch_add(1, std::memory_order_relaxed) + 1;
-    }
-
-    cc_t disconnect(cc_t cc_id) noexcept {
-        if (cc_id == ~static_cast<circ::cc_t>(0u)) {
-            // clear all connections
-            this->cc_.store(0, std::memory_order_relaxed);
-            return 0u;
-        }
-        else {
-            return this->cc_.fetch_sub(1, std::memory_order_relaxed) - 1;
-        }
-    }
-
-    std::size_t conn_count(std::memory_order order = std::memory_order_acquire) const noexcept {
-        return this->connections(order);
-    }
-};
-
-} // namespace circ
-} // namespace ipc
diff --git a/src/libipc/ipc.cpp b/src/libipc/ipc.cpp
index 58d7979..c7f4a86 100755
--- a/src/libipc/ipc.cpp
+++ b/src/libipc/ipc.cpp
@@ -1,669 +1,2 @@
 
-#include <type_traits>
-#include <cstring>
-#include <algorithm>
-#include <utility>          // std::pair, std::move, std::forward
-#include <atomic>
-#include <type_traits>      // aligned_storage_t
-#include <string>
-#include <vector>
-#include <array>
-#include <cassert>
-
-#include "libipc/ipc.h"
-#include "libipc/def.h"
-#include "libipc/shm.h"
-#include "libipc/pool_alloc.h"
-#include "libipc/queue.h"
-#include "libipc/policy.h"
-#include "libipc/rw_lock.h"
-#include "libipc/waiter.h"
-
-#include "libipc/utility/log.h"
-#include "libipc/utility/id_pool.h"
-#include "libipc/utility/scope_guard.h"
-#include "libipc/utility/utility.h"
-
-#include "libipc/memory/resource.h"
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_array.h"
-
-namespace {
-
-using msg_id_t = std::uint32_t;
-using acc_t    = std::atomic<msg_id_t>;
-
-template <std::size_t DataSize, std::size_t AlignSize>
-struct msg_t;
-
-template <std::size_t AlignSize>
-struct msg_t<0, AlignSize> {
-    msg_id_t     cc_id_;
-    msg_id_t     id_;
-    std::int32_t remain_;
-    bool         storage_;
-};
-
-template <std::size_t DataSize, std::size_t AlignSize>
-struct msg_t : msg_t<0, AlignSize> {
-    std::aligned_storage_t<DataSize, AlignSize> data_ {};
-
-    msg_t() = default;
-    msg_t(msg_id_t cc_id, msg_id_t id, std::int32_t remain, void const * data, std::size_t size)
-        : msg_t<0, AlignSize> {cc_id, id, remain, (data == nullptr) || (size == 0)} {
-        if (this->storage_) {
-            if (data != nullptr) {
-                // copy storage-id
-                *reinterpret_cast<ipc::storage_id_t*>(&data_) =
-                     *static_cast<ipc::storage_id_t const *>(data);
-            }
-        }
-        else std::memcpy(&data_, data, size);
-    }
-};
-
-template <typename T>
-ipc::buff_t make_cache(T& data, std::size_t size) {
-    auto ptr = ipc::mem::alloc(size);
-    std::memcpy(ptr, &data, (ipc::detail::min)(sizeof(data), size));
-    return { ptr, size, ipc::mem::free };
-}
-
-struct cache_t {
-    std::size_t fill_;
-    ipc::buff_t buff_;
-
-    cache_t(std::size_t f, ipc::buff_t && b)
-        : fill_(f), buff_(std::move(b))
-    {}
-
-    void append(void const * data, std::size_t size) {
-        if (fill_ >= buff_.size() || data == nullptr || size == 0) return;
-        auto new_fill = (ipc::detail::min)(fill_ + size, buff_.size());
-        std::memcpy(static_cast<ipc::byte_t*>(buff_.data()) + fill_, data, new_fill - fill_);
-        fill_ = new_fill;
-    }
-};
-
-auto cc_acc() {
-    static ipc::shm::handle acc_h("__CA_CONN__", sizeof(acc_t));
-    return static_cast<acc_t*>(acc_h.get());
-}
-
-IPC_CONSTEXPR_ std::size_t align_chunk_size(std::size_t size) noexcept {
-    return (((size - 1) / ipc::large_msg_align) + 1) * ipc::large_msg_align;
-}
-
-IPC_CONSTEXPR_ std::size_t calc_chunk_size(std::size_t size) noexcept {
-    return ipc::make_align(alignof(std::max_align_t), align_chunk_size(
-           ipc::make_align(alignof(std::max_align_t), sizeof(std::atomic<ipc::circ::cc_t>)) + size));
-}
-
-struct chunk_t {
-    std::atomic<ipc::circ::cc_t> &conns() noexcept {
-        return *reinterpret_cast<std::atomic<ipc::circ::cc_t> *>(this);
-    }
-
-    void *data() noexcept {
-        return reinterpret_cast<ipc::byte_t *>(this)
-             + ipc::make_align(alignof(std::max_align_t), sizeof(std::atomic<ipc::circ::cc_t>));
-    }
-};
-
-struct chunk_info_t {
-    ipc::id_pool<> pool_;
-    ipc::spin_lock lock_;
-
-    IPC_CONSTEXPR_ static std::size_t chunks_mem_size(std::size_t chunk_size) noexcept {
-        return ipc::id_pool<>::max_count * chunk_size;
-    }
-
-    ipc::byte_t *chunks_mem() noexcept {
-        return reinterpret_cast<ipc::byte_t *>(this + 1);
-    }
-
-    chunk_t *at(std::size_t chunk_size, ipc::storage_id_t id) noexcept {
-        if (id < 0) return nullptr;
-        return reinterpret_cast<chunk_t *>(chunks_mem() + (chunk_size * id));
-    }
-};
-
-auto& chunk_storages() {
-    class chunk_handle_t {
-        ipc::shm::handle handle_;
-
-    public:
-        chunk_info_t *get_info(std::size_t chunk_size) {
-            if (!handle_.valid() &&
-                !handle_.acquire( ("__CHUNK_INFO__" + ipc::to_string(chunk_size)).c_str(), 
-                                  sizeof(chunk_info_t) + chunk_info_t::chunks_mem_size(chunk_size) )) {
-                ipc::error("[chunk_storages] chunk_shm.id_info_.acquire failed: chunk_size = %zd\n", chunk_size);
-                return nullptr;
-            }
-            auto info = static_cast<chunk_info_t*>(handle_.get());
-            if (info == nullptr) {
-                ipc::error("[chunk_storages] chunk_shm.id_info_.get failed: chunk_size = %zd\n", chunk_size);
-                return nullptr;
-            }
-            return info;
-        }
-    };
-    static ipc::map<std::size_t, chunk_handle_t> chunk_hs;
-    return chunk_hs;
-}
-
-chunk_info_t *chunk_storage_info(std::size_t chunk_size) {
-    auto &storages = chunk_storages();
-    std::decay_t<decltype(storages)>::iterator it;
-    {
-        static ipc::rw_lock lock;
-        IPC_UNUSED_ std::shared_lock<ipc::rw_lock> guard {lock};
-        if ((it = storages.find(chunk_size)) == storages.end()) {
-            using chunk_handle_t = std::decay_t<decltype(storages)>::value_type::second_type;
-            guard.unlock();
-            IPC_UNUSED_ std::lock_guard<ipc::rw_lock> guard {lock};
-            it = storages.emplace(chunk_size, chunk_handle_t{}).first;
-        }
-    }
-    return it->second.get_info(chunk_size);
-}
-
-std::pair<ipc::storage_id_t, void*> acquire_storage(std::size_t size, ipc::circ::cc_t conns) {
-    std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
-    if (info == nullptr) return {};
-
-    info->lock_.lock();
-    info->pool_.prepare();
-    // got an unique id
-    auto id = info->pool_.acquire();
-    info->lock_.unlock();
-
-    auto chunk = info->at(chunk_size, id);
-    if (chunk == nullptr) return {};
-    chunk->conns().store(conns, std::memory_order_relaxed);
-    return { id, chunk->data() };
-}
-
-void *find_storage(ipc::storage_id_t id, std::size_t size) {
-    if (id < 0) {
-        ipc::error("[find_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
-        return nullptr;
-    }
-    std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
-    if (info == nullptr) return nullptr;
-    return info->at(chunk_size, id)->data();
-}
-
-void release_storage(ipc::storage_id_t id, std::size_t size) {
-    if (id < 0) {
-        ipc::error("[release_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
-        return;
-    }
-    std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
-    if (info == nullptr) return;
-    info->lock_.lock();
-    info->pool_.release(id);
-    info->lock_.unlock();
-}
-
-template <ipc::relat Rp, ipc::relat Rc>
-bool sub_rc(ipc::wr<Rp, Rc, ipc::trans::unicast>, 
-            std::atomic<ipc::circ::cc_t> &/*conns*/, ipc::circ::cc_t /*curr_conns*/, ipc::circ::cc_t /*conn_id*/) noexcept {
-    return true;
-}
-
-template <ipc::relat Rp, ipc::relat Rc>
-bool sub_rc(ipc::wr<Rp, Rc, ipc::trans::broadcast>, 
-            std::atomic<ipc::circ::cc_t> &conns, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) noexcept {
-    auto last_conns = curr_conns & ~conn_id;
-    for (unsigned k = 0;;) {
-        auto chunk_conns  = conns.load(std::memory_order_acquire);
-        if (conns.compare_exchange_weak(chunk_conns, chunk_conns & last_conns, std::memory_order_release)) {
-            return (chunk_conns & last_conns) == 0;
-        }
-        ipc::yield(k);
-    }
-}
-
-template <typename Flag>
-void recycle_storage(ipc::storage_id_t id, std::size_t size, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) {
-    if (id < 0) {
-        ipc::error("[recycle_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
-        return;
-    }
-    std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
-    if (info == nullptr) return;
-
-    auto chunk = info->at(chunk_size, id);
-    if (chunk == nullptr) return;
-
-    if (!sub_rc(Flag{}, chunk->conns(), curr_conns, conn_id)) {
-        return;
-    }
-    info->lock_.lock();
-    info->pool_.release(id);
-    info->lock_.unlock();
-}
-
-template <typename MsgT>
-bool clear_message(void* p) {
-    auto msg = static_cast<MsgT*>(p);
-    if (msg->storage_) {
-        std::int32_t r_size = static_cast<std::int32_t>(ipc::data_length) + msg->remain_;
-        if (r_size <= 0) {
-            ipc::error("[clear_message] invalid msg size: %d\n", (int)r_size);
-            return true;
-        }
-        release_storage(
-            *reinterpret_cast<ipc::storage_id_t*>(&msg->data_),
-            static_cast<std::size_t>(r_size));
-    }
-    return true;
-}
-
-struct conn_info_head {
-
-    ipc::string name_;
-    msg_id_t    cc_id_; // connection-info id
-    ipc::detail::waiter cc_waiter_, wt_waiter_, rd_waiter_;
-    ipc::shm::handle acc_h_;
-
-    conn_info_head(char const * name)
-        : name_     {name}
-        , cc_id_    {(cc_acc() == nullptr) ? 0 : cc_acc()->fetch_add(1, std::memory_order_relaxed)}
-        , cc_waiter_{("__CC_CONN__" + name_).c_str()}
-        , wt_waiter_{("__WT_CONN__" + name_).c_str()}
-        , rd_waiter_{("__RD_CONN__" + name_).c_str()}
-        , acc_h_    {("__AC_CONN__" + name_).c_str(), sizeof(acc_t)} {
-    }
-
-    void quit_waiting() {
-        cc_waiter_.quit_waiting();
-        wt_waiter_.quit_waiting();
-        rd_waiter_.quit_waiting();
-    }
-
-    auto acc() {
-        return static_cast<acc_t*>(acc_h_.get());
-    }
-
-    auto& recv_cache() {
-        thread_local ipc::unordered_map<msg_id_t, cache_t> tls;
-        return tls;
-    }
-};
-
-template <typename W, typename F>
-bool wait_for(W& waiter, F&& pred, std::uint64_t tm) {
-    if (tm == 0) return !pred();
-    for (unsigned k = 0; pred();) {
-        bool ret = true;
-        ipc::sleep(k, [&k, &ret, &waiter, &pred, tm] {
-            ret = waiter.wait_if(std::forward<F>(pred), tm);
-            k   = 0;
-        });
-        if (!ret) return false; // timeout or fail
-        if (k == 0) break; // k has been reset
-    }
-    return true;
-}
-
-template <typename Policy,
-          std::size_t DataSize  = ipc::data_length,
-          std::size_t AlignSize = (ipc::detail::min)(DataSize, alignof(std::max_align_t))>
-struct queue_generator {
-
-    using queue_t = ipc::queue<msg_t<DataSize, AlignSize>, Policy>;
-
-    struct conn_info_t : conn_info_head {
-        queue_t que_;
-
-        conn_info_t(char const * name)
-            : conn_info_head{name}
-            , que_{("__QU_CONN__" +
-                    ipc::to_string(DataSize) + "__" +
-                    ipc::to_string(AlignSize) + "__" + name).c_str()} {
-        }
-
-        void disconnect_receiver() {
-            bool dis = que_.disconnect();
-            this->quit_waiting();
-            if (dis) {
-                this->recv_cache().clear();
-            }
-        }
-    };
-};
-
-template <typename Policy>
-struct detail_impl {
-
-using policy_t    = Policy;
-using flag_t      = typename policy_t::flag_t;
-using queue_t     = typename queue_generator<policy_t>::queue_t;
-using conn_info_t = typename queue_generator<policy_t>::conn_info_t;
-
-constexpr static conn_info_t* info_of(ipc::handle_t h) noexcept {
-    return static_cast<conn_info_t*>(h);
-}
-
-constexpr static queue_t* queue_of(ipc::handle_t h) noexcept {
-    return (info_of(h) == nullptr) ? nullptr : &(info_of(h)->que_);
-}
-
-/* API implementations */
-
-static void disconnect(ipc::handle_t h) {
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        return;
-    }
-    que->shut_sending();
-    assert(info_of(h) != nullptr);
-    info_of(h)->disconnect_receiver();
-}
-
-static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
-    assert(ph != nullptr);
-    assert(*ph != nullptr);
-    auto que = queue_of(*ph);
-    if (que == nullptr) {
-        return false;
-    }
-    if (start_to_recv) {
-        que->shut_sending();
-        if (que->connect()) { // wouldn't connect twice
-            info_of(*ph)->cc_waiter_.broadcast();
-            return true;
-        }
-        return false;
-    }
-    // start_to_recv == false
-    if (que->connected()) {
-        info_of(*ph)->disconnect_receiver();
-    }
-    return que->ready_sending();
-}
-
-static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
-    assert(ph != nullptr);
-    if (*ph == nullptr) {
-        *ph = ipc::mem::alloc<conn_info_t>(name);
-    }
-    return reconnect(ph, start_to_recv);
-}
-
-static void destroy(ipc::handle_t h) {
-    disconnect(h);
-    ipc::mem::free(info_of(h));
-}
-
-static std::size_t recv_count(ipc::handle_t h) noexcept {
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        return ipc::invalid_value;
-    }
-    return que->conn_count();
-}
-
-static bool wait_for_recv(ipc::handle_t h, std::size_t r_count, std::uint64_t tm) {
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        return false;
-    }
-    return wait_for(info_of(h)->cc_waiter_, [que, r_count] {
-        return que->conn_count() < r_count;
-    }, tm);
-}
-
-template <typename F>
-static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t size) {
-    if (data == nullptr || size == 0) {
-        ipc::error("fail: send(%p, %zd)\n", data, size);
-        return false;
-    }
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        ipc::error("fail: send, queue_of(h) == nullptr\n");
-        return false;
-    }
-    if (que->elems() == nullptr) {
-        ipc::error("fail: send, queue_of(h)->elems() == nullptr\n");
-        return false;
-    }
-    if (!que->ready_sending()) {
-        ipc::error("fail: send, que->ready_sending() == false\n");
-        return false;
-    }
-    ipc::circ::cc_t conns = que->elems()->connections(std::memory_order_relaxed);
-    if (conns == 0) {
-        ipc::error("fail: send, there is no receiver on this connection.\n");
-        return false;
-    }
-    // calc a new message id
-    auto acc = info_of(h)->acc();
-    if (acc == nullptr) {
-        ipc::error("fail: send, info_of(h)->acc() == nullptr\n");
-        return false;
-    }
-    auto msg_id   = acc->fetch_add(1, std::memory_order_relaxed);
-    auto try_push = std::forward<F>(gen_push)(info_of(h), que, msg_id);
-    if (size > ipc::large_msg_limit) {
-        auto   dat = acquire_storage(size, conns);
-        void * buf = dat.second;
-        if (buf != nullptr) {
-            std::memcpy(buf, data, size);
-            return try_push(static_cast<std::int32_t>(size) - 
-                            static_cast<std::int32_t>(ipc::data_length), &(dat.first), 0);
-        }
-        // try using message fragment
-        //ipc::log("fail: shm::handle for big message. msg_id: %zd, size: %zd\n", msg_id, size);
-    }
-    // push message fragment
-    std::int32_t offset = 0;
-    for (std::int32_t i = 0; i < static_cast<std::int32_t>(size / ipc::data_length); ++i, offset += ipc::data_length) {
-        if (!try_push(static_cast<std::int32_t>(size) - offset - static_cast<std::int32_t>(ipc::data_length),
-                      static_cast<ipc::byte_t const *>(data) + offset, ipc::data_length)) {
-            return false;
-        }
-    }
-    // if remain > 0, this is the last message fragment
-    std::int32_t remain = static_cast<std::int32_t>(size) - offset;
-    if (remain > 0) {
-        if (!try_push(remain - static_cast<std::int32_t>(ipc::data_length),
-                      static_cast<ipc::byte_t const *>(data) + offset, 
-                      static_cast<std::size_t>(remain))) {
-            return false;
-        }
-    }
-    return true;
-}
-
-static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
-    return send([tm](auto info, auto que, auto msg_id) {
-        return [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
-            if (!wait_for(info->wt_waiter_, [&] {
-                    return !que->push(
-                        [](void*) { return true; },
-                        info->cc_id_, msg_id, remain, data, size);
-                }, tm)) {
-                return false;
-            }
-            info->rd_waiter_.broadcast();
-            return true;
-        };
-    }, h, data, size);
-}
-
-static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        ipc::error("fail: recv, queue_of(h) == nullptr\n");
-        return {};
-    }
-    if (!que->connected()) {
-        // hasn't connected yet, just return.
-        return {};
-    }
-    auto& rc = info_of(h)->recv_cache();
-    for (;;) {
-        // pop a new message
-        typename queue_t::value_t msg;
-        if (!wait_for(info_of(h)->rd_waiter_, [que, &msg] {
-                return !que->pop(msg);
-            }, tm)) {
-            // pop failed, just return.
-            return {};
-        }
-        info_of(h)->wt_waiter_.broadcast();
-        if ((info_of(h)->acc() != nullptr) && (msg.cc_id_ == info_of(h)->cc_id_)) {
-            continue; // ignore message to self
-        }
-        // msg.remain_ may minus & abs(msg.remain_) < data_length
-        std::int32_t r_size = static_cast<std::int32_t>(ipc::data_length) + msg.remain_;
-        if (r_size <= 0) {
-            ipc::error("fail: recv, r_size = %d\n", (int)r_size);
-            return {};
-        }
-        std::size_t msg_size = static_cast<std::size_t>(r_size);
-        // large message
-        if (msg.storage_) {
-            ipc::storage_id_t buf_id = *reinterpret_cast<ipc::storage_id_t*>(&msg.data_);
-            void* buf = find_storage(buf_id, msg_size);
-            if (buf != nullptr) {
-                struct recycle_t {
-                    ipc::storage_id_t storage_id;
-                    ipc::circ::cc_t   curr_conns;
-                    ipc::circ::cc_t   conn_id;
-                } *r_info = ipc::mem::alloc<recycle_t>(recycle_t{
-                    buf_id, que->elems()->connections(std::memory_order_relaxed), que->connected_id()
-                });
-                if (r_info == nullptr) {
-                    ipc::log("fail: ipc::mem::alloc<recycle_t>.\n");
-                    return ipc::buff_t{buf, msg_size}; // no recycle
-                } else {
-                    return ipc::buff_t{buf, msg_size, [](void* p_info, std::size_t size) {
-                        auto r_info = static_cast<recycle_t *>(p_info);
-                        IPC_UNUSED_ auto finally = ipc::guard([r_info] {
-                            ipc::mem::free(r_info);
-                        });
-                        recycle_storage<flag_t>(r_info->storage_id, size, r_info->curr_conns, r_info->conn_id);
-                    }, r_info};
-                }
-            } else {
-                ipc::log("fail: shm::handle for large message. msg_id: %zd, buf_id: %zd, size: %zd\n", msg.id_, buf_id, msg_size);
-                continue;
-            }
-        }
-        // find cache with msg.id_
-        auto cac_it = rc.find(msg.id_);
-        if (cac_it == rc.end()) {
-            if (msg_size <= ipc::data_length) {
-                return make_cache(msg.data_, msg_size);
-            }
-            // gc
-            if (rc.size() > 1024) {
-                std::vector<msg_id_t> need_del;
-                for (auto const & pair : rc) {
-                    auto cmp = std::minmax(msg.id_, pair.first);
-                    if (cmp.second - cmp.first > 8192) {
-                        need_del.push_back(pair.first);
-                    }
-                }
-                for (auto id : need_del) rc.erase(id);
-            }
-            // cache the first message fragment
-            rc.emplace(msg.id_, cache_t { ipc::data_length, make_cache(msg.data_, msg_size) });
-        }
-        // has cached before this message
-        else {
-            auto& cac = cac_it->second;
-            // this is the last message fragment
-            if (msg.remain_ <= 0) {
-                cac.append(&(msg.data_), msg_size);
-                // finish this message, erase it from cache
-                auto buff = std::move(cac.buff_);
-                rc.erase(cac_it);
-                return buff;
-            }
-            // there are remain datas after this message
-            cac.append(&(msg.data_), ipc::data_length);
-        }
-    }
-}
-
-static ipc::buff_t try_recv(ipc::handle_t h) {
-    return recv(h, 0);
-}
-
-}; // detail_impl<Policy>
-
-template <typename Flag>
-using policy_t = ipc::policy::choose<ipc::circ::elem_array, Flag>;
-
-} // internal-linkage
-
-namespace ipc {
-
-template <typename Flag>
-bool chan_impl<Flag>::connect(ipc::handle_t * ph, char const * name, unsigned mode) {
-    return detail_impl<policy_t<Flag>>::connect(ph, name, mode & receiver);
-}
-
-template <typename Flag>
-bool chan_impl<Flag>::reconnect(ipc::handle_t * ph, unsigned mode) {
-    return detail_impl<policy_t<Flag>>::reconnect(ph, mode & receiver);
-}
-
-template <typename Flag>
-void chan_impl<Flag>::disconnect(ipc::handle_t h) {
-    detail_impl<policy_t<Flag>>::disconnect(h);
-}
-
-template <typename Flag>
-void chan_impl<Flag>::destroy(ipc::handle_t h) {
-    detail_impl<policy_t<Flag>>::destroy(h);
-}
-
-template <typename Flag>
-char const * chan_impl<Flag>::name(ipc::handle_t h) {
-    auto info = detail_impl<policy_t<Flag>>::info_of(h);
-    return (info == nullptr) ? nullptr : info->name_.c_str();
-}
-
-template <typename Flag>
-std::size_t chan_impl<Flag>::recv_count(ipc::handle_t h) {
-    return detail_impl<policy_t<Flag>>::recv_count(h);
-}
-
-template <typename Flag>
-bool chan_impl<Flag>::wait_for_recv(ipc::handle_t h, std::size_t r_count, std::uint64_t tm) {
-    return detail_impl<policy_t<Flag>>::wait_for_recv(h, r_count, tm);
-}
-
-template <typename Flag>
-bool chan_impl<Flag>::send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
-    return detail_impl<policy_t<Flag>>::send(h, data, size, tm);
-}
-
-template <typename Flag>
-buff_t chan_impl<Flag>::recv(ipc::handle_t h, std::uint64_t tm) {
-    return detail_impl<policy_t<Flag>>::recv(h, tm);
-}
-
-template <typename Flag>
-buff_t chan_impl<Flag>::try_recv(ipc::handle_t h) {
-    return detail_impl<policy_t<Flag>>::try_recv(h);
-}
-
-template struct chan_impl<ipc::wr<relat::single, relat::single, trans::unicast  >>;
-// template struct chan_impl<ipc::wr<relat::single, relat::multi , trans::unicast  >>; // TBD
-// template struct chan_impl<ipc::wr<relat::multi , relat::multi , trans::unicast  >>; // TBD
-template struct chan_impl<ipc::wr<relat::single, relat::multi , trans::broadcast>>;
-template struct chan_impl<ipc::wr<relat::multi , relat::multi , trans::broadcast>>;
-
-} // namespace ipc
+#include "libipc/def.h"
\ No newline at end of file
diff --git a/src/libipc/memory/alloc.h b/src/libipc/memory/alloc.h
deleted file mode 100755
index 16bebc9..0000000
--- a/src/libipc/memory/alloc.h
+++ /dev/null
@@ -1,424 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <utility>
-#include <iterator>
-#include <limits>       // std::numeric_limits
-#include <cstdlib>
-#include <cassert>      // assert
-
-#include "libipc/def.h"
-#include "libipc/rw_lock.h"
-
-#include "libipc/utility/concept.h"
-#include "libipc/memory/allocator_wrapper.h"
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-namespace mem {
-
-class static_alloc {
-public:
-    static void swap(static_alloc&) {}
-
-    static void* alloc(std::size_t size) {
-        return size ? std::malloc(size) : nullptr;
-    }
-
-    static void free(void* p) {
-        std::free(p);
-    }
-
-    static void free(void* p, std::size_t /*size*/) {
-        free(p);
-    }
-};
-
-////////////////////////////////////////////////////////////////
-/// Scope allocation -- The destructor will release all allocated blocks.
-////////////////////////////////////////////////////////////////
-
-namespace detail {
-
-constexpr std::size_t aligned(std::size_t size, size_t alignment) noexcept {
-    return ( (size - 1) & ~(alignment - 1) ) + alignment;
-}
-
-IPC_CONCEPT_(has_take, take(std::move(std::declval<Type>())));
-
-class scope_alloc_base {
-protected:
-    struct block_t {
-        std::size_t size_;
-        block_t   * next_;
-    } * head_ = nullptr, * tail_ = nullptr;
-
-    enum : std::size_t {
-        aligned_block_size = aligned(sizeof(block_t), alignof(std::max_align_t))
-    };
-
-public:
-    void swap(scope_alloc_base & rhs) {
-        std::swap(head_, rhs.head_);
-        std::swap(tail_, rhs.tail_);
-    }
-
-    bool empty() const noexcept {
-        return head_ == nullptr;
-    }
-
-    void take(scope_alloc_base && rhs) {
-        if (rhs.empty()) return;
-        if (empty()) swap(rhs);
-        else {
-            std::swap(tail_->next_, rhs.head_);
-            // rhs.head_ should be nullptr here
-            tail_ = rhs.tail_;
-            rhs.tail_ = nullptr;
-        }
-    }
-
-    void free(void* /*p*/) {}
-    void free(void* /*p*/, std::size_t) {}
-};
-
-} // namespace detail
-
-template <typename AllocP = static_alloc>
-class scope_alloc : public detail::scope_alloc_base {
-public:
-    using base_t = detail::scope_alloc_base;
-    using alloc_policy = AllocP;
-
-private:
-    alloc_policy alloc_;
-
-    void free_all() {
-        while (!empty()) {
-            auto curr = head_;
-            head_ = head_->next_;
-            alloc_.free(curr, curr->size_);
-        }
-        // now head_ is nullptr
-    }
-
-public:
-    scope_alloc() = default;
-
-    scope_alloc(scope_alloc && rhs)         { swap(rhs); }
-    scope_alloc& operator=(scope_alloc rhs) { swap(rhs); return (*this); }
-
-    ~scope_alloc() { free_all(); }
-
-    void swap(scope_alloc& rhs) {
-        alloc_.swap(rhs.alloc_);
-        base_t::swap(rhs);
-    }
-
-    template <typename A = AllocP>
-    auto take(scope_alloc && rhs) -> ipc::require<detail::has_take<A>::value> {
-        base_t::take(std::move(rhs));
-        alloc_.take(std::move(rhs.alloc_));
-    }
-
-    template <typename A = AllocP>
-    auto take(scope_alloc && rhs) -> ipc::require<!detail::has_take<A>::value> {
-        base_t::take(std::move(rhs));
-    }
-
-    void* alloc(std::size_t size) {
-        std::size_t real_size = aligned_block_size + size;
-        auto curr = static_cast<block_t*>(alloc_.alloc(real_size));
-        curr->size_ = real_size;
-        curr->next_ = head_;
-        head_ = curr;
-        if (tail_ == nullptr) {
-            tail_ = curr;
-        }
-        return (reinterpret_cast<byte_t*>(curr) + aligned_block_size);
-    }
-};
-
-////////////////////////////////////////////////////////////////
-/// Fixed-size blocks allocation
-////////////////////////////////////////////////////////////////
-
-namespace detail {
-
-class fixed_alloc_base {
-protected:
-    std::size_t block_size_;
-    std::size_t init_expand_;
-    void      * cursor_;
-
-    void init(std::size_t block_size, std::size_t init_expand) {
-        block_size_  = block_size;
-        init_expand_ = init_expand;
-        cursor_      = nullptr;
-    }
-
-    static void** node_p(void* node) {
-        return reinterpret_cast<void**>(node);
-    }
-
-    static auto& next(void* node) {
-        return *node_p(node);
-    }
-
-public:
-    bool operator<(fixed_alloc_base const & right) const {
-        return init_expand_ < right.init_expand_;
-    }
-
-    void set_block_size(std::size_t block_size) {
-        block_size_ = block_size;
-    }
-
-    void swap(fixed_alloc_base& rhs) {
-        std::swap(block_size_ , rhs.block_size_);
-        std::swap(init_expand_, rhs.init_expand_);
-        std::swap(cursor_     , rhs.cursor_);
-    }
-
-    bool empty() const noexcept {
-        return cursor_ == nullptr;
-    }
-
-    void take(fixed_alloc_base && rhs) {
-        assert(block_size_ == rhs.block_size_);
-        init_expand_ = (ipc::detail::max)(init_expand_, rhs.init_expand_);
-        if (rhs.empty()) return;
-        auto curr = cursor_;
-        if (curr != nullptr) while (1) {
-            auto next_cur = next(curr);
-            if (next_cur == nullptr) {
-                std::swap(next(curr), rhs.cursor_);
-                return;
-            }
-            // next_cur != nullptr
-            else curr = next_cur;
-        }
-        // curr == nullptr, means cursor_ == nullptr
-        else std::swap(cursor_, rhs.cursor_);
-        // rhs.cursor_ must be nullptr
-    }
-
-    void free(void* p) {
-        if (p == nullptr) return;
-        next(p) = cursor_;
-        cursor_ = p;
-    }
-
-    void free(void* p, std::size_t) {
-        free(p);
-    }
-};
-
-template <typename AllocP, typename ExpandP>
-class fixed_alloc : public detail::fixed_alloc_base {
-public:
-    using base_t = detail::fixed_alloc_base;
-    using alloc_policy = AllocP;
-
-private:
-    alloc_policy alloc_;
-
-    void* try_expand() {
-        if (empty()) {
-            auto size = ExpandP::next(block_size_, init_expand_);
-            auto p = node_p(cursor_ = alloc_.alloc(size));
-            for (std::size_t i = 0; i < (size / block_size_) - 1; ++i)
-                p = node_p((*p) = reinterpret_cast<byte_t*>(p) + block_size_);
-            (*p) = nullptr;
-        }
-        return cursor_;
-    }
-
-public:
-    explicit fixed_alloc(std::size_t block_size, std::size_t init_expand = 1) {
-        init(block_size, init_expand);
-    }
-
-    fixed_alloc(fixed_alloc && rhs) {
-        init(0, 0);
-        swap(rhs);
-    }
-
-    fixed_alloc& operator=(fixed_alloc rhs) {
-        swap(rhs);
-        return (*this);
-    }
-
-    void swap(fixed_alloc& rhs) {
-        alloc_.swap(rhs.alloc_);
-        base_t::swap(rhs);
-    }
-
-    template <typename A = AllocP>
-    auto take(fixed_alloc && rhs) -> ipc::require<detail::has_take<A>::value> {
-        base_t::take(std::move(rhs));
-        alloc_.take(std::move(rhs.alloc_));
-    }
-
-    void* alloc() {
-        void* p = try_expand();
-        cursor_ = next(p);
-        return p;
-    }
-
-    void* alloc(std::size_t) {
-        return alloc();
-    }
-};
-
-} // namespace detail
-
-template <std::size_t BaseSize  = sizeof(void*) * 1024, 
-          std::size_t LimitSize = (std::numeric_limits<std::uint32_t>::max)()>
-struct fixed_expand_policy {
-
-    enum : std::size_t {
-        base_size  = BaseSize,
-        limit_size = LimitSize
-    };
-
-    constexpr static std::size_t prev(std::size_t e) noexcept {
-        return ((e / 2) == 0) ? 1 : (e / 2);
-    }
-
-    constexpr static std::size_t next(std::size_t e) noexcept {
-        return e * 2;
-    }
-
-    static std::size_t next(std::size_t block_size, std::size_t & e) {
-        auto n = ipc::detail::max<std::size_t>(block_size, base_size) * e;
-             e = ipc::detail::min<std::size_t>(limit_size, next(e));
-        return n;
-    }
-};
-
-template <std::size_t BlockSize,
-          typename AllocP  = scope_alloc<>,
-          typename ExpandP = fixed_expand_policy<>>
-class fixed_alloc : public detail::fixed_alloc<AllocP, ExpandP> {
-public:
-    using base_t = detail::fixed_alloc<AllocP, ExpandP>;
-
-    enum : std::size_t {
-        block_size = ipc::detail::max<std::size_t>(BlockSize, sizeof(void*))
-    };
-
-public:
-    explicit fixed_alloc(std::size_t init_expand)
-        : base_t(block_size, init_expand) {
-    }
-
-    fixed_alloc() : fixed_alloc(1) {}
-
-    fixed_alloc(fixed_alloc && rhs)
-        : base_t(std::move(rhs)) {
-    }
-
-    fixed_alloc& operator=(fixed_alloc rhs) {
-        swap(rhs);
-        return (*this);
-    }
-
-    void swap(fixed_alloc& rhs) {
-        base_t::swap(rhs);
-    }
-};
-
-////////////////////////////////////////////////////////////////
-/// Variable-size blocks allocation (without alignment)
-////////////////////////////////////////////////////////////////
-
-namespace detail {
-
-class variable_alloc_base {
-protected:
-    byte_t * head_ = nullptr, * tail_ = nullptr;
-
-public:
-    void swap(variable_alloc_base & rhs) {
-        std::swap(head_, rhs.head_);
-        std::swap(tail_, rhs.tail_);
-    }
-
-    std::size_t remain() const noexcept {
-        return static_cast<std::size_t>(tail_ - head_);
-    }
-
-    bool empty() const noexcept {
-        return remain() == 0;
-    }
-
-    void take(variable_alloc_base && rhs) {
-        if (remain() < rhs.remain()) {
-            // replace this by rhs
-            head_ = rhs.head_;
-            tail_ = rhs.tail_;
-        }
-        // discard rhs
-        rhs.head_ = rhs.tail_ = nullptr;
-    }
-
-    void free(void* /*p*/) {}
-    void free(void* /*p*/, std::size_t) {}
-};
-
-} // namespace detail
-
-template <std::size_t ChunkSize = (sizeof(void*) * 1024), typename AllocP = scope_alloc<>>
-class variable_alloc : public detail::variable_alloc_base {
-public:
-    using base_t       = detail::variable_alloc_base;
-    using alloc_policy = AllocP;
-
-    enum : std::size_t {
-        aligned_chunk_size = detail::aligned(ChunkSize, alignof(std::max_align_t))
-    };
-
-private:
-    alloc_policy alloc_;
-
-public:
-    variable_alloc() = default;
-
-    variable_alloc(variable_alloc && rhs)         { swap(rhs); }
-    variable_alloc& operator=(variable_alloc rhs) { swap(rhs); return (*this); }
-
-    void swap(variable_alloc& rhs) {
-        alloc_.swap(rhs.alloc_);
-        base_t::swap(rhs);
-    }
-
-    template <typename A = AllocP>
-    auto take(variable_alloc && rhs) -> ipc::require<detail::has_take<A>::value> {
-        base_t::take(std::move(rhs));
-        alloc_.take(std::move(rhs.alloc_));
-    }
-
-    void* alloc(std::size_t size) {
-        /*
-         * byte alignment is always alignof(std::max_align_t).
-        */
-        size = detail::aligned(size, alignof(std::max_align_t));
-        void* ptr;
-        // size would never be 0 here
-        if (remain() < size) {
-            std::size_t chunk_size = ipc::detail::max<std::size_t>(aligned_chunk_size, size);
-            ptr   = alloc_.alloc(chunk_size);
-            tail_ = static_cast<byte_t*>(ptr) + chunk_size;
-            head_ = tail_ - (chunk_size - size);
-        }
-        else {
-            ptr   = head_;
-            head_ += size;
-        }
-        return ptr;
-    }
-};
-
-} // namespace mem
-} // namespace ipc
diff --git a/src/libipc/memory/allocator_wrapper.h b/src/libipc/memory/allocator_wrapper.h
deleted file mode 100755
index d1c3ea3..0000000
--- a/src/libipc/memory/allocator_wrapper.h
+++ /dev/null
@@ -1,121 +0,0 @@
-#pragma once
-
-#include <limits>   // std::numeric_limits
-#include <utility>  // std::forward
-#include <cstddef>
-
-#include "libipc/pool_alloc.h"
-
-namespace ipc {
-namespace mem {
-
-////////////////////////////////////////////////////////////////
-/// The allocator wrapper class for STL
-////////////////////////////////////////////////////////////////
-
-namespace detail {
-
-template <typename T, typename AllocP>
-struct rebind {
-    template <typename U>
-    using alloc_t = AllocP;
-};
-
-template <typename T, template <typename> class AllocT>
-struct rebind<T, AllocT<T>> {
-    template <typename U>
-    using alloc_t = AllocT<U>;
-};
-
-} // namespace detail
-
-template <typename T, typename AllocP>
-class allocator_wrapper {
-
-    template <typename U, typename AllocU>
-    friend class allocator_wrapper;
-
-public:
-    // type definitions
-    typedef T                 value_type;
-    typedef value_type*       pointer;
-    typedef const value_type* const_pointer;
-    typedef value_type&       reference;
-    typedef const value_type& const_reference;
-    typedef std::size_t       size_type;
-    typedef std::ptrdiff_t    difference_type;
-    typedef AllocP            alloc_policy;
-
-private:
-    alloc_policy alloc_;
-
-public:
-    allocator_wrapper() noexcept {}
-
-    // construct by copying (do nothing)
-    allocator_wrapper           (const allocator_wrapper<T, AllocP>&) noexcept {}
-    allocator_wrapper& operator=(const allocator_wrapper<T, AllocP>&) noexcept { return *this; }
-	
-    // construct from a related allocator (do nothing)
-    template <typename U, typename AllocU> allocator_wrapper           (const allocator_wrapper<U, AllocU>&) noexcept {}
-    template <typename U, typename AllocU> allocator_wrapper& operator=(const allocator_wrapper<U, AllocU>&) noexcept { return *this; }
-
-    allocator_wrapper           (allocator_wrapper && rhs) noexcept : alloc_ ( std::move(rhs.alloc_) ) {}
-    allocator_wrapper& operator=(allocator_wrapper && rhs) noexcept { alloc_ = std::move(rhs.alloc_); return *this; }
-
-public:
-    // the other type of std_allocator
-    template <typename U>
-    struct rebind { 
-        using other = allocator_wrapper< U, typename detail::rebind<T, AllocP>::template alloc_t<U> >;
-    };
-
-    constexpr size_type max_size(void) const noexcept {
-        return (std::numeric_limits<size_type>::max)() / sizeof(value_type);
-    }
-
-public:
-    pointer allocate(size_type count) noexcept {
-        if (count == 0) return nullptr;
-        if (count > this->max_size()) return nullptr;
-        return static_cast<pointer>(alloc_.alloc(count * sizeof(value_type)));
-    }
-
-    void deallocate(pointer p, size_type count) noexcept {
-        alloc_.free(p, count * sizeof(value_type));
-    }
-
-    template <typename... P>
-    static void construct(pointer p, P && ... params) {
-        ipc::mem::construct(p, std::forward<P>(params)...);
-    }
-
-    static void destroy(pointer p) {
-        ipc::mem::destruct(p);
-    }
-};
-
-template <class AllocP>
-class allocator_wrapper<void, AllocP> {
-public:
-    // type definitions
-    typedef void              value_type;
-    typedef value_type*       pointer;
-    typedef const value_type* const_pointer;
-    typedef std::size_t       size_type;
-    typedef std::ptrdiff_t    difference_type;
-    typedef AllocP            alloc_policy;
-};
-
-template <typename T, typename U, class AllocP>
-constexpr bool operator==(const allocator_wrapper<T, AllocP>&, const allocator_wrapper<U, AllocP>&) noexcept {
-    return true;
-}
-
-template <typename T, typename U, class AllocP>
-constexpr bool operator!=(const allocator_wrapper<T, AllocP>&, const allocator_wrapper<U, AllocP>&) noexcept {
-    return false;
-}
-
-} // namespace mem
-} // namespace ipc
diff --git a/src/libipc/memory/resource.h b/src/libipc/memory/resource.h
deleted file mode 100755
index 38b6fb6..0000000
--- a/src/libipc/memory/resource.h
+++ /dev/null
@@ -1,90 +0,0 @@
-#pragma once
-
-#include <type_traits>
-#include <limits>
-#include <utility>
-#include <functional>
-#include <unordered_map>
-#include <map>
-#include <string>
-#include <cstdio>
-
-#include "libipc/def.h"
-
-#include "libipc/memory/alloc.h"
-#include "libipc/memory/wrapper.h"
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-namespace mem {
-
-//using async_pool_alloc = static_wrapper<variable_wrapper<async_wrapper<
-//    detail::fixed_alloc<
-//        variable_alloc                           <sizeof(void*) * 1024 * 256>, 
-//        fixed_expand_policy<sizeof(void*) * 1024, sizeof(void*) * 1024 * 256>
-//    >, 
-//    default_recycler >>>;
-using async_pool_alloc = ipc::mem::static_alloc;
-
-template <typename T>
-using allocator = allocator_wrapper<T, async_pool_alloc>;
-
-} // namespace mem
-
-namespace {
-
-constexpr char const * pf(int)                { return "%d"  ; }
-constexpr char const * pf(long)               { return "%ld" ; }
-constexpr char const * pf(long long)          { return "%lld"; }
-constexpr char const * pf(unsigned int)       { return "%u"  ; }
-constexpr char const * pf(unsigned long)      { return "%lu" ; }
-constexpr char const * pf(unsigned long long) { return "%llu"; }
-constexpr char const * pf(float)              { return "%f"  ; }
-constexpr char const * pf(double)             { return "%f"  ; }
-constexpr char const * pf(long double)        { return "%Lf" ; }
-
-} // internal-linkage
-
-template <typename T>
-struct hash : public std::hash<T> {};
-
-template <typename Key, typename T>
-using unordered_map = std::unordered_map<
-    Key, T, ipc::hash<Key>, std::equal_to<Key>, ipc::mem::allocator<std::pair<Key const, T>>
->;
-
-template <typename Key, typename T>
-using map = std::map<
-    Key, T, std::less<Key>, ipc::mem::allocator<std::pair<Key const, T>>
->;
-
-template <typename Char>
-using basic_string = std::basic_string<
-    Char, std::char_traits<Char>, ipc::mem::allocator<Char>
->;
-
-using string  = basic_string<char>;
-using wstring = basic_string<wchar_t>;
-
-template <> struct hash<string> {
-    std::size_t operator()(string const &val) const noexcept {
-        return std::hash<char const *>{}(val.c_str());
-    }
-};
-
-template <> struct hash<wstring> {
-    std::size_t operator()(wstring const &val) const noexcept {
-        return std::hash<wchar_t const *>{}(val.c_str());
-    }
-};
-
-template <typename T>
-ipc::string to_string(T val) {
-    char buf[std::numeric_limits<T>::digits10 + 1] {};
-    if (std::snprintf(buf, sizeof(buf), pf(val), val) > 0) {
-        return buf;
-    }
-    return {};
-}
-
-} // namespace ipc
diff --git a/src/libipc/memory/wrapper.h b/src/libipc/memory/wrapper.h
deleted file mode 100755
index b0b7c58..0000000
--- a/src/libipc/memory/wrapper.h
+++ /dev/null
@@ -1,327 +0,0 @@
-#pragma once
-
-#include <tuple>
-#include <thread>
-#include <deque>        // std::deque
-#include <functional>   // std::function
-#include <utility>      // std::forward
-#include <cstddef>
-#include <cassert>      // assert
-#include <type_traits>  // std::aligned_storage_t
-
-#include "libipc/def.h"
-#include "libipc/rw_lock.h"
-#include "libipc/pool_alloc.h"
-
-#include "libipc/utility/concept.h"
-#include "libipc/memory/alloc.h"
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-namespace mem {
-
-////////////////////////////////////////////////////////////////
-/// Thread-safe allocation wrapper
-////////////////////////////////////////////////////////////////
-
-namespace detail {
-
-IPC_CONCEPT_(is_comparable, operator<(std::declval<Type>()));
-
-} // namespace detail
-
-template <typename AllocP, bool = detail::is_comparable<AllocP>::value>
-class limited_recycler;
-
-template <typename AllocP>
-class limited_recycler<AllocP, true> {
-public:
-    using alloc_policy = AllocP;
-
-protected:
-    std::deque<alloc_policy> master_allocs_;
-    ipc::spin_lock master_lock_;
-
-    template <typename F>
-    void take_first_do(F && pred) {
-        auto it = master_allocs_.begin();
-        pred(const_cast<alloc_policy&>(*it));
-        master_allocs_.erase(it);
-    }
-
-public:
-    void try_recover(alloc_policy & alc) {
-        IPC_UNUSED_ auto guard = ipc::detail::unique_lock(master_lock_);
-        if (master_allocs_.empty()) return;
-        take_first_do([&alc](alloc_policy & first) { alc.swap(first); });
-    }
-
-    void collect(alloc_policy && alc) {
-        IPC_UNUSED_ auto guard = ipc::detail::unique_lock(master_lock_);
-        if (master_allocs_.size() >= 32) {
-            take_first_do([](alloc_policy &) {}); // erase first
-        }
-        master_allocs_.emplace_back(std::move(alc));
-    }
-
-    IPC_CONSTEXPR_ auto try_replenish(alloc_policy&, std::size_t) noexcept {}
-};
-
-template <typename AllocP>
-class default_recycler : public limited_recycler<AllocP> {
-
-    IPC_CONCEPT_(has_remain, remain());
-    IPC_CONCEPT_(has_empty , empty());
-
-    template <typename A>
-    void try_fill(A & alc) {
-        IPC_UNUSED_ auto guard = ipc::detail::unique_lock(this->master_lock_);
-        if (this->master_allocs_.empty()) return;
-        this->take_first_do([&alc](alloc_policy & first) { alc.take(std::move(first)); });
-    }
-
-public:
-    using alloc_policy = typename limited_recycler<AllocP>::alloc_policy;
-
-    template <typename A = AllocP>
-    auto try_replenish(alloc_policy & alc, std::size_t size)
-        -> ipc::require<detail::has_take<A>::value && has_remain<A>::value> {
-        if (alc.remain() >= size) return;
-        this->try_fill(alc);
-    }
-
-    template <typename A = AllocP>
-    auto try_replenish(alloc_policy & alc, std::size_t /*size*/)
-        -> ipc::require<detail::has_take<A>::value && !has_remain<A>::value && has_empty<A>::value> {
-        if (!alc.empty()) return;
-        this->try_fill(alc);
-    }
-
-    template <typename A = AllocP>
-    auto try_replenish(alloc_policy & alc, std::size_t /*size*/)
-        -> ipc::require<!detail::has_take<A>::value && has_empty<A>::value> {
-        if (!alc.empty()) return;
-        this->try_recover(alc);
-    }
-
-    template <typename A = AllocP>
-    IPC_CONSTEXPR_ auto try_replenish(alloc_policy & /*alc*/, std::size_t /*size*/) noexcept
-        -> ipc::require<(!detail::has_take<A>::value || !has_remain<A>::value) && !has_empty<A>::value> {
-        // Do Nothing.
-    }
-};
-
-template <typename AllocP>
-class empty_recycler {
-public:
-    using alloc_policy = AllocP;
-
-    IPC_CONSTEXPR_ void try_recover(alloc_policy&)                noexcept {}
-    IPC_CONSTEXPR_ auto try_replenish(alloc_policy&, std::size_t) noexcept {}
-    IPC_CONSTEXPR_ void collect(alloc_policy&&)                   noexcept {}
-};
-
-template <typename AllocP,
-          template <typename> class RecyclerP = default_recycler>
-class async_wrapper {
-public:
-    using alloc_policy = AllocP;
-
-private:
-    RecyclerP<alloc_policy> recycler_;
-
-    class alloc_proxy : public AllocP {
-        async_wrapper * w_ = nullptr;
-
-    public:
-        alloc_proxy(alloc_proxy && rhs) = default;
-
-        template <typename ... P>
-        alloc_proxy(async_wrapper* w, P && ... pars)
-            : AllocP(std::forward<P>(pars) ...), w_(w) {
-            assert(w_ != nullptr);
-            w_->recycler_.try_recover(*this);
-        }
-
-        ~alloc_proxy() {
-            w_->recycler_.collect(std::move(*this));
-        }
-
-        auto alloc(std::size_t size) {
-            w_->recycler_.try_replenish(*this, size);
-            return AllocP::alloc(size);
-        }
-    };
-
-    friend class alloc_proxy;
-    using ref_t = alloc_proxy&;
-
-    std::function<ref_t()> get_alloc_;
-
-public:
-    template <typename ... P>
-    async_wrapper(P ... pars) {
-        get_alloc_ = [this, pars ...]()->ref_t {
-            thread_local alloc_proxy tls(pars ...);
-            return tls;
-        };
-    }
-
-    void* alloc(std::size_t size) {
-        return get_alloc_().alloc(size);
-    }
-
-    void free(void* p, std::size_t size) {
-        get_alloc_().free(p, size);
-    }
-};
-
-////////////////////////////////////////////////////////////////
-/// Thread-safe allocation wrapper (with spin_lock)
-////////////////////////////////////////////////////////////////
-
-template <typename AllocP, typename MutexT = ipc::spin_lock>
-class sync_wrapper {
-public:
-    using alloc_policy = AllocP;
-    using mutex_type   = MutexT;
-
-private:
-    mutex_type   lock_;
-    alloc_policy alloc_;
-
-public:
-    template <typename ... P>
-    sync_wrapper(P && ... pars)
-        : alloc_(std::forward<P>(pars) ...)
-    {}
-
-    void swap(sync_wrapper& rhs) {
-        IPC_UNUSED_ auto guard = ipc::detail::unique_lock(lock_);
-        alloc_.swap(rhs.alloc_);
-    }
-
-    void* alloc(std::size_t size) {
-        IPC_UNUSED_ auto guard = ipc::detail::unique_lock(lock_);
-        return alloc_.alloc(size);
-    }
-
-    void free(void* p, std::size_t size) {
-        IPC_UNUSED_ auto guard = ipc::detail::unique_lock(lock_);
-        alloc_.free(p, size);
-    }
-};
-
-////////////////////////////////////////////////////////////////
-/// Variable memory allocation wrapper
-////////////////////////////////////////////////////////////////
-
-template <std::size_t BaseSize = 0, std::size_t IterSize = sizeof(void*)>
-struct default_mapping_policy {
-
-    enum : std::size_t {
-        base_size    = BaseSize,
-        iter_size    = IterSize,
-        classes_size = 64
-    };
-
-    template <typename F, typename ... P>
-    IPC_CONSTEXPR_ static void foreach(F && f, P && ... params) {
-        for (std::size_t i = 0; i < classes_size; ++i) {
-            f(i, std::forward<P>(params)...);
-        }
-    }
-
-    IPC_CONSTEXPR_ static std::size_t block_size(std::size_t id) noexcept {
-        return (id < classes_size) ? (base_size + (id + 1) * iter_size) : 0;
-    }
-
-    template <typename F, typename D, typename ... P>
-    IPC_CONSTEXPR_ static auto classify(F && f, D && d, std::size_t size, P && ... params) {
-        std::size_t id = (size - base_size - 1) / iter_size;
-        return (id < classes_size) ? 
-            f(id, size, std::forward<P>(params)...) : 
-            d(size, std::forward<P>(params)...);
-    }
-};
-
-template <typename FixedAlloc,
-          typename DefaultAlloc = mem::static_alloc,
-          typename MappingP     = default_mapping_policy<>>
-class variable_wrapper {
-
-    struct initiator {
-
-        using falc_t = std::aligned_storage_t<sizeof(FixedAlloc), alignof(FixedAlloc)>;
-        falc_t arr_[MappingP::classes_size];
-
-        initiator() {
-            MappingP::foreach([](std::size_t id, falc_t * a) {
-                ipc::mem::construct(&initiator::at(a, id), MappingP::block_size(id));
-            }, arr_);
-        }
-
-        ~initiator() {
-            MappingP::foreach([](std::size_t id, falc_t * a) {
-                ipc::mem::destruct(&initiator::at(a, id));
-            }, arr_);
-        }
-
-        static FixedAlloc & at(falc_t * arr, std::size_t id) noexcept {
-            return reinterpret_cast<FixedAlloc&>(arr[id]);
-        }
-    } init_;
-
-    using falc_t = typename initiator::falc_t;
-
-public:
-    void swap(variable_wrapper & other) {
-        MappingP::foreach([](std::size_t id, falc_t * in, falc_t * ot) {
-            initiator::at(in, id).swap(initiator::at(ot, id));
-        }, init_.arr_, other.init_.arr_);
-    }
-
-    void* alloc(std::size_t size) {
-        return MappingP::classify([](std::size_t id, std::size_t size, falc_t * a) {
-            return initiator::at(a, id).alloc(size);
-        }, [](std::size_t size, falc_t *) {
-            return DefaultAlloc::alloc(size);
-        }, size, init_.arr_);
-    }
-
-    void free(void* p, std::size_t size) {
-        MappingP::classify([](std::size_t id, std::size_t size, void* p, falc_t * a) {
-            initiator::at(a, id).free(p, size);
-        }, [](std::size_t size, void* p, falc_t *) {
-            DefaultAlloc::free(p, size);
-        }, size, p, init_.arr_);
-    }
-};
-
-////////////////////////////////////////////////////////////////
-/// Static allocation wrapper
-////////////////////////////////////////////////////////////////
-
-template <typename AllocP>
-class static_wrapper {
-public:
-    using alloc_policy = AllocP;
-
-    static alloc_policy& instance() {
-        static alloc_policy alloc;
-        return alloc;
-    }
-
-    static void swap(static_wrapper&) {}
-
-    static void* alloc(std::size_t size) {
-        return instance().alloc(size);
-    }
-
-    static void free(void* p, std::size_t size) {
-        instance().free(p, size);
-    }
-};
-
-} // namespace mem
-} // namespace ipc
diff --git a/src/libipc/platform/detail.h b/src/libipc/platform/detail.h
deleted file mode 100755
index e93c1d2..0000000
--- a/src/libipc/platform/detail.h
+++ /dev/null
@@ -1,136 +0,0 @@
-#ifndef LIBIPC_SRC_PLATFORM_DETAIL_H_
-#define LIBIPC_SRC_PLATFORM_DETAIL_H_
-
-// detect platform
-
-#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__) || \
-    defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || \
-    defined(WINCE) || defined(_WIN32_WCE)
-#   define IPC_OS_WINDOWS_
-#elif defined(__linux__) || defined(__linux)
-#   define IPC_OS_LINUX_
-#elif defined(__QNX__)
-#   define IPC_OS_QNX_
-#elif defined(__APPLE__)
-#elif defined(__ANDROID__)
-// TBD
-#endif
-
-#if defined(__cplusplus)
-
-#include <memory>
-#include <mutex>
-#include <shared_mutex>
-#include <type_traits>
-#include <tuple>
-#include <algorithm>
-
-// pre-defined
-
-#ifdef IPC_UNUSED_
-#   error "IPC_UNUSED_ has been defined."
-#endif
-#ifdef IPC_FALLTHROUGH_
-#   error "IPC_FALLTHROUGH_ has been defined."
-#endif
-#ifdef IPC_STBIND_
-#   error "IPC_STBIND_ has been defined."
-#endif
-#ifdef IPC_CONSTEXPR_
-#   error "IPC_CONSTEXPR_ has been defined."
-#endif
-
-#if __cplusplus >= 201703L
-
-#define IPC_UNUSED_      [[maybe_unused]]
-#define IPC_FALLTHROUGH_ [[fallthrough]]
-#define IPC_STBIND_(A, B, ...) auto [A, B] = __VA_ARGS__
-#define IPC_CONSTEXPR_   constexpr
-
-#else /*__cplusplus < 201703L*/
-
-#if defined(_MSC_VER)
-#   define IPC_UNUSED_ __pragma(warning(suppress: 4100 4101 4189))
-#elif defined(__GNUC__)
-#   define IPC_UNUSED_ __attribute__((__unused__))
-#else
-#   define IPC_UNUSED_
-#endif
-
-#define IPC_FALLTHROUGH_
-
-#define IPC_STBIND_(A, B, ...)       \
-    auto tp___ = __VA_ARGS__         \
-    auto A     = std::get<0>(tp___); \
-    auto B     = std::get<1>(tp___)
-
-#define IPC_CONSTEXPR_ inline
-
-#endif/*__cplusplus < 201703L*/
-
-#if __cplusplus >= 201703L
-
-namespace std {
-
-// deduction guides for std::unique_ptr
-template <typename T>
-unique_ptr(T* p) -> unique_ptr<T>;
-template <typename T, typename D>
-unique_ptr(T* p, D&& d) -> unique_ptr<T, std::decay_t<D>>;
-
-} // namespace std
-
-namespace ipc {
-namespace detail {
-
-using std::unique_ptr;
-using std::unique_lock;
-using std::shared_lock;
-using std::max;
-using std::min;
-
-#else /*__cplusplus < 201703L*/
-
-namespace ipc {
-namespace detail {
-
-// deduction guides for std::unique_ptr
-template <typename T>
-constexpr auto unique_ptr(T* p) noexcept {
-    return std::unique_ptr<T> { p };
-}
-
-template <typename T, typename D>
-constexpr auto unique_ptr(T* p, D&& d) noexcept {
-    return std::unique_ptr<T, std::decay_t<D>> { p, std::forward<D>(d) };
-}
-
-// deduction guides for std::unique_lock
-template <typename T>
-constexpr auto unique_lock(T&& lc) noexcept {
-    return std::unique_lock<std::decay_t<T>> { std::forward<T>(lc) };
-}
-
-// deduction guides for std::shared_lock
-template <typename T>
-constexpr auto shared_lock(T&& lc) noexcept {
-    return std::shared_lock<std::decay_t<T>> { std::forward<T>(lc) };
-}
-
-template <typename T>
-constexpr const T& (max)(const T& a, const T& b) {
-    return (a < b) ? b : a;
-}
-
-template <typename T>
-constexpr const T& (min)(const T& a, const T& b) {
-    return (b < a) ? b : a;
-}
-
-#endif/*__cplusplus < 201703L*/
-
-} // namespace detail
-} // namespace ipc
-
-#endif // defined(__cplusplus)
-#endif // LIBIPC_SRC_PLATFORM_DETAIL_H_
\ No newline at end of file
diff --git a/src/libipc/platform/linux/a0/LICENSE b/src/libipc/platform/linux/a0/LICENSE
deleted file mode 100644
index cf1ab25..0000000
--- a/src/libipc/platform/linux/a0/LICENSE
+++ /dev/null
@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <http://unlicense.org>
diff --git a/src/libipc/platform/linux/a0/README.md b/src/libipc/platform/linux/a0/README.md
deleted file mode 100644
index 8aed9d7..0000000
--- a/src/libipc/platform/linux/a0/README.md
+++ /dev/null
@@ -1,213 +0,0 @@
-<h1 align="center">
-  <br>
-  <img src="https://raw.githubusercontent.com/alephzero/logo/master/rendered/alephzero.svg" width="256px">
-  <br>
-  AlephZero
-</h1>
-
-<h3 align="center">Simple, Robust, Fast IPC.</h3>
-
-<p align="center">
-  <a href="https://github.com/alephzero/alephzero/actions?query=workflow%3ACI"><img src="https://github.com/alephzero/alephzero/workflows/CI/badge.svg"></a>
-  <a href="https://codecov.io/gh/alephzero/alephzero"><img src="https://codecov.io/gh/alephzero/alephzero/branch/master/graph/badge.svg"></a>
-  <a href="https://alephzero.readthedocs.io/en/latest/?badge=latest"><img src="https://readthedocs.org/projects/alephzero/badge/?version=latest"></a>
-  <a href="http://unlicense.org"><img src="https://img.shields.io/badge/license-Unlicense-blue.svg"></a>
-</p>
-
-<p align="center">
-  <a href="#overview">Overview</a> •
-  <a href="#transport">Transport</a> •
-  <a href="#protocol">Protocol</a> •
-  <a href="#examples">Examples</a> •
-  <a href="#installation">Installation</a> •
-  <a href="#across-dockers">Across Dockers</a>
-</p>
-
-# Overview
-
-[Presentation from March 25, 2020](https://docs.google.com/presentation/d/12KE9UucjZPtpVnM1NljxOqBolBBKECWJdrCoE2yJaBw/edit#slide=id.p)
-
-AlephZero is a library for message based communication between programs running on the same machine.
-
-## Simple
-
-AlephZero's main goal is to be simple to use. Nothing is higher priority.
-
-There is no "master" process in between your nodes that is needed to do handshakes or exchanges of any kind. All you need is the topic name.
-
-See the <a href="#examples">Examples</a>.
-
-## Robust
-
-This is probably the main value of AlephZero, above similar libraries.
-
-AlephZero uses a lot of tricks to ensure the state of all channels is consistent, even when programs die. This includes double-buffering the state of the communication channel and [robustifying](https://man7.org/linux/man-pages/man3/pthread_mutexattr_setrobust.3.html) the locks and notification channels.
-
-## Fast
-
-AlephZero uses shared memory across multiple processes to read and write messages, minimizing the involvement of the kernel. The kernel only really gets involved in notifying a process that a new message exists, and for that we use futex (fast user-space mutex).
-
-TODO: Benchmarks
-
-# Transport
-
-AlephZero, at its core, is a simple allocator on top of a contiguous region of memory. Usually, shared-memory. The allocator of choice is a circular-linked-list, which is fast, simple, and sufficient for the protocol listed below. It also plays well with the robustness requirement.
-
-This has a number of implications. For one, this means that old messages are kept around until the space is needed. The oldest messages are always discarded before any more recent messages.
-
-# Protocol
-
-Rather than exposing the low-level transport directly, AlephZero provides a few higher level protocol:
-
-* <b>PubSub</b>: Broadcast published messages. Subscribers get notified.
-* <b>RPC</b>: Request-response.
-* <b>PRPC (Progressive RPC)</b>: Request-streaming response.
-* <b>Sessions</b>: Bi-directional channel of communication. Not yet implemented. Let me know if you want this.
-
-# Examples
-
-Many more example and an interactive experience can be found at: https://github.com/alephzero/playground
-
-For the curious, here are some simple snippets to get you started:
-
-To begin with, we need to include AlephZero:
-```cc
-#include <a0.h>
-```
-
-## PubSub
-
-You can have as many publisher and subscribers on the same topic as you wish. They just need to agree on the filename.
-
-```cc
-a0::Publisher p("my_pubsub_topic");
-p.pub("foo");
-```
-
-You just published `"foo"` to the `"my_pubsub_topic"`.
-
-To read those message, you can create a subscriber on the same topic:
-```cc
-a0::Subscriber sub(
-    "my_pubsub_topic",
-    A0_INIT_AWAIT_NEW,  // or MOST_RECENT or OLDEST
-    A0_ITER_NEWEST,     // or NEXT
-    [](a0::PacketView pkt_view) {
-      std::cout << "Got: " << pkt_view.payload() << std::endl;
-    });
-```
-The callback will trigger whenever a message is published.
-
-The `Subscriber` object spawns a thread that will read the topic and call the callback.
-
-The `A0_INIT` tells the subscriber where to start reading. 
-* `A0_INIT_AWAIT_NEW`: Start with messages published after the creation of the subscriber.
-* `A0_INIT_MOST_RECENT`: Start with the most recently published message. Useful for state and configuration. But be careful, this can be quite old!
-* `A0_INIT_OLDEST`: Topics keep a history of 16MB (unless configures otherwise). Start with the oldest thing still in there.
-
-The `A0_ITER` tells the subscriber how to continue reading messages. After each callback:
-* `A0_ITER_NEXT`: grab the sequentially next message. When you don't want to miss a thing.
-* `A0_ITER_NEWEST`: grab the newest available unread message. When you want to keep up with the firehose.
-
-```cc
-a0::SubscriberSync sub_sync(
-    "my_pubsub_topic",
-    A0_INIT_OLDEST, A0_ITER_NEXT);
-while (sub_sync.has_next()) {
-  auto pkt = sub_sync.next();
-  std::cout << "Got: " << pkt.payload() << std::endl;
-}
-```
-
-## RPC
-
-Create an `RpcServer`:
-
-```cc
-a0::RpcServer server(
-    "my_rpc_topic",
-    /* onrequest = */ [](a0::RpcRequest req) {
-        std::cout << "Got: " << req.pkt().payload() << std::endl;
-        req.reply("echo " + std::string(req.pkt().payload()));
-    },
-    /* oncancel = */ nullptr);
-```
-
-Create an `RpcClient`:
-
-```cc
-a0::RpcClient client("my_rpc_topic");
-client.send("client msg", [](a0::PacketView reply) {
-  std::cout << "Got: " << reply.payload() << std::endl;
-});
-```
-
-# Installation
-
-## Install From Source
-
-### Ubuntu Dependencies
-
-```sh
-apt install g++ make
-```
-
-### Alpine Dependencies
-
-```sh
-apk add g++ linux-headers make
-```
-
-### Download And Install
-
-```sh
-git clone https://github.com/alephzero/alephzero.git
-cd alephzero
-make install -j
-```
-
-## Install From Package
-
-Coming soon-ish. Let me know if you want this and I'll prioritize it. External support is much appreciated.
-
-## Integration
-
-### Command Line
-
-Add the following to g++ / clang commands.
-```sh
--L${libdir} -lalephzero -lpthread
-```
-
-### Package-cfg
-
-```sh
-pkg-config --cflags --libs alephzero
-```
-
-### CMake
-
-Coming soon-ish. Let me know if you want this and I'll prioritize it. External support is much appreciated.
-
-### Bazel
-
-Coming soon-ish. Let me know if you want this and I'll prioritize it.
-
-# Across Dockers
-
-For programs running across different dockers to be able to communicate, we need to have them match up on two flags: `--ipc` and `--pid`.
-
-* `--ipc` shares the `/dev/shm` filesystem. This is necessary to open the same file topics.
-* `--pid` shares the process id namespace. This is necessary for the locking and notification systems.
-
-In the simplest case, you can set them both to `host` and talk through the system's global `/dev/shm` and process id namespace.
-```sh
-docker run --ipc=host --pid=host --name=foo foo_image
-docker run --ipc=host --pid=host --name=bar bar_image
-```
-
-Or, you can mark one as `shareable` and have the others connect to it:
-```sh
-docker run --ipc=shareable --pid=shareable --name=foo foo_image
-docker run --ipc=container:foo --pid=container:foo --name=bar bar_image
-```
diff --git a/src/libipc/platform/linux/a0/atomic.h b/src/libipc/platform/linux/a0/atomic.h
deleted file mode 100644
index 09a26ff..0000000
--- a/src/libipc/platform/linux/a0/atomic.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifndef A0_SRC_ATOMIC_H
-#define A0_SRC_ATOMIC_H
-
-#include "a0/inline.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-A0_STATIC_INLINE
-void a0_barrier() {
-  // 'atomic_thread_fence' is not supported with ‘-fsanitize=thread’
-  __sync_synchronize();
-}
-
-#define a0_atomic_fetch_add(P, V) __atomic_fetch_add((P), (V), __ATOMIC_RELAXED)
-#define a0_atomic_add_fetch(P, V) __atomic_add_fetch((P), (V), __ATOMIC_RELAXED)
-
-#define a0_atomic_fetch_and(P, V) __atomic_fetch_and((P), (V), __ATOMIC_RELAXED)
-#define a0_atomic_and_fetch(P, V) __atomic_and_fetch((P), (V), __ATOMIC_RELAXED)
-
-#define a0_atomic_fetch_or(P, V) __atomic_fetch_or((P), (V), __ATOMIC_RELAXED)
-#define a0_atomic_or_fetch(P, V) __atomic_or_fetch((P), (V), __ATOMIC_RELAXED)
-
-#define a0_atomic_load(P) __atomic_load_n((P), __ATOMIC_RELAXED)
-#define a0_atomic_store(P, V) __atomic_store_n((P), (V), __ATOMIC_RELAXED)
-
-// TODO(lshamis): Switch from __sync to __atomic.
-#define a0_cas_val(P, OV, NV) __sync_val_compare_and_swap((P), (OV), (NV))
-#define a0_cas(P, OV, NV) __sync_bool_compare_and_swap((P), (OV), (NV))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // A0_SRC_ATOMIC_H
diff --git a/src/libipc/platform/linux/a0/clock.h b/src/libipc/platform/linux/a0/clock.h
deleted file mode 100644
index 7b2a88b..0000000
--- a/src/libipc/platform/linux/a0/clock.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef A0_SRC_CLOCK_H
-#define A0_SRC_CLOCK_H
-
-#include "a0/err.h"
-#include "a0/inline.h"
-
-#include <stdint.h>
-#include <time.h>
-
-#include "err_macro.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static const int64_t NS_PER_SEC = 1e9;
-
-typedef struct timespec timespec_t;
-
-A0_STATIC_INLINE
-a0_err_t a0_clock_now(clockid_t clk, timespec_t* out) {
-  A0_RETURN_SYSERR_ON_MINUS_ONE(clock_gettime(clk, out));
-  return A0_OK;
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_clock_add(timespec_t ts, int64_t add_nsec, timespec_t* out) {
-  out->tv_sec = ts.tv_sec + add_nsec / NS_PER_SEC;
-  out->tv_nsec = ts.tv_nsec + add_nsec % NS_PER_SEC;
-  if (out->tv_nsec >= NS_PER_SEC) {
-    out->tv_sec++;
-    out->tv_nsec -= NS_PER_SEC;
-  } else if (out->tv_nsec < 0) {
-    out->tv_sec--;
-    out->tv_nsec += NS_PER_SEC;
-  }
-
-  return A0_OK;
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_clock_convert(
-    clockid_t orig_clk,
-    timespec_t orig_ts,
-    clockid_t target_clk,
-    timespec_t* target_ts) {
-  timespec_t orig_now;
-  A0_RETURN_ERR_ON_ERR(a0_clock_now(orig_clk, &orig_now));
-  timespec_t target_now;
-  A0_RETURN_ERR_ON_ERR(a0_clock_now(target_clk, &target_now));
-
-  int64_t add_nsec = (orig_ts.tv_sec - orig_now.tv_sec) * NS_PER_SEC + (orig_ts.tv_nsec - orig_now.tv_nsec);
-  return a0_clock_add(target_now, add_nsec, target_ts);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // A0_SRC_CLOCK_H
diff --git a/src/libipc/platform/linux/a0/empty.h b/src/libipc/platform/linux/a0/empty.h
deleted file mode 100644
index 69fef8a..0000000
--- a/src/libipc/platform/linux/a0/empty.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef A0_EMPTY_H
-#define A0_EMPTY_H
-
-// Bah. Why is there no consistent way to zero initialize a struct?
-#ifdef __cplusplus
-#define A0_EMPTY \
-  {}
-#else
-#define A0_EMPTY \
-  { 0 }
-#endif
-
-#endif  // A0_EMPTY_H
diff --git a/src/libipc/platform/linux/a0/err.c b/src/libipc/platform/linux/a0/err.c
deleted file mode 100644
index a48b858..0000000
--- a/src/libipc/platform/linux/a0/err.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "a0/err.h"
-#include "a0/thread_local.h"
-
-#include <errno.h>
-#include <string.h>
-
-A0_THREAD_LOCAL int a0_err_syscode;
-A0_THREAD_LOCAL char a0_err_msg[1024];
-
-const char* a0_strerror(a0_err_t err) {
-  switch (err) {
-    case A0_OK: {
-      return strerror(0);
-    }
-    case A0_ERR_SYS: {
-      return strerror(a0_err_syscode);
-    }
-    case A0_ERR_CUSTOM_MSG: {
-      return a0_err_msg;
-    }
-    case A0_ERR_INVALID_ARG: {
-      return strerror(EINVAL);
-    }
-    case A0_ERR_RANGE: {
-      return "Index out of bounds";
-    }
-    case A0_ERR_AGAIN: {
-      return "Not available yet";
-    }
-    case A0_ERR_FRAME_LARGE: {
-      return "Frame size too large";
-    }
-    case A0_ERR_ITER_DONE: {
-      return "Done iterating";
-    }
-    case A0_ERR_NOT_FOUND: {
-      return "Not found";
-    }
-    case A0_ERR_BAD_PATH: {
-      return "Invalid path";
-    }
-    case A0_ERR_BAD_TOPIC: {
-      return "Invalid topic name";
-    }
-    default: {
-      break;
-    }
-  }
-  return "";
-}
diff --git a/src/libipc/platform/linux/a0/err.h b/src/libipc/platform/linux/a0/err.h
deleted file mode 100644
index 05b7007..0000000
--- a/src/libipc/platform/linux/a0/err.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef A0_ERR_H
-#define A0_ERR_H
-
-#include "a0/thread_local.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum a0_err_e {
-  A0_OK = 0,
-  A0_ERR_SYS = 1,
-  A0_ERR_CUSTOM_MSG = 2,
-  A0_ERR_INVALID_ARG = 3,
-  A0_ERR_RANGE = 4,
-  A0_ERR_AGAIN = 5,
-  A0_ERR_ITER_DONE = 6,
-  A0_ERR_NOT_FOUND = 7,
-  A0_ERR_FRAME_LARGE = 8,
-  A0_ERR_BAD_PATH = 9,
-  A0_ERR_BAD_TOPIC = 10,
-} a0_err_t;
-
-extern A0_THREAD_LOCAL int a0_err_syscode;
-extern A0_THREAD_LOCAL char a0_err_msg[1024];
-
-const char* a0_strerror(a0_err_t);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // A0_ERR_H
diff --git a/src/libipc/platform/linux/a0/err_macro.h b/src/libipc/platform/linux/a0/err_macro.h
deleted file mode 100644
index 6683efc..0000000
--- a/src/libipc/platform/linux/a0/err_macro.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef A0_SRC_ERR_MACRO_H
-#define A0_SRC_ERR_MACRO_H
-
-#include "a0/err.h"
-#include "a0/inline.h"
-
-#include <errno.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-A0_STATIC_INLINE
-a0_err_t A0_MAKE_SYSERR(int syserr) {
-  a0_err_syscode = syserr;
-  return A0_ERR_SYS;
-}
-
-A0_STATIC_INLINE
-int A0_SYSERR(a0_err_t err) {
-  return err == A0_ERR_SYS ? a0_err_syscode : 0;
-}
-
-A0_STATIC_INLINE_RECURSIVE
-a0_err_t A0_MAKE_MSGERR(const char* fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-  if (fmt) {
-    vsnprintf(a0_err_msg, sizeof(a0_err_msg), fmt, args);  // NOLINT(clang-analyzer-valist.Uninitialized): https://bugs.llvm.org/show_bug.cgi?id=41311
-    va_end(args);
-    return A0_ERR_CUSTOM_MSG;
-  }
-  va_end(args);
-  return A0_OK;
-}
-
-#define A0_RETURN_SYSERR_ON_MINUS_ONE(X) \
-  do {                                   \
-    if ((X) == -1) {                     \
-      a0_err_syscode = errno;            \
-      return A0_ERR_SYS;                 \
-    }                                    \
-  } while (0)
-
-#define A0_RETURN_ERR_ON_ERR(X) \
-  do {                          \
-    a0_err_t _err = (X);        \
-    if (_err) {                 \
-      return _err;              \
-    }                           \
-  } while (0)
-
-#endif  // A0_SRC_ERR_MACRO_H
diff --git a/src/libipc/platform/linux/a0/ftx.h b/src/libipc/platform/linux/a0/ftx.h
deleted file mode 100644
index d0d4c3d..0000000
--- a/src/libipc/platform/linux/a0/ftx.h
+++ /dev/null
@@ -1,111 +0,0 @@
-#ifndef A0_SRC_FTX_H
-#define A0_SRC_FTX_H
-
-#include "a0/err.h"
-#include "a0/inline.h"
-#include "a0/time.h"
-
-#include <limits.h>
-#include <linux/futex.h>
-#include <stdint.h>
-#include <syscall.h>
-#include <time.h>
-#include <unistd.h>
-
-#include "clock.h"
-#include "err_macro.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// FUTEX_WAIT and FUTEX_WAIT_REQUEUE_PI default to CLOCK_MONOTONIC,
-// but FUTEX_LOCK_PI always uses CLOCK_REALTIME.
-//
-// Until someone tells me otherwise, I assume this is bad decision making
-// and I will instead standardize all things on CLOCK_BOOTTIME.
-
-// Futex.
-// Operations rely on the address.
-// It should not be copied or moved.
-typedef uint32_t a0_ftx_t;
-
-A0_STATIC_INLINE
-a0_err_t a0_futex(a0_ftx_t* uaddr,
-                  int futex_op,
-                  int val,
-                  uintptr_t timeout_or_val2,
-                  a0_ftx_t* uaddr2,
-                  int val3) {
-  A0_RETURN_SYSERR_ON_MINUS_ONE(syscall(SYS_futex, uaddr, futex_op, val, timeout_or_val2, uaddr2, val3));
-  return A0_OK;
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_ftx_wait(a0_ftx_t* ftx, int confirm_val, const a0_time_mono_t* time_mono) {
-  if (!time_mono) {
-    return a0_futex(ftx, FUTEX_WAIT, confirm_val, 0, NULL, 0);
-  }
-
-  timespec_t ts_mono;
-  A0_RETURN_ERR_ON_ERR(a0_clock_convert(CLOCK_BOOTTIME, time_mono->ts, CLOCK_MONOTONIC, &ts_mono));
-  return a0_futex(ftx, FUTEX_WAIT, confirm_val, (uintptr_t)&ts_mono, NULL, 0);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_ftx_wake(a0_ftx_t* ftx, int cnt) {
-  return a0_futex(ftx, FUTEX_WAKE, cnt, 0, NULL, 0);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_ftx_signal(a0_ftx_t* ftx) {
-  return a0_ftx_wake(ftx, 1);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_ftx_broadcast(a0_ftx_t* ftx) {
-  return a0_ftx_wake(ftx, INT_MAX);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_ftx_lock_pi(a0_ftx_t* ftx, const a0_time_mono_t* time_mono) {
-  if (!time_mono) {
-    return a0_futex(ftx, FUTEX_LOCK_PI, 0, 0, NULL, 0);
-  }
-
-  timespec_t ts_wall;
-  A0_RETURN_ERR_ON_ERR(a0_clock_convert(CLOCK_BOOTTIME, time_mono->ts, CLOCK_REALTIME, &ts_wall));
-  return a0_futex(ftx, FUTEX_LOCK_PI, 0, (uintptr_t)&ts_wall, NULL, 0);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_ftx_trylock_pi(a0_ftx_t* ftx) {
-  return a0_futex(ftx, FUTEX_TRYLOCK_PI, 0, 0, NULL, 0);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_ftx_unlock_pi(a0_ftx_t* ftx) {
-  return a0_futex(ftx, FUTEX_UNLOCK_PI, 0, 0, NULL, 0);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_ftx_cmp_requeue_pi(a0_ftx_t* ftx, int confirm_val, a0_ftx_t* requeue_ftx, int max_requeue) {
-  return a0_futex(ftx, FUTEX_CMP_REQUEUE_PI, 1, max_requeue, requeue_ftx, confirm_val);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_ftx_wait_requeue_pi(a0_ftx_t* ftx, int confirm_val, const a0_time_mono_t* time_mono, a0_ftx_t* requeue_ftx) {
-  if (!time_mono) {
-    return a0_futex(ftx, FUTEX_WAIT_REQUEUE_PI, confirm_val, 0, requeue_ftx, 0);
-  }
-
-  timespec_t ts_mono;
-  A0_RETURN_ERR_ON_ERR(a0_clock_convert(CLOCK_BOOTTIME, time_mono->ts, CLOCK_MONOTONIC, &ts_mono));
-  return a0_futex(ftx, FUTEX_WAIT_REQUEUE_PI, confirm_val, (uintptr_t)&ts_mono, requeue_ftx, 0);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // A0_SRC_FTX_H
diff --git a/src/libipc/platform/linux/a0/inline.h b/src/libipc/platform/linux/a0/inline.h
deleted file mode 100644
index a605540..0000000
--- a/src/libipc/platform/linux/a0/inline.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef A0_INLINE_H
-#define A0_INLINE_H
-
-#define A0_STATIC_INLINE static inline __attribute__((always_inline))
-
-#define A0_STATIC_INLINE_RECURSIVE static inline
-
-#endif  // A0_INLINE_H
diff --git a/src/libipc/platform/linux/a0/mtx.c b/src/libipc/platform/linux/a0/mtx.c
deleted file mode 100644
index 00022b6..0000000
--- a/src/libipc/platform/linux/a0/mtx.c
+++ /dev/null
@@ -1,420 +0,0 @@
-#include "a0/err.h"
-#include "a0/inline.h"
-#include "a0/mtx.h"
-#include "a0/thread_local.h"
-#include "a0/tid.h"
-#include "a0/time.h"
-
-#include <errno.h>
-#include <limits.h>
-#include <linux/futex.h>
-#include <pthread.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <syscall.h>
-#include <time.h>
-#include <unistd.h>
-
-#include "atomic.h"
-#include "clock.h"
-#include "err_macro.h"
-#include "ftx.h"
-
-// TSAN is worth the pain of properly annotating our mutex.
-
-// clang-format off
-#if defined(__SANITIZE_THREAD__)
-  #define A0_TSAN_ENABLED
-#elif defined(__has_feature)
-  #if __has_feature(thread_sanitizer)
-    #define A0_TSAN_ENABLED
-  #endif
-#endif
-// clang-format on
-
-const unsigned __tsan_mutex_linker_init = 1 << 0;
-const unsigned __tsan_mutex_write_reentrant = 1 << 1;
-const unsigned __tsan_mutex_read_reentrant = 1 << 2;
-const unsigned __tsan_mutex_not_static = 1 << 8;
-const unsigned __tsan_mutex_read_lock = 1 << 3;
-const unsigned __tsan_mutex_try_lock = 1 << 4;
-const unsigned __tsan_mutex_try_lock_failed = 1 << 5;
-const unsigned __tsan_mutex_recursive_lock = 1 << 6;
-const unsigned __tsan_mutex_recursive_unlock = 1 << 7;
-
-#ifdef A0_TSAN_ENABLED
-
-void __tsan_mutex_create(void* addr, unsigned flags);
-void __tsan_mutex_destroy(void* addr, unsigned flags);
-void __tsan_mutex_pre_lock(void* addr, unsigned flags);
-void __tsan_mutex_post_lock(void* addr, unsigned flags, int recursion);
-int __tsan_mutex_pre_unlock(void* addr, unsigned flags);
-void __tsan_mutex_post_unlock(void* addr, unsigned flags);
-void __tsan_mutex_pre_signal(void* addr, unsigned flags);
-void __tsan_mutex_post_signal(void* addr, unsigned flags);
-void __tsan_mutex_pre_divert(void* addr, unsigned flags);
-void __tsan_mutex_post_divert(void* addr, unsigned flags);
-
-#else
-
-#define _u_ __attribute__((unused))
-
-A0_STATIC_INLINE void _u_ __tsan_mutex_create(_u_ void* addr, _u_ unsigned flags) {}
-A0_STATIC_INLINE void _u_ __tsan_mutex_destroy(_u_ void* addr, _u_ unsigned flags) {}
-A0_STATIC_INLINE void _u_ __tsan_mutex_pre_lock(_u_ void* addr, _u_ unsigned flags) {}
-A0_STATIC_INLINE void _u_ __tsan_mutex_post_lock(_u_ void* addr,
-                                                 _u_ unsigned flags,
-                                                 _u_ int recursion) {}
-A0_STATIC_INLINE int _u_ __tsan_mutex_pre_unlock(_u_ void* addr, _u_ unsigned flags) {
-  return 0;
-}
-A0_STATIC_INLINE void _u_ __tsan_mutex_post_unlock(_u_ void* addr, _u_ unsigned flags) {}
-A0_STATIC_INLINE void _u_ __tsan_mutex_pre_signal(_u_ void* addr, _u_ unsigned flags) {}
-A0_STATIC_INLINE void _u_ __tsan_mutex_post_signal(_u_ void* addr, _u_ unsigned flags) {}
-A0_STATIC_INLINE void _u_ __tsan_mutex_pre_divert(_u_ void* addr, _u_ unsigned flags) {}
-A0_STATIC_INLINE void _u_ __tsan_mutex_post_divert(_u_ void* addr, _u_ unsigned flags) {}
-
-#endif
-
-A0_THREAD_LOCAL bool a0_robust_init = false;
-
-A0_STATIC_INLINE
-void a0_robust_reset() {
-  a0_robust_init = 0;
-}
-
-A0_STATIC_INLINE
-void a0_robust_reset_atfork() {
-  pthread_atfork(NULL, NULL, &a0_robust_reset);
-}
-
-static pthread_once_t a0_robust_reset_atfork_once;
-
-typedef struct robust_list robust_list_t;
-typedef struct robust_list_head robust_list_head_t;
-
-A0_THREAD_LOCAL robust_list_head_t a0_robust_head;
-
-A0_STATIC_INLINE
-void robust_init() {
-  a0_robust_head.list.next = &a0_robust_head.list;
-  a0_robust_head.futex_offset = offsetof(a0_mtx_t, ftx);
-  a0_robust_head.list_op_pending = NULL;
-  syscall(SYS_set_robust_list, &a0_robust_head.list, sizeof(a0_robust_head));
-}
-
-A0_STATIC_INLINE
-void init_thread() {
-  if (a0_robust_init) {
-    return;
-  }
-
-  pthread_once(&a0_robust_reset_atfork_once, a0_robust_reset_atfork);
-  robust_init();
-  a0_robust_init = true;
-}
-
-A0_STATIC_INLINE
-void robust_op_start(a0_mtx_t* mtx) {
-  init_thread();
-  a0_robust_head.list_op_pending = (struct robust_list*)mtx;
-  a0_barrier();
-}
-
-A0_STATIC_INLINE
-void robust_op_end(a0_mtx_t* mtx) {
-  (void)mtx;
-  a0_barrier();
-  a0_robust_head.list_op_pending = NULL;
-}
-
-A0_STATIC_INLINE
-bool robust_is_head(a0_mtx_t* mtx) {
-  return mtx == (a0_mtx_t*)&a0_robust_head;
-}
-
-A0_STATIC_INLINE
-void robust_op_add(a0_mtx_t* mtx) {
-  a0_mtx_t* old_first = (a0_mtx_t*)a0_robust_head.list.next;
-
-  mtx->prev = (a0_mtx_t*)&a0_robust_head;
-  mtx->next = old_first;
-
-  a0_barrier();
-
-  a0_robust_head.list.next = (robust_list_t*)mtx;
-  if (!robust_is_head(old_first)) {
-    old_first->prev = mtx;
-  }
-}
-
-A0_STATIC_INLINE
-void robust_op_del(a0_mtx_t* mtx) {
-  a0_mtx_t* prev = mtx->prev;
-  a0_mtx_t* next = mtx->next;
-  prev->next = next;
-  if (!robust_is_head(next)) {
-    next->prev = prev;
-  }
-}
-
-A0_STATIC_INLINE
-uint32_t ftx_tid(a0_ftx_t ftx) {
-  return ftx & FUTEX_TID_MASK;
-}
-
-A0_STATIC_INLINE
-bool ftx_owner_died(a0_ftx_t ftx) {
-  return ftx & FUTEX_OWNER_DIED;
-}
-
-static const uint32_t FTX_NOTRECOVERABLE = FUTEX_TID_MASK | FUTEX_OWNER_DIED;
-
-A0_STATIC_INLINE
-bool ftx_notrecoverable(a0_ftx_t ftx) {
-  return (ftx & FTX_NOTRECOVERABLE) == FTX_NOTRECOVERABLE;
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_mtx_timedlock_robust(a0_mtx_t* mtx, const a0_time_mono_t* timeout) {
-  const uint32_t tid = a0_tid();
-
-  int syserr = EINTR;
-  while (syserr == EINTR) {
-    // Can't lock if borked.
-    if (ftx_notrecoverable(a0_atomic_load(&mtx->ftx))) {
-      return A0_MAKE_SYSERR(ENOTRECOVERABLE);
-    }
-
-    // Try to lock without kernel involvement.
-    if (a0_cas(&mtx->ftx, 0, tid)) {
-      return A0_OK;
-    }
-
-    // Ask the kernel to lock.
-    syserr = A0_SYSERR(a0_ftx_lock_pi(&mtx->ftx, timeout));
-  }
-
-  if (!syserr) {
-    if (ftx_owner_died(a0_atomic_load(&mtx->ftx))) {
-      return A0_MAKE_SYSERR(EOWNERDEAD);
-    }
-    return A0_OK;
-  }
-
-  return A0_MAKE_SYSERR(syserr);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_mtx_timedlock_impl(a0_mtx_t* mtx, const a0_time_mono_t* timeout) {
-  // Note: __tsan_mutex_pre_lock should come here, but tsan doesn't provide
-  //       a way to "fail" a lock. Only a trylock.
-  robust_op_start(mtx);
-  const a0_err_t err = a0_mtx_timedlock_robust(mtx, timeout);
-  if (!err || A0_SYSERR(err) == EOWNERDEAD) {
-    __tsan_mutex_pre_lock(mtx, 0);
-    robust_op_add(mtx);
-    __tsan_mutex_post_lock(mtx, 0, 0);
-  }
-  robust_op_end(mtx);
-  return err;
-}
-
-a0_err_t a0_mtx_timedlock(a0_mtx_t* mtx, a0_time_mono_t timeout) {
-  return a0_mtx_timedlock_impl(mtx, &timeout);
-}
-
-a0_err_t a0_mtx_lock(a0_mtx_t* mtx) {
-  return a0_mtx_timedlock_impl(mtx, NULL);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_mtx_trylock_impl(a0_mtx_t* mtx) {
-  const uint32_t tid = a0_tid();
-
-  // Try to lock without kernel involvement.
-  uint32_t old = a0_cas_val(&mtx->ftx, 0, tid);
-
-  // Did it work?
-  if (!old) {
-    robust_op_add(mtx);
-    return A0_OK;
-  }
-
-  // Is the lock still usable?
-  if (ftx_notrecoverable(old)) {
-    return A0_MAKE_SYSERR(ENOTRECOVERABLE);
-  }
-
-  // Is the owner still alive?
-  if (!ftx_owner_died(old)) {
-    return A0_MAKE_SYSERR(EBUSY);
-  }
-
-  // Oh, the owner died. Ask the kernel to fix the state.
-  a0_err_t err = a0_ftx_trylock_pi(&mtx->ftx);
-  if (!err) {
-    robust_op_add(mtx);
-    if (ftx_owner_died(a0_atomic_load(&mtx->ftx))) {
-      return A0_MAKE_SYSERR(EOWNERDEAD);
-    }
-    return A0_OK;
-  }
-
-  // EAGAIN means that somebody else beat us to it.
-  // Anything else means we're borked.
-  if (A0_SYSERR(err) == EAGAIN) {
-    return A0_MAKE_SYSERR(EBUSY);
-  }
-  return A0_MAKE_SYSERR(ENOTRECOVERABLE);
-}
-
-a0_err_t a0_mtx_trylock(a0_mtx_t* mtx) {
-  __tsan_mutex_pre_lock(mtx, __tsan_mutex_try_lock);
-  robust_op_start(mtx);
-  a0_err_t err = a0_mtx_trylock_impl(mtx);
-  robust_op_end(mtx);
-  if (!err || A0_SYSERR(err) == EOWNERDEAD) {
-    __tsan_mutex_post_lock(mtx, __tsan_mutex_try_lock, 0);
-  } else {
-    __tsan_mutex_post_lock(mtx, __tsan_mutex_try_lock | __tsan_mutex_try_lock_failed, 0);
-  }
-  return err;
-}
-
-a0_err_t a0_mtx_consistent(a0_mtx_t* mtx) {
-  const uint32_t val = a0_atomic_load(&mtx->ftx);
-
-  // Why fix what isn't broken?
-  if (!ftx_owner_died(val)) {
-    return A0_MAKE_SYSERR(EINVAL);
-  }
-
-  // Is it yours to fix?
-  if (ftx_tid(val) != a0_tid()) {
-    return A0_MAKE_SYSERR(EPERM);
-  }
-
-  // Fix it!
-  a0_atomic_and_fetch(&mtx->ftx, ~FUTEX_OWNER_DIED);
-
-  return A0_OK;
-}
-
-a0_err_t a0_mtx_unlock(a0_mtx_t* mtx) {
-  const uint32_t tid = a0_tid();
-
-  const uint32_t val = a0_atomic_load(&mtx->ftx);
-
-  // Only the owner can unlock.
-  if (ftx_tid(val) != tid) {
-    return A0_MAKE_SYSERR(EPERM);
-  }
-
-  __tsan_mutex_pre_unlock(mtx, 0);
-
-  // If the mutex was acquired with EOWNERDEAD, the caller is responsible
-  // for fixing the state and marking the mutex consistent. If they did
-  // not mark it consistent and are unlocking... then we are unrecoverably
-  // borked!
-  uint32_t new_val = 0;
-  if (ftx_owner_died(val)) {
-    new_val = FTX_NOTRECOVERABLE;
-  }
-
-  robust_op_start(mtx);
-  robust_op_del(mtx);
-
-  // If the futex is exactly equal to tid, then there are no waiters and the
-  // kernel doesn't need to get involved.
-  if (!a0_cas(&mtx->ftx, tid, new_val)) {
-    // Ask the kernel to wake up a waiter.
-    a0_ftx_unlock_pi(&mtx->ftx);
-    if (new_val) {
-      a0_atomic_or_fetch(&mtx->ftx, new_val);
-    }
-  }
-
-  robust_op_end(mtx);
-  __tsan_mutex_post_unlock(mtx, 0);
-
-  return A0_OK;
-}
-
-// TODO(lshamis): Handle ENOTRECOVERABLE
-A0_STATIC_INLINE
-a0_err_t a0_cnd_timedwait_impl(a0_cnd_t* cnd, a0_mtx_t* mtx, const a0_time_mono_t* timeout) {
-  const uint32_t init_cnd = a0_atomic_load(cnd);
-
-  // Unblock other threads to do the things that will eventually signal this wait.
-  a0_err_t err = a0_mtx_unlock(mtx);
-  if (err) {
-    return err;
-  }
-
-  __tsan_mutex_pre_lock(mtx, 0);
-  robust_op_start(mtx);
-
-  do {
-    // Priority-inheritance-aware wait until awoken or timeout.
-    err = a0_ftx_wait_requeue_pi(cnd, init_cnd, timeout, &mtx->ftx);
-  } while (A0_SYSERR(err) == EINTR);
-
-  // We need to manually lock on timeout.
-  // Note: We keep the timeout error.
-  if (A0_SYSERR(err) == ETIMEDOUT) {
-    a0_mtx_timedlock_robust(mtx, NULL);
-  }
-  // Someone else grabbed and mutated the resource between the unlock and wait.
-  // No need to wait.
-  if (A0_SYSERR(err) == EAGAIN) {
-    err = a0_mtx_timedlock_robust(mtx, NULL);
-  }
-
-  robust_op_add(mtx);
-
-  // If no higher priority error, check the previous owner didn't die.
-  if (!err) {
-    err = ftx_owner_died(a0_atomic_load(&mtx->ftx)) ? EOWNERDEAD : A0_OK;
-  }
-
-  robust_op_end(mtx);
-  __tsan_mutex_post_lock(mtx, 0, 0);
-  return err;
-}
-
-a0_err_t a0_cnd_timedwait(a0_cnd_t* cnd, a0_mtx_t* mtx, a0_time_mono_t timeout) {
-  // Let's not unlock the mutex if we're going to get EINVAL due to a bad timeout.
-  if ((timeout.ts.tv_sec < 0 || timeout.ts.tv_nsec < 0 || (!timeout.ts.tv_sec && !timeout.ts.tv_nsec) || timeout.ts.tv_nsec >= NS_PER_SEC)) {
-    return A0_MAKE_SYSERR(EINVAL);
-  }
-  return a0_cnd_timedwait_impl(cnd, mtx, &timeout);
-}
-
-a0_err_t a0_cnd_wait(a0_cnd_t* cnd, a0_mtx_t* mtx) {
-  return a0_cnd_timedwait_impl(cnd, mtx, NULL);
-}
-
-A0_STATIC_INLINE
-a0_err_t a0_cnd_wake(a0_cnd_t* cnd, a0_mtx_t* mtx, uint32_t cnt) {
-  uint32_t val = a0_atomic_add_fetch(cnd, 1);
-
-  while (true) {
-    a0_err_t err = a0_ftx_cmp_requeue_pi(cnd, val, &mtx->ftx, cnt);
-    if (A0_SYSERR(err) != EAGAIN) {
-      return err;
-    }
-
-    // Another thread is also trying to wake this condition variable.
-    val = a0_atomic_load(cnd);
-  }
-}
-
-a0_err_t a0_cnd_signal(a0_cnd_t* cnd, a0_mtx_t* mtx) {
-  return a0_cnd_wake(cnd, mtx, 1);
-}
-
-a0_err_t a0_cnd_broadcast(a0_cnd_t* cnd, a0_mtx_t* mtx) {
-  return a0_cnd_wake(cnd, mtx, INT_MAX);
-}
diff --git a/src/libipc/platform/linux/a0/mtx.h b/src/libipc/platform/linux/a0/mtx.h
deleted file mode 100644
index d27ce17..0000000
--- a/src/libipc/platform/linux/a0/mtx.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef A0_MTX_H
-#define A0_MTX_H
-
-#include "a0/err.h"
-#include "a0/time.h"
-#include "a0/unused.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef uint32_t a0_ftx_t;
-
-// https://stackoverflow.com/questions/61645966/is-typedef-allowed-before-definition
-struct a0_mtx_s;
-
-typedef struct a0_mtx_s a0_mtx_t;
-
-// Mutex implementation designed for IPC.
-//
-// Similar to pthread_mutex_t with the following flags fixed:
-// * Process shared.
-// * Robust.
-// * Error checking.
-// * Priority inheriting.
-//
-// Unlike pthread_mutex_t, timespec are expected to use CLOCK_BOOTTIME.
-//
-// struct a0_mtx_s "Inherits" from robust_list, which requires:
-// * The first field MUST be a next pointer.
-// * There must be a futex, which makes the mutex immovable.
-//
-// Note: a mutex MUST be unlocked before being freed or unmapped.
-struct a0_mtx_s {
-  a0_mtx_t* next;
-  a0_mtx_t* prev;
-  a0_ftx_t ftx;
-};
-
-a0_err_t a0_mtx_lock(a0_mtx_t*) A0_WARN_UNUSED_RESULT;
-a0_err_t a0_mtx_timedlock(a0_mtx_t*, a0_time_mono_t) A0_WARN_UNUSED_RESULT;
-a0_err_t a0_mtx_trylock(a0_mtx_t*) A0_WARN_UNUSED_RESULT;
-a0_err_t a0_mtx_consistent(a0_mtx_t*);
-a0_err_t a0_mtx_unlock(a0_mtx_t*);
-
-typedef a0_ftx_t a0_cnd_t;
-
-a0_err_t a0_cnd_wait(a0_cnd_t*, a0_mtx_t*);
-a0_err_t a0_cnd_timedwait(a0_cnd_t*, a0_mtx_t*, a0_time_mono_t);
-a0_err_t a0_cnd_signal(a0_cnd_t*, a0_mtx_t*);
-a0_err_t a0_cnd_broadcast(a0_cnd_t*, a0_mtx_t*);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // A0_MTX_H
diff --git a/src/libipc/platform/linux/a0/strconv.c b/src/libipc/platform/linux/a0/strconv.c
deleted file mode 100644
index 70eedbf..0000000
--- a/src/libipc/platform/linux/a0/strconv.c
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "strconv.h"
-
-#include "a0/err.h"
-
-#include <string.h>
-
-static const char DECIMAL_DIGITS[] =
-    "00010203040506070809"
-    "10111213141516171819"
-    "20212223242526272829"
-    "30313233343536373839"
-    "40414243444546474849"
-    "50515253545556575859"
-    "60616263646566676869"
-    "70717273747576777879"
-    "80818283848586878889"
-    "90919293949596979899";
-
-a0_err_t a0_u32_to_str(uint32_t val, char* buf_start, char* buf_end, char** start_ptr) {
-  return a0_u64_to_str(val, buf_start, buf_end, start_ptr);
-}
-
-a0_err_t a0_u64_to_str(uint64_t val, char* buf_start, char* buf_end, char** start_ptr) {
-  uint64_t orig_val = val;
-  char* ptr = buf_end;
-  while (val >= 10) {
-    ptr -= 2;
-    memcpy(ptr, &DECIMAL_DIGITS[2 * (val % 100)], sizeof(uint16_t));
-    val /= 100;
-  }
-  if (val) {
-    *--ptr = (char)('0' + val);
-  }
-  memset(buf_start, '0', ptr - buf_start);
-  ptr -= (!orig_val);
-  if (start_ptr) {
-    *start_ptr = ptr;
-  }
-  return A0_OK;
-}
-
-a0_err_t a0_str_to_u32(const char* start, const char* end, uint32_t* out) {
-  *out = 0;
-  for (const char* ptr = start; ptr < end; ptr++) {
-    if (*ptr < '0' || *ptr > '9') {
-      return A0_ERR_INVALID_ARG;
-    }
-    *out *= 10;
-    *out += *ptr - '0';
-  }
-  return A0_OK;
-}
-
-a0_err_t a0_str_to_u64(const char* start, const char* end, uint64_t* out) {
-  *out = 0;
-  for (const char* ptr = start; ptr < end; ptr++) {
-    if (*ptr < '0' || *ptr > '9') {
-      return A0_ERR_INVALID_ARG;
-    }
-    *out *= 10;
-    *out += *ptr - '0';
-  }
-  return A0_OK;
-}
diff --git a/src/libipc/platform/linux/a0/strconv.h b/src/libipc/platform/linux/a0/strconv.h
deleted file mode 100644
index 2f5b743..0000000
--- a/src/libipc/platform/linux/a0/strconv.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef A0_SRC_STRCONV_H
-#define A0_SRC_STRCONV_H
-
-#include "a0/err.h"
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Converts a uint32 or uint64 to string.
-// The entire buffer will be populated, if not with given the value, then with '0'.
-// Populates the buffer from the back.
-// start_ptr, if not null, will be set to the point within the buffer where the number starts.
-// Does NOT check for overflow.
-a0_err_t a0_u32_to_str(uint32_t val, char* buf_start, char* buf_end, char** start_ptr);
-a0_err_t a0_u64_to_str(uint64_t val, char* buf_start, char* buf_end, char** start_ptr);
-
-// Converts a string to uint32 or uint64.
-// The string may have leading '0's.
-// Returns A0_ERR_INVALID_ARG if any character is not a digit.
-// Does NOT check for overflow.
-a0_err_t a0_str_to_u32(const char* start, const char* end, uint32_t* out);
-a0_err_t a0_str_to_u64(const char* start, const char* end, uint64_t* out);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // A0_SRC_STRCONV_H
diff --git a/src/libipc/platform/linux/a0/thread_local.h b/src/libipc/platform/linux/a0/thread_local.h
deleted file mode 100644
index 8e49813..0000000
--- a/src/libipc/platform/linux/a0/thread_local.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef A0_THREAD_LOCAL_H
-#define A0_THREAD_LOCAL_H
-
-#ifdef __cplusplus
-#define A0_THREAD_LOCAL thread_local
-#else
-#define A0_THREAD_LOCAL _Thread_local
-#endif  // __cplusplus
-
-#endif  // A0_THREAD_LOCAL_H
diff --git a/src/libipc/platform/linux/a0/tid.c b/src/libipc/platform/linux/a0/tid.c
deleted file mode 100644
index 9ad016a..0000000
--- a/src/libipc/platform/linux/a0/tid.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "a0/inline.h"
-#include "a0/thread_local.h"
-#include "a0/tid.h"
-
-#include <pthread.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <syscall.h>
-#include <unistd.h>
-
-A0_THREAD_LOCAL uint32_t a0_tid_cache = 0;
-static pthread_once_t a0_tid_reset_atfork_once;
-
-A0_STATIC_INLINE
-void a0_tid_reset() {
-  a0_tid_cache = 0;
-}
-
-A0_STATIC_INLINE
-void a0_tid_reset_atfork() {
-  pthread_atfork(NULL, NULL, &a0_tid_reset);
-}
-
-uint32_t a0_tid() {
-  if (!a0_tid_cache) {
-    a0_tid_cache = syscall(SYS_gettid);
-    pthread_once(&a0_tid_reset_atfork_once, a0_tid_reset_atfork);
-  }
-  return a0_tid_cache;
-}
diff --git a/src/libipc/platform/linux/a0/tid.h b/src/libipc/platform/linux/a0/tid.h
deleted file mode 100644
index 11cb71c..0000000
--- a/src/libipc/platform/linux/a0/tid.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef A0_TID_H
-#define A0_TID_H
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-uint32_t a0_tid();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // A0_TID_H
diff --git a/src/libipc/platform/linux/a0/time.c b/src/libipc/platform/linux/a0/time.c
deleted file mode 100644
index 09a79b4..0000000
--- a/src/libipc/platform/linux/a0/time.c
+++ /dev/null
@@ -1,124 +0,0 @@
-#include "a0/empty.h"
-#include "a0/err.h"
-#include "a0/time.h"
-
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <time.h>
-
-#include "clock.h"
-#include "err_macro.h"
-#include "strconv.h"
-
-const char A0_TIME_MONO[] = "a0_time_mono";
-
-a0_err_t a0_time_mono_now(a0_time_mono_t* out) {
-  return a0_clock_now(CLOCK_BOOTTIME, &out->ts);
-}
-
-a0_err_t a0_time_mono_str(a0_time_mono_t time_mono, char mono_str[20]) {
-  // Mono time as unsigned integer with up to 20 chars: "18446744072709551615"
-  uint64_t ns = time_mono.ts.tv_sec * NS_PER_SEC + time_mono.ts.tv_nsec;
-  mono_str[19] = '\0';
-  return a0_u64_to_str(ns, mono_str, mono_str + 19, NULL);
-}
-
-a0_err_t a0_time_mono_parse(const char mono_str[20], a0_time_mono_t* out) {
-  uint64_t ns;
-  A0_RETURN_ERR_ON_ERR(a0_str_to_u64(mono_str, mono_str + 19, &ns));
-  out->ts.tv_sec = ns / NS_PER_SEC;
-  out->ts.tv_nsec = ns % NS_PER_SEC;
-  return A0_OK;
-}
-
-a0_err_t a0_time_mono_add(a0_time_mono_t time_mono, int64_t add_nsec, a0_time_mono_t* out) {
-  return a0_clock_add(time_mono.ts, add_nsec, &out->ts);
-}
-
-const char A0_TIME_WALL[] = "a0_time_wall";
-
-a0_err_t a0_time_wall_now(a0_time_wall_t* out) {
-  A0_RETURN_SYSERR_ON_MINUS_ONE(clock_gettime(CLOCK_REALTIME, &out->ts));
-  return A0_OK;
-}
-
-a0_err_t a0_time_wall_str(a0_time_wall_t wall_time, char wall_str[36]) {
-  // Wall time in RFC 3999 Nano: "2006-01-02T15:04:05.999999999-07:00"
-  struct tm wall_tm;
-  gmtime_r(&wall_time.ts.tv_sec, &wall_tm);
-
-  strftime(&wall_str[0], 20, "%Y-%m-%dT%H:%M:%S", &wall_tm);
-  snprintf(&wall_str[19], 17, ".%09ld-00:00", wall_time.ts.tv_nsec);
-  wall_str[35] = '\0';
-
-  return A0_OK;
-}
-
-a0_err_t a0_time_wall_parse(const char wall_str[36], a0_time_wall_t* out) {
-  // strptime requires _GNU_SOURCE, which we don't want, so we do it our selves.
-  // Hard code "%Y-%m-%dT%H:%M:%S" + ".%09ld-00:00" pattern.
-
-  struct tm wall_tm = A0_EMPTY;
-  // %Y
-  A0_RETURN_ERR_ON_ERR(a0_str_to_u32(wall_str + 0, wall_str + 4, (uint32_t*)&wall_tm.tm_year));
-  wall_tm.tm_year -= 1900;
-  // -
-  if (wall_str[4] != '-') {
-    return A0_ERR_INVALID_ARG;
-  }
-  // %m
-  A0_RETURN_ERR_ON_ERR(a0_str_to_u32(wall_str + 5, wall_str + 7, (uint32_t*)&wall_tm.tm_mon));
-  if (wall_tm.tm_mon < 1 || wall_tm.tm_mon > 12) {
-    return A0_ERR_INVALID_ARG;
-  }
-  wall_tm.tm_mon--;
-  // -
-  if (wall_str[7] != '-') {
-    return A0_ERR_INVALID_ARG;
-  }
-  // %d
-  A0_RETURN_ERR_ON_ERR(a0_str_to_u32(wall_str + 8, wall_str + 10, (uint32_t*)&wall_tm.tm_mday));
-  if (wall_tm.tm_mday < 1 || wall_tm.tm_mday > 31) {
-    return A0_ERR_INVALID_ARG;
-  }
-  // T
-  if (wall_str[10] != 'T') {
-    return A0_ERR_INVALID_ARG;
-  }
-  // %H
-  A0_RETURN_ERR_ON_ERR(a0_str_to_u32(wall_str + 11, wall_str + 13, (uint32_t*)&wall_tm.tm_hour));
-  if (wall_tm.tm_hour > 24) {
-    return A0_ERR_INVALID_ARG;
-  }
-  // :
-  if (wall_str[13] != ':') {
-    return A0_ERR_INVALID_ARG;
-  }
-  // %M
-  A0_RETURN_ERR_ON_ERR(a0_str_to_u32(wall_str + 14, wall_str + 16, (uint32_t*)&wall_tm.tm_min));
-  if (wall_tm.tm_min > 60) {
-    return A0_ERR_INVALID_ARG;
-  }
-  // :
-  if (wall_str[16] != ':') {
-    return A0_ERR_INVALID_ARG;
-  }
-  // %S
-  A0_RETURN_ERR_ON_ERR(a0_str_to_u32(wall_str + 17, wall_str + 19, (uint32_t*)&wall_tm.tm_sec));
-  if (wall_tm.tm_sec > 61) {
-    return A0_ERR_INVALID_ARG;
-  }
-  // .
-  if (wall_str[19] != '.') {
-    return A0_ERR_INVALID_ARG;
-  }
-
-  if (memcmp(wall_str + 29, "-00:00", 6) != 0) {
-    return A0_ERR_INVALID_ARG;
-  }
-
-  // Use timegm, cause it's a pain to compute months/years to seconds.
-  out->ts.tv_sec = timegm(&wall_tm);
-  return a0_str_to_u64(wall_str + 20, wall_str + 29, (uint64_t*)&out->ts.tv_nsec);
-}
diff --git a/src/libipc/platform/linux/a0/time.h b/src/libipc/platform/linux/a0/time.h
deleted file mode 100644
index 77e49c4..0000000
--- a/src/libipc/platform/linux/a0/time.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * \file time.h
- * \rst
- *
- * Mono Time
- * ---------
- *
- * | Mono time is a number of nanoseconds from machine boottime.
- * | This time cannot decrease and duration between ticks is constant.
- * | This time is not related to wall clock time.
- * | This time is most suitable for measuring durations.
- * |
- * | As a string, it is represented as a 20 char number:
- * | **18446744072709551615**
- * |
- * | Note that this uses CLOCK_BOOTTIME under the hood, not CLOCK_MONOTONIC.
- *
- * Wall Time
- * ---------
- *
- * | Wall time is an time object representing human-readable wall clock time.
- * | This time can decrease and duration between ticks is not constant.
- * | This time is most related to wall clock time.
- * | This time is not suitable for measuring durations.
- * |
- * | As a string, it is represented as a 36 char RFC 3999 Nano / ISO 8601:
- * | **2006-01-02T15:04:05.999999999-07:00**
- *
- * \endrst
- */
-
-#ifndef A0_TIME_H
-#define A0_TIME_H
-
-#include "a0/err.h"
-
-#include <stdint.h>
-#include <time.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** \addtogroup TIME_MONO
- *  @{
- */
-
-/// Header key for mono timestamps.
-extern const char A0_TIME_MONO[];
-
-/// Monotonic timestamp. Despite the name, uses CLOCK_BOOTTIME.
-typedef struct a0_time_mono_s {
-  struct timespec ts;
-} a0_time_mono_t;
-
-/// Get the current mono timestamps.
-a0_err_t a0_time_mono_now(a0_time_mono_t*);
-
-/// Stringify a given mono timestamps.
-a0_err_t a0_time_mono_str(a0_time_mono_t, char mono_str[20]);
-
-/// Parse a stringified mono timestamps.
-a0_err_t a0_time_mono_parse(const char mono_str[20], a0_time_mono_t*);
-
-/// Add a duration in nanoseconds to a mono timestamp.
-a0_err_t a0_time_mono_add(a0_time_mono_t, int64_t add_nsec, a0_time_mono_t*);
-
-/** @}*/
-
-/** \addtogroup TIME_WALL
- *  @{
- */
-
-/// Header key for wall timestamps.
-extern const char A0_TIME_WALL[];
-
-/// Wall clock timestamp.
-typedef struct a0_time_wall_s {
-  struct timespec ts;
-} a0_time_wall_t;
-
-/// Get the current wall timestamps.
-a0_err_t a0_time_wall_now(a0_time_wall_t*);
-
-/// Stringify a given wall timestamps.
-a0_err_t a0_time_wall_str(a0_time_wall_t, char wall_str[36]);
-
-/// Parse a stringified wall timestamps.
-a0_err_t a0_time_wall_parse(const char wall_str[36], a0_time_wall_t*);
-
-/** @}*/
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // A0_TRANSPORT_H
diff --git a/src/libipc/platform/linux/a0/unused.h b/src/libipc/platform/linux/a0/unused.h
deleted file mode 100644
index 8b1025a..0000000
--- a/src/libipc/platform/linux/a0/unused.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef A0_UNUSED_H
-#define A0_UNUSED_H
-
-#define A0_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
-#define A0_MAYBE_UNUSED(X) ((void)(X))
-
-#endif  // A0_UNUSED_H
diff --git a/src/libipc/platform/linux/condition.h b/src/libipc/platform/linux/condition.h
deleted file mode 100644
index c4f00ca..0000000
--- a/src/libipc/platform/linux/condition.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#pragma once
-
-#include "libipc/utility/log.h"
-#include "libipc/mutex.h"
-
-#include "get_wait_time.h"
-#include "sync_obj_impl.h"
-
-#include "a0/err_macro.h"
-#include "a0/mtx.h"
-
-namespace ipc {
-namespace detail {
-namespace sync {
-
-class condition : public sync::obj_impl<a0_cnd_t> {
-public:
-    condition() = default;
-    ~condition() = default;
-
-    bool wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
-        if (!valid()) return false;
-        if (tm == invalid_value) {
-            int eno = A0_SYSERR(a0_cnd_wait(native(), static_cast<a0_mtx_t *>(mtx.native())));
-            if (eno != 0) {
-                ipc::error("fail condition wait[%d]\n", eno);
-                return false;
-            }
-        } else {
-            auto ts = detail::make_timespec(tm);
-            int eno = A0_SYSERR(a0_cnd_timedwait(native(), static_cast<a0_mtx_t *>(mtx.native()), {ts}));
-            if (eno != 0) {
-                if (eno != ETIMEDOUT) {
-                    ipc::error("fail condition timedwait[%d]: tm = %zd, tv_sec = %ld, tv_nsec = %ld\n",
-                                eno, tm, ts.tv_sec, ts.tv_nsec);
-                }
-                return false;
-            }
-        }
-        return true;
-    }
-
-    bool notify(ipc::sync::mutex &mtx) noexcept {
-        if (!valid()) return false;
-        int eno = A0_SYSERR(a0_cnd_signal(native(), static_cast<a0_mtx_t *>(mtx.native())));
-        if (eno != 0) {
-            ipc::error("fail condition notify[%d]\n", eno);
-            return false;
-        }
-        return true;
-    }
-
-    bool broadcast(ipc::sync::mutex &mtx) noexcept {
-        if (!valid()) return false;
-        int eno = A0_SYSERR(a0_cnd_broadcast(native(), static_cast<a0_mtx_t *>(mtx.native())));
-        if (eno != 0) {
-            ipc::error("fail condition broadcast[%d]\n", eno);
-            return false;
-        }
-        return true;
-    }
-};
-
-} // namespace sync
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/linux/get_wait_time.h b/src/libipc/platform/linux/get_wait_time.h
deleted file mode 100644
index ffaf2d2..0000000
--- a/src/libipc/platform/linux/get_wait_time.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <cinttypes>
-#include <system_error>
-
-#include "libipc/utility/log.h"
-
-#include "a0/time.h"
-#include "a0/err_macro.h"
-
-namespace ipc {
-namespace detail {
-
-inline bool calc_wait_time(timespec &ts, std::uint64_t tm /*ms*/) noexcept {
-    std::int64_t add_ns = static_cast<std::int64_t>(tm * 1000000ull);
-    if (add_ns < 0) {
-        ipc::error("invalid time = " PRIu64 "\n", tm);
-        return false;
-    }
-    a0_time_mono_t now;
-    int eno = A0_SYSERR(a0_time_mono_now(&now));
-    if (eno != 0) {
-        ipc::error("fail get time[%d]\n", eno);
-        return false;
-    }
-    a0_time_mono_t *target = reinterpret_cast<a0_time_mono_t *>(&ts);
-    if ((eno = A0_SYSERR(a0_time_mono_add(now, add_ns, target))) != 0) {
-        ipc::error("fail get time[%d]\n", eno);
-        return false;
-    }
-    return true;
-}
-
-inline timespec make_timespec(std::uint64_t tm /*ms*/) noexcept(false) {
-    timespec ts {};
-    if (!calc_wait_time(ts, tm)) {
-        ipc::error("fail calc_wait_time: tm = %zd, tv_sec = %ld, tv_nsec = %ld\n",
-                    tm, ts.tv_sec, ts.tv_nsec);
-        throw std::system_error{static_cast<int>(errno), std::system_category()};
-    }
-    return ts;
-}
-
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/linux/mutex.h b/src/libipc/platform/linux/mutex.h
deleted file mode 100644
index 91f156b..0000000
--- a/src/libipc/platform/linux/mutex.h
+++ /dev/null
@@ -1,204 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <system_error>
-#include <mutex>
-#include <atomic>
-
-#include "libipc/platform/detail.h"
-#include "libipc/utility/log.h"
-#include "libipc/memory/resource.h"
-#include "libipc/shm.h"
-
-#include "get_wait_time.h"
-#include "sync_obj_impl.h"
-
-#include "a0/err_macro.h"
-#include "a0/mtx.h"
-
-namespace ipc {
-namespace detail {
-namespace sync {
-
-class robust_mutex : public sync::obj_impl<a0_mtx_t> {
-public:
-    bool lock(std::uint64_t tm) noexcept {
-        if (!valid()) return false;
-        for (;;) {
-            auto ts = detail::make_timespec(tm);
-            int eno = A0_SYSERR(
-                (tm == invalid_value) ? a0_mtx_lock(native()) 
-                                      : a0_mtx_timedlock(native(), {ts}));
-            switch (eno) {
-            case 0:
-                return true;
-            case ETIMEDOUT:
-                return false;
-            case EOWNERDEAD: {
-                    int eno2 = A0_SYSERR(a0_mtx_consistent(native()));
-                    if (eno2 != 0) {
-                        ipc::error("fail mutex lock[%d] -> consistent[%d]\n", eno, eno2);
-                        return false;
-                    }
-                    int eno3 = A0_SYSERR(a0_mtx_unlock(native()));
-                    if (eno3 != 0) {
-                        ipc::error("fail mutex lock[%d] -> unlock[%d]\n", eno, eno3);
-                        return false;
-                    }
-                }
-                break; // loop again
-            default:
-                ipc::error("fail mutex lock[%d]\n", eno);
-                return false;
-            }
-        }
-    }
-
-    bool try_lock() noexcept(false) {
-        if (!valid()) return false;
-        int eno = A0_SYSERR(a0_mtx_timedlock(native(), {detail::make_timespec(0)}));
-        switch (eno) {
-        case 0:
-            return true;
-        case ETIMEDOUT:
-            return false;
-        case EOWNERDEAD: {
-                int eno2 = A0_SYSERR(a0_mtx_consistent(native()));
-                if (eno2 != 0) {
-                    ipc::error("fail mutex try_lock[%d] -> consistent[%d]\n", eno, eno2);
-                    break;
-                }
-                int eno3 = A0_SYSERR(a0_mtx_unlock(native()));
-                if (eno3 != 0) {
-                    ipc::error("fail mutex try_lock[%d] -> unlock[%d]\n", eno, eno3);
-                    break;
-                }
-            }
-            break;
-        default:
-            ipc::error("fail mutex try_lock[%d]\n", eno);
-            break;
-        }
-        throw std::system_error{eno, std::system_category()};
-    }
-
-    bool unlock() noexcept {
-        if (!valid()) return false;
-        int eno = A0_SYSERR(a0_mtx_unlock(native()));
-        if (eno != 0) {
-            ipc::error("fail mutex unlock[%d]\n", eno);
-            return false;
-        }
-        return true;
-    }
-};
-
-class mutex {
-    robust_mutex *mutex_ = nullptr;
-    std::atomic<std::int32_t> *ref_ = nullptr;
-
-    struct curr_prog {
-        struct shm_data {
-            robust_mutex mtx;
-            std::atomic<std::int32_t> ref;
-
-            struct init {
-                char const *name;
-            };
-            shm_data(init arg)
-                : mtx{}, ref{0} { mtx.open(arg.name); }
-        };
-        ipc::map<ipc::string, shm_data> mutex_handles;
-        std::mutex lock;
-
-        static curr_prog &get() {
-            static curr_prog info;
-            return info;
-        }
-    };
-
-    void acquire_mutex(char const *name) {
-        if (name == nullptr) {
-            return;
-        }
-        auto &info = curr_prog::get();
-        IPC_UNUSED_ std::lock_guard<std::mutex> guard {info.lock};
-        auto it = info.mutex_handles.find(name);
-        if (it == info.mutex_handles.end()) {
-            it = curr_prog::get().mutex_handles.emplace(name, 
-                              curr_prog::shm_data::init{name}).first;
-        }
-        mutex_ = &it->second.mtx;
-        ref_   = &it->second.ref;
-    }
-
-    template <typename F>
-    void release_mutex(ipc::string const &name, F &&clear) {
-        if (name.empty()) return;
-        IPC_UNUSED_ std::lock_guard<std::mutex> guard {curr_prog::get().lock};
-        auto it = curr_prog::get().mutex_handles.find(name);
-        if (it == curr_prog::get().mutex_handles.end()) {
-            return;
-        }
-        if (clear()) {
-            curr_prog::get().mutex_handles.erase(it);
-        }
-    }
-
-public:
-    mutex() = default;
-    ~mutex() = default;
-
-    a0_mtx_t const *native() const noexcept {
-        return valid() ? mutex_->native() : nullptr;
-    }
-
-    a0_mtx_t *native() noexcept {
-        return valid() ? mutex_->native() : nullptr;
-    }
-
-    bool valid() const noexcept {
-        return (mutex_ != nullptr) && (ref_ != nullptr) && mutex_->valid();
-    }
-
-    bool open(char const *name) noexcept {
-        close();
-        acquire_mutex(name);
-        if (!valid()) {
-            return false;
-        }
-        ref_->fetch_add(1, std::memory_order_relaxed);
-        return true;
-    }
-
-    void close() noexcept {
-        if ((mutex_ != nullptr) && (ref_ != nullptr)) {
-            if (mutex_->name() != nullptr) {
-                release_mutex(mutex_->name(), [this] {
-                    return ref_->fetch_sub(1, std::memory_order_relaxed) <= 1;
-                });
-            } else mutex_->close();
-        }
-        mutex_ = nullptr;
-        ref_   = nullptr;
-    }
-
-    bool lock(std::uint64_t tm) noexcept {
-        if (!valid()) return false;
-        return mutex_->lock(tm);
-    }
-
-    bool try_lock() noexcept(false) {
-        if (!valid()) return false;
-        return mutex_->try_lock();
-    }
-
-    bool unlock() noexcept {
-        if (!valid()) return false;
-        return mutex_->unlock();
-    }
-};
-
-} // namespace sync
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/linux/sync_obj_impl.h b/src/libipc/platform/linux/sync_obj_impl.h
deleted file mode 100644
index e28f95d..0000000
--- a/src/libipc/platform/linux/sync_obj_impl.h
+++ /dev/null
@@ -1,69 +0,0 @@
-#pragma once
-
-#include "libipc/utility/log.h"
-#include "libipc/shm.h"
-
-#include "a0/empty.h"
-
-namespace ipc {
-namespace detail {
-namespace sync {
-
-template <typename SyncT>
-class obj_impl {
-public:
-    using sync_t = SyncT;
-
-protected:
-    ipc::shm::handle shm_;
-    sync_t *h_ = nullptr;
-
-    sync_t *acquire_handle(char const *name) {
-        if (!shm_.acquire(name, sizeof(sync_t))) {
-            ipc::error("[acquire_handle] fail shm.acquire: %s\n", name);
-            return nullptr;
-        }
-        return static_cast<sync_t *>(shm_.get());
-    }
-
-public:
-    obj_impl() = default;
-    ~obj_impl() = default;
-
-    sync_t const *native() const noexcept {
-        return h_;
-    }
-
-    sync_t *native() noexcept {
-        return h_;
-    }
-
-    char const *name() const noexcept {
-        return shm_.name();
-    }
-
-    bool valid() const noexcept {
-        return h_ != nullptr;
-    }
-
-    bool open(char const *name) noexcept {
-        close();
-        if ((h_ = acquire_handle(name)) == nullptr) {
-            return false;
-        }
-        if (shm_.ref() > 1) {
-            return true;
-        }
-        *h_ = A0_EMPTY;
-        return true;
-    }
-
-    void close() noexcept {
-        shm_.release();
-        h_ = nullptr;
-    }
-};
-
-} // namespace sync
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/platform.c b/src/libipc/platform/platform.c
deleted file mode 100644
index 49cc977..0000000
--- a/src/libipc/platform/platform.c
+++ /dev/null
@@ -1,13 +0,0 @@
-
-#include "libipc/platform/detail.h"
-#if defined(IPC_OS_WINDOWS_)
-#elif defined(IPC_OS_LINUX_)
-#include "libipc/platform/linux/a0/err.c"
-#include "libipc/platform/linux/a0/mtx.c"
-#include "libipc/platform/linux/a0/strconv.c"
-#include "libipc/platform/linux/a0/tid.c"
-#include "libipc/platform/linux/a0/time.c"
-#elif defined(IPC_OS_QNX_)
-#else/*IPC_OS*/
-#   error "Unsupported platform."
-#endif
diff --git a/src/libipc/platform/platform.cpp b/src/libipc/platform/platform.cpp
deleted file mode 100644
index b77cbc9..0000000
--- a/src/libipc/platform/platform.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-
-#include "libipc/platform/detail.h"
-#if defined(IPC_OS_WINDOWS_)
-#include "libipc/platform/win/shm_win.cpp"
-#elif defined(IPC_OS_LINUX_) || defined(IPC_OS_QNX_)
-#include "libipc/platform/posix/shm_posix.cpp"
-#else/*IPC_OS*/
-#   error "Unsupported platform."
-#endif
diff --git a/src/libipc/platform/posix/condition.h b/src/libipc/platform/posix/condition.h
deleted file mode 100644
index d283d68..0000000
--- a/src/libipc/platform/posix/condition.h
+++ /dev/null
@@ -1,141 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <cstring>
-
-#include <pthread.h>
-
-#include "libipc/utility/log.h"
-#include "libipc/utility/scope_guard.h"
-#include "libipc/mutex.h"
-#include "libipc/shm.h"
-
-#include "get_wait_time.h"
-
-namespace ipc {
-namespace detail {
-namespace sync {
-
-class condition {
-    ipc::shm::handle shm_;
-    pthread_cond_t *cond_ = nullptr;
-
-    pthread_cond_t *acquire_cond(char const *name) {
-        if (!shm_.acquire(name, sizeof(pthread_cond_t))) {
-            ipc::error("[acquire_cond] fail shm.acquire: %s\n", name);
-            return nullptr;
-        }
-        return static_cast<pthread_cond_t *>(shm_.get());
-    }
-
-public:
-    condition() = default;
-    ~condition() = default;
-
-    pthread_cond_t const *native() const noexcept {
-        return cond_;
-    }
-
-    pthread_cond_t *native() noexcept {
-        return cond_;
-    }
-
-    bool valid() const noexcept {
-        static const char tmp[sizeof(pthread_cond_t)] {};
-        return (cond_ != nullptr)
-            && (std::memcmp(tmp, cond_, sizeof(pthread_cond_t)) != 0);
-    }
-
-    bool open(char const *name) noexcept {
-        close();
-        if ((cond_ = acquire_cond(name)) == nullptr) {
-            return false;
-        }
-        if (shm_.ref() > 1) {
-            return valid();
-        }
-        ::pthread_cond_destroy(cond_);
-        auto finally = ipc::guard([this] { close(); }); // close when failed
-        // init condition
-        int eno;
-        pthread_condattr_t cond_attr;
-        if ((eno = ::pthread_condattr_init(&cond_attr)) != 0) {
-            ipc::error("fail pthread_condattr_init[%d]\n", eno);
-            return false;
-        }
-        IPC_UNUSED_ auto guard_cond_attr = guard([&cond_attr] { ::pthread_condattr_destroy(&cond_attr); });
-        if ((eno = ::pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED)) != 0) {
-            ipc::error("fail pthread_condattr_setpshared[%d]\n", eno);
-            return false;
-        }
-        *cond_ = PTHREAD_COND_INITIALIZER;
-        if ((eno = ::pthread_cond_init(cond_, &cond_attr)) != 0) {
-            ipc::error("fail pthread_cond_init[%d]\n", eno);
-            return false;
-        }
-        finally.dismiss();
-        return valid();
-    }
-
-    void close() noexcept {
-        if ((shm_.ref() <= 1) && cond_ != nullptr) {
-            int eno;
-            if ((eno = ::pthread_cond_destroy(cond_)) != 0) {
-                ipc::error("fail pthread_cond_destroy[%d]\n", eno);
-            }
-        }
-        shm_.release();
-        cond_ = nullptr;
-    }
-
-    bool wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
-        if (!valid()) return false;
-        switch (tm) {
-        case invalid_value: {
-                int eno;
-                if ((eno = ::pthread_cond_wait(cond_, static_cast<pthread_mutex_t *>(mtx.native()))) != 0) {
-                    ipc::error("fail pthread_cond_wait[%d]\n", eno);
-                    return false;
-                }
-            }
-            break;
-        default: {
-                auto ts = detail::make_timespec(tm);
-                int eno;
-                if ((eno = ::pthread_cond_timedwait(cond_, static_cast<pthread_mutex_t *>(mtx.native()), &ts)) != 0) {
-                    if (eno != ETIMEDOUT) {
-                        ipc::error("fail pthread_cond_timedwait[%d]: tm = %zd, tv_sec = %ld, tv_nsec = %ld\n",
-                                   eno, tm, ts.tv_sec, ts.tv_nsec);
-                    }
-                    return false;
-                }
-            }
-            break;
-        }
-        return true;
-    }
-
-    bool notify(ipc::sync::mutex &) noexcept {
-        if (!valid()) return false;
-        int eno;
-        if ((eno = ::pthread_cond_signal(cond_)) != 0) {
-            ipc::error("fail pthread_cond_signal[%d]\n", eno);
-            return false;
-        }
-        return true;
-    }
-
-    bool broadcast(ipc::sync::mutex &) noexcept {
-        if (!valid()) return false;
-        int eno;
-        if ((eno = ::pthread_cond_broadcast(cond_)) != 0) {
-            ipc::error("fail pthread_cond_broadcast[%d]\n", eno);
-            return false;
-        }
-        return true;
-    }
-};
-
-} // namespace sync
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/posix/get_error.h b/src/libipc/platform/posix/get_error.h
deleted file mode 100644
index c552f22..0000000
--- a/src/libipc/platform/posix/get_error.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include <errno.h>
-#include <string.h>
-
-namespace ipc {
-namespace detail {
-
-inline char const *curr_error() noexcept {
-    return ::strerror(errno);
-}
-
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/posix/get_wait_time.h b/src/libipc/platform/posix/get_wait_time.h
deleted file mode 100644
index 785cd75..0000000
--- a/src/libipc/platform/posix/get_wait_time.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <system_error>
-
-#include <sys/time.h>
-#include <time.h>
-#include <errno.h>
-
-#include "libipc/utility/log.h"
-
-namespace ipc {
-namespace detail {
-
-inline bool calc_wait_time(timespec &ts, std::uint64_t tm /*ms*/) noexcept {
-    timeval now;
-    int eno = ::gettimeofday(&now, NULL);
-    if (eno != 0) {
-        ipc::error("fail gettimeofday [%d]\n", eno);
-        return false;
-    }
-    ts.tv_nsec = (now.tv_usec + (tm % 1000) * 1000) * 1000;
-    ts.tv_sec  =  now.tv_sec  + (tm / 1000) + (ts.tv_nsec / 1000000000l);
-    ts.tv_nsec %= 1000000000l;
-    return true;
-}
-
-inline timespec make_timespec(std::uint64_t tm /*ms*/) noexcept(false) {
-    timespec ts {};
-    if (!calc_wait_time(ts, tm)) {
-        ipc::error("fail calc_wait_time: tm = %zd, tv_sec = %ld, tv_nsec = %ld\n",
-                    tm, ts.tv_sec, ts.tv_nsec);
-        throw std::system_error{static_cast<int>(errno), std::system_category()};
-    }
-    return ts;
-}
-
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/posix/mutex.h b/src/libipc/platform/posix/mutex.h
deleted file mode 100644
index 8f7525f..0000000
--- a/src/libipc/platform/posix/mutex.h
+++ /dev/null
@@ -1,237 +0,0 @@
-#pragma once
-
-#include <cstring>
-#include <cassert>
-#include <cstdint>
-#include <system_error>
-#include <mutex>
-#include <atomic>
-
-#include <pthread.h>
-
-#include "libipc/platform/detail.h"
-#include "libipc/utility/log.h"
-#include "libipc/utility/scope_guard.h"
-#include "libipc/memory/resource.h"
-#include "libipc/shm.h"
-
-#include "get_wait_time.h"
-
-namespace ipc {
-namespace detail {
-namespace sync {
-
-class mutex {
-    ipc::shm::handle *shm_ = nullptr;
-    std::atomic<std::int32_t> *ref_ = nullptr;
-    pthread_mutex_t *mutex_ = nullptr;
-
-    struct curr_prog {
-        struct shm_data {
-            ipc::shm::handle shm;
-            std::atomic<std::int32_t> ref;
-
-            struct init {
-                char const *name;
-                std::size_t size;
-            };
-            shm_data(init arg)
-                : shm{arg.name, arg.size}, ref{0} {}
-        };
-        ipc::map<ipc::string, shm_data> mutex_handles;
-        std::mutex lock;
-
-        static curr_prog &get() {
-            static curr_prog info;
-            return info;
-        }
-    };
-
-    pthread_mutex_t *acquire_mutex(char const *name) {
-        if (name == nullptr) {
-            return nullptr;
-        }
-        auto &info = curr_prog::get();
-        IPC_UNUSED_ std::lock_guard<std::mutex> guard {info.lock};
-        auto it = info.mutex_handles.find(name);
-        if (it == info.mutex_handles.end()) {
-            it = curr_prog::get().mutex_handles.emplace(name, 
-                              curr_prog::shm_data::init{name, sizeof(pthread_mutex_t)}).first;
-        }
-        shm_ = &it->second.shm;
-        ref_ = &it->second.ref;
-        if (shm_ == nullptr) {
-            return nullptr;
-        }
-        return static_cast<pthread_mutex_t *>(shm_->get());
-    }
-
-    template <typename F>
-    void release_mutex(ipc::string const &name, F &&clear) {
-        if (name.empty()) return;
-        IPC_UNUSED_ std::lock_guard<std::mutex> guard {curr_prog::get().lock};
-        auto it = curr_prog::get().mutex_handles.find(name);
-        if (it == curr_prog::get().mutex_handles.end()) {
-            return;
-        }
-        if (clear()) {
-            curr_prog::get().mutex_handles.erase(it);
-        }
-    }
-
-public:
-    mutex() = default;
-    ~mutex() = default;
-
-    pthread_mutex_t const *native() const noexcept {
-        return mutex_;
-    }
-
-    pthread_mutex_t *native() noexcept {
-        return mutex_;
-    }
-
-    bool valid() const noexcept {
-        static const char tmp[sizeof(pthread_mutex_t)] {};
-        return (shm_ != nullptr) && (ref_ != nullptr) && (mutex_ != nullptr)
-            && (std::memcmp(tmp, mutex_, sizeof(pthread_mutex_t)) != 0);
-    }
-
-    bool open(char const *name) noexcept {
-        close();
-        if ((mutex_ = acquire_mutex(name)) == nullptr) {
-            return false;
-        }
-        auto self_ref = ref_->fetch_add(1, std::memory_order_relaxed);
-        if (shm_->ref() > 1 || self_ref > 0) {
-            return valid();
-        }
-        ::pthread_mutex_destroy(mutex_);
-        auto finally = ipc::guard([this] { close(); }); // close when failed
-        // init mutex
-        int eno;
-        pthread_mutexattr_t mutex_attr;
-        if ((eno = ::pthread_mutexattr_init(&mutex_attr)) != 0) {
-            ipc::error("fail pthread_mutexattr_init[%d]\n", eno);
-            return false;
-        }
-        IPC_UNUSED_ auto guard_mutex_attr = guard([&mutex_attr] { ::pthread_mutexattr_destroy(&mutex_attr); });
-        if ((eno = ::pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED)) != 0) {
-            ipc::error("fail pthread_mutexattr_setpshared[%d]\n", eno);
-            return false;
-        }
-        if ((eno = ::pthread_mutexattr_setrobust(&mutex_attr, PTHREAD_MUTEX_ROBUST)) != 0) {
-            ipc::error("fail pthread_mutexattr_setrobust[%d]\n", eno);
-            return false;
-        }
-        *mutex_ = PTHREAD_MUTEX_INITIALIZER;
-        if ((eno = ::pthread_mutex_init(mutex_, &mutex_attr)) != 0) {
-            ipc::error("fail pthread_mutex_init[%d]\n", eno);
-            return false;
-        }
-        finally.dismiss();
-        return valid();
-    }
-
-    void close() noexcept {
-        if ((ref_ != nullptr) && (shm_ != nullptr) && (mutex_ != nullptr)) {
-            if (shm_->name() != nullptr) {
-                release_mutex(shm_->name(), [this] {
-                    auto self_ref = ref_->fetch_sub(1, std::memory_order_relaxed);
-                    if ((shm_->ref() <= 1) && (self_ref <= 1)) {
-                        int eno;
-                        if ((eno = ::pthread_mutex_destroy(mutex_)) != 0) {
-                            ipc::error("fail pthread_mutex_destroy[%d]\n", eno);
-                        }
-                        return true;
-                    }
-                    return false;
-                });
-            } else shm_->release();
-        }
-        shm_   = nullptr;
-        ref_   = nullptr;
-        mutex_ = nullptr;
-    }
-
-    bool lock(std::uint64_t tm) noexcept {
-        if (!valid()) return false;
-        for (;;) {
-            auto ts = detail::make_timespec(tm);
-            int eno = (tm == invalid_value) 
-                ? ::pthread_mutex_lock(mutex_) 
-                : ::pthread_mutex_timedlock(mutex_, &ts);
-            switch (eno) {
-            case 0:
-                return true;
-            case ETIMEDOUT:
-                return false;
-            case EOWNERDEAD: {
-                    if (shm_->ref() > 1) {
-                        shm_->sub_ref();
-                    }
-                    int eno2 = ::pthread_mutex_consistent(mutex_);
-                    if (eno2 != 0) {
-                        ipc::error("fail pthread_mutex_lock[%d], pthread_mutex_consistent[%d]\n", eno, eno2);
-                        return false;
-                    }
-                    int eno3 = ::pthread_mutex_unlock(mutex_);
-                    if (eno3 != 0) {
-                        ipc::error("fail pthread_mutex_lock[%d], pthread_mutex_unlock[%d]\n", eno, eno3);
-                        return false;
-                    }
-                }
-                break; // loop again
-            default:
-                ipc::error("fail pthread_mutex_lock[%d]\n", eno);
-                return false;
-            }
-        }
-    }
-
-    bool try_lock() noexcept(false) {
-        if (!valid()) return false;
-        auto ts = detail::make_timespec(0);
-        int eno = ::pthread_mutex_timedlock(mutex_, &ts);
-        switch (eno) {
-        case 0:
-            return true;
-        case ETIMEDOUT:
-            return false;
-        case EOWNERDEAD: {
-                if (shm_->ref() > 1) {
-                    shm_->sub_ref();
-                }
-                int eno2 = ::pthread_mutex_consistent(mutex_);
-                if (eno2 != 0) {
-                    ipc::error("fail pthread_mutex_timedlock[%d], pthread_mutex_consistent[%d]\n", eno, eno2);
-                    break;
-                }
-                int eno3 = ::pthread_mutex_unlock(mutex_);
-                if (eno3 != 0) {
-                    ipc::error("fail pthread_mutex_timedlock[%d], pthread_mutex_unlock[%d]\n", eno, eno3);
-                    break;
-                }
-            }
-            break;
-        default:
-            ipc::error("fail pthread_mutex_timedlock[%d]\n", eno);
-            break;
-        }
-        throw std::system_error{eno, std::system_category()};
-    }
-
-    bool unlock() noexcept {
-        if (!valid()) return false;
-        int eno;
-        if ((eno = ::pthread_mutex_unlock(mutex_)) != 0) {
-            ipc::error("fail pthread_mutex_unlock[%d]\n", eno);
-            return false;
-        }
-        return true;
-    }
-};
-
-} // namespace sync
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/posix/semaphore_impl.h b/src/libipc/platform/posix/semaphore_impl.h
deleted file mode 100644
index 94a5350..0000000
--- a/src/libipc/platform/posix/semaphore_impl.h
+++ /dev/null
@@ -1,100 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-#include <fcntl.h>      /* For O_* constants */
-#include <sys/stat.h>   /* For mode constants */
-#include <semaphore.h>
-#include <errno.h>
-
-#include "libipc/utility/log.h"
-#include "libipc/shm.h"
-
-#include "get_wait_time.h"
-#include "get_error.h"
-
-namespace ipc {
-namespace detail {
-namespace sync {
-
-class semaphore {
-    ipc::shm::handle shm_;
-    sem_t *h_ = SEM_FAILED;
-
-public:
-    semaphore() = default;
-    ~semaphore() noexcept = default;
-
-    sem_t *native() const noexcept {
-        return h_;
-    }
-
-    bool valid() const noexcept {
-        return h_ != SEM_FAILED;
-    }
-
-    bool open(char const *name, std::uint32_t count) noexcept {
-        close();
-        if (!shm_.acquire(name, 1)) {
-            ipc::error("[open_semaphore] fail shm.acquire: %s\n", name);
-            return false;
-        }
-        h_ = ::sem_open(name, O_CREAT, 0666, static_cast<unsigned>(count));
-        if (h_ == SEM_FAILED) {
-            ipc::error("fail sem_open[%s]: name = %s\n", curr_error(), name);
-            return false;
-        }
-        return true;
-    }
-
-    void close() noexcept {
-        if (!valid()) return;
-        if (::sem_close(h_) != 0) {
-            ipc::error("fail sem_close[%s]\n", curr_error());
-        }
-        h_ = SEM_FAILED;
-        if (shm_.name() != nullptr) {
-            std::string name = shm_.name();
-            if (shm_.release() <= 1) {
-                if (::sem_unlink(name.c_str()) != 0) {
-                    ipc::error("fail sem_unlink[%s]: name = %s\n", curr_error(), name.c_str());
-                }
-            }
-        }
-    }
-
-    bool wait(std::uint64_t tm) noexcept {
-        if (!valid()) return false;
-        if (tm == invalid_value) {
-            if (::sem_wait(h_) != 0) {
-                ipc::error("fail sem_wait[%s]\n", curr_error());
-                return false;
-            }
-        } else {
-            auto ts = detail::make_timespec(tm);
-            if (::sem_timedwait(h_, &ts) != 0) {
-                if (errno != ETIMEDOUT) {
-                    ipc::error("fail sem_timedwait[%s]: tm = %zd, tv_sec = %ld, tv_nsec = %ld\n",
-                                curr_error(), tm, ts.tv_sec, ts.tv_nsec);
-                }
-                return false;
-            }
-        }
-        return true;
-    }
-
-    bool post(std::uint32_t count) noexcept {
-        if (!valid()) return false;
-        for (std::uint32_t i = 0; i < count; ++i) {
-            if (::sem_post(h_) != 0) {
-                ipc::error("fail sem_post[%s]\n", curr_error());
-                return false;
-            }
-        }
-        return true;
-    }
-};
-
-} // namespace sync
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/posix/shm_posix.cpp b/src/libipc/platform/posix/shm_posix.cpp
deleted file mode 100644
index 9bf09ca..0000000
--- a/src/libipc/platform/posix/shm_posix.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-#include <atomic>
-#include <string>
-#include <utility>
-#include <cstring>
-
-#include "libipc/shm.h"
-#include "libipc/def.h"
-#include "libipc/pool_alloc.h"
-
-#include "libipc/utility/log.h"
-#include "libipc/memory/resource.h"
-
-#include "get_error.h"
-
-namespace {
-
-struct info_t {
-    std::atomic<std::int32_t> acc_;
-};
-
-struct id_info_t {
-    int         fd_   = -1;
-    void*       mem_  = nullptr;
-    std::size_t size_ = 0;
-    ipc::string name_;
-};
-
-constexpr std::size_t calc_size(std::size_t size) {
-    return ((((size - 1) / alignof(info_t)) + 1) * alignof(info_t)) + sizeof(info_t);
-}
-
-inline auto& acc_of(void* mem, std::size_t size) {
-    return reinterpret_cast<info_t*>(static_cast<ipc::byte_t*>(mem) + size - sizeof(info_t))->acc_;
-}
-
-} // internal-linkage
-
-namespace ipc {
-namespace shm {
-
-id_t acquire(char const * name, std::size_t size, unsigned mode) {
-    if (name == nullptr || name[0] == '\0') {
-        ipc::error("fail acquire: name is empty\n");
-        return nullptr;
-    }
-    ipc::string op_name = ipc::string{"__IPC_SHM__"} + name;
-    // Open the object for read-write access.
-    int flag = O_RDWR;
-    switch (mode) {
-    case open:
-        size = 0;
-        break;
-    // The check for the existence of the object, 
-    // and its creation if it does not exist, are performed atomically.
-    case create:
-        flag |= O_CREAT | O_EXCL;
-        break;
-    // Create the shared memory object if it does not exist.
-    default:
-        flag |= O_CREAT;
-        break;
-    }
-    int fd = ::shm_open(op_name.c_str(), flag, S_IRUSR | S_IWUSR |
-                                               S_IRGRP | S_IWGRP |
-                                               S_IROTH | S_IWOTH);
-    if (fd == -1) {
-        ipc::error("fail shm_open[%s]: name = %s\n", curr_error(), name);
-        return nullptr;
-    }
-    auto ii = mem::alloc<id_info_t>();
-    ii->fd_   = fd;
-    ii->size_ = size;
-    ii->name_ = std::move(op_name);
-    return ii;
-}
-
-std::int32_t get_ref(id_t id) {
-    if (id == nullptr) {
-        return 0;
-    }
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ == nullptr || ii->size_ == 0) {
-        return 0;
-    }
-    return acc_of(ii->mem_, ii->size_).load(std::memory_order_acquire);
-}
-
-void sub_ref(id_t id) {
-    if (id == nullptr) {
-        ipc::error("fail sub_ref: invalid id (null)\n");
-        return;
-    }
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ == nullptr || ii->size_ == 0) {
-        ipc::error("fail sub_ref: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
-        return;
-    }
-    acc_of(ii->mem_, ii->size_).fetch_sub(1, std::memory_order_acq_rel);
-}
-
-void * get_mem(id_t id, std::size_t * size) {
-    if (id == nullptr) {
-        ipc::error("fail get_mem: invalid id (null)\n");
-        return nullptr;
-    }
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ != nullptr) {
-        if (size != nullptr) *size = ii->size_;
-        return ii->mem_;
-    }
-    int fd = ii->fd_;
-    if (fd == -1) {
-        ipc::error("fail get_mem: invalid id (fd = -1)\n");
-        return nullptr;
-    }
-    if (ii->size_ == 0) {
-        struct stat st;
-        if (::fstat(fd, &st) != 0) {
-            ipc::error("fail fstat[%s]: name = %s, size = %zd\n", curr_error(), ii->name_.c_str(), ii->size_);
-            return nullptr;
-        }
-        ii->size_ = static_cast<std::size_t>(st.st_size);
-        if ((ii->size_ <= sizeof(info_t)) || (ii->size_ % sizeof(info_t))) {
-            ipc::error("fail get_mem: %s, invalid size = %zd\n", ii->name_.c_str(), ii->size_);
-            return nullptr;
-        }
-    } else {
-        ii->size_ = calc_size(ii->size_);
-        if (::ftruncate(fd, static_cast<off_t>(ii->size_)) != 0) {
-            ipc::error("fail ftruncate[%s]: name = %s, size = %zd\n", curr_error(), ii->name_.c_str(), ii->size_);
-            return nullptr;
-        }
-    }
-    void* mem = ::mmap(nullptr, ii->size_, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-    if (mem == MAP_FAILED) {
-        ipc::error("fail mmap[%s]: name = %s, size = %zd\n", curr_error(), ii->name_.c_str(), ii->size_);
-        return nullptr;
-    }
-    ::close(fd);
-    ii->fd_  = -1;
-    ii->mem_ = mem;
-    if (size != nullptr) *size = ii->size_;
-    acc_of(mem, ii->size_).fetch_add(1, std::memory_order_release);
-    return mem;
-}
-
-std::int32_t release(id_t id) {
-    if (id == nullptr) {
-        ipc::error("fail release: invalid id (null)\n");
-        return -1;
-    }
-    std::int32_t ret = -1;
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ == nullptr || ii->size_ == 0) {
-        ipc::error("fail release: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
-    }
-    else if ((ret = acc_of(ii->mem_, ii->size_).fetch_sub(1, std::memory_order_acq_rel)) <= 1) {
-        ::munmap(ii->mem_, ii->size_);
-        if (!ii->name_.empty()) {
-            ::shm_unlink(ii->name_.c_str());
-        }
-    }
-    else ::munmap(ii->mem_, ii->size_);
-    mem::free(ii);
-    return ret;
-}
-
-void remove(id_t id) {
-    if (id == nullptr) {
-        ipc::error("fail remove: invalid id (null)\n");
-        return;
-    }
-    auto ii = static_cast<id_info_t*>(id);
-    auto name = std::move(ii->name_);
-    release(id);
-    if (!name.empty()) {
-        ::shm_unlink(name.c_str());
-    }
-}
-
-void remove(char const * name) {
-    if (name == nullptr || name[0] == '\0') {
-        ipc::error("fail remove: name is empty\n");
-        return;
-    }
-    ::shm_unlink((ipc::string{"__IPC_SHM__"} + name).c_str());
-}
-
-} // namespace shm
-} // namespace ipc
diff --git a/src/libipc/platform/win/condition.h b/src/libipc/platform/win/condition.h
deleted file mode 100644
index e477bff..0000000
--- a/src/libipc/platform/win/condition.h
+++ /dev/null
@@ -1,119 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <mutex>
-
-#include <Windows.h>
-
-#include "libipc/utility/log.h"
-#include "libipc/utility/scope_guard.h"
-#include "libipc/platform/detail.h"
-#include "libipc/mutex.h"
-#include "libipc/semaphore.h"
-#include "libipc/shm.h"
-
-namespace ipc {
-namespace detail {
-namespace sync {
-
-class condition {
-    ipc::sync::semaphore sem_;
-    ipc::sync::mutex lock_;
-    ipc::shm::handle shm_;
-
-    std::int32_t &counter() {
-        return *static_cast<std::int32_t *>(shm_.get());
-    }
-
-public:
-    condition() = default;
-    ~condition() noexcept = default;
-
-    auto native() noexcept {
-        return sem_.native();
-    }
-
-    auto native() const noexcept {
-        return sem_.native();
-    }
-
-    bool valid() const noexcept {
-        return sem_.valid() && lock_.valid() && shm_.valid();
-    }
-
-    bool open(char const *name) noexcept {
-        close();
-        if (!sem_.open((std::string{"_cond_sem_"} + name).c_str())) {
-            return false;
-        }
-        auto finally_sem = ipc::guard([this] { sem_.close(); }); // close when failed
-        if (!lock_.open((std::string{"_cond_lock_"} + name).c_str())) {
-            return false;
-        }
-        auto finally_lock = ipc::guard([this] { lock_.close(); }); // close when failed
-        if (!shm_.acquire((std::string{"_cond_shm_"} + name).c_str(), sizeof(std::int32_t))) {
-            return false;
-        }
-        finally_lock.dismiss();
-        finally_sem.dismiss();
-        return valid();
-    }
-
-    void close() noexcept {
-        if (!valid()) return;
-        sem_.close();
-        lock_.close();
-        shm_.release();
-    }
-
-    bool wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
-        if (!valid()) return false;
-        auto &cnt = counter();
-        {
-            IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> guard {lock_};
-            cnt = (cnt < 0) ? 1 : cnt + 1;
-        }
-        DWORD ms = (tm == invalid_value) ? INFINITE : static_cast<DWORD>(tm);
-        /**
-         * @see
-         *  - https://www.microsoft.com/en-us/research/wp-content/uploads/2004/12/ImplementingCVs.pdf
-         *  - https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-signalobjectandwait
-        */
-        bool rs = ::SignalObjectAndWait(mtx.native(), sem_.native(), ms, FALSE) == WAIT_OBJECT_0;
-        bool rl = mtx.lock(); // INFINITE
-        if (!rs) {
-            IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> guard {lock_};
-            cnt -= 1;
-        }
-        return rs && rl;
-    }
-
-    bool notify(ipc::sync::mutex &) noexcept {
-        if (!valid()) return false;
-        auto &cnt = counter();
-        if (!lock_.lock()) return false;
-        bool ret = false;
-        if (cnt > 0) {
-            ret = sem_.post(1);
-            cnt -= 1;
-        }
-        return lock_.unlock() && ret;
-    }
-
-    bool broadcast(ipc::sync::mutex &) noexcept {
-        if (!valid()) return false;
-        auto &cnt = counter();
-        if (!lock_.lock()) return false;
-        bool ret = false;
-        if (cnt > 0) {
-            ret = sem_.post(cnt);
-            cnt = 0;
-        }
-        return lock_.unlock() && ret;
-    }
-};
-
-} // namespace sync
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/win/get_sa.h b/src/libipc/platform/win/get_sa.h
deleted file mode 100644
index 74b68d4..0000000
--- a/src/libipc/platform/win/get_sa.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include <securitybaseapi.h>
-
-namespace ipc {
-namespace detail {
-
-inline LPSECURITY_ATTRIBUTES get_sa() {
-    static struct initiator {
-
-        SECURITY_DESCRIPTOR sd_;
-        SECURITY_ATTRIBUTES sa_;
-
-        bool succ_ = false;
-
-        initiator() {
-            if (!::InitializeSecurityDescriptor(&sd_, SECURITY_DESCRIPTOR_REVISION)) {
-                ipc::error("fail InitializeSecurityDescriptor[%d]\n", static_cast<int>(::GetLastError()));
-                return;
-            }
-            if (!::SetSecurityDescriptorDacl(&sd_, TRUE, NULL, FALSE)) {
-                ipc::error("fail SetSecurityDescriptorDacl[%d]\n", static_cast<int>(::GetLastError()));
-                return;
-            }
-            sa_.nLength = sizeof(SECURITY_ATTRIBUTES);
-            sa_.bInheritHandle = FALSE;
-            sa_.lpSecurityDescriptor = &sd_;
-            succ_ = true;
-        }
-    } handle;
-    return handle.succ_ ? &handle.sa_ : nullptr;
-}
-
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/win/mutex.h b/src/libipc/platform/win/mutex.h
deleted file mode 100644
index 68968c4..0000000
--- a/src/libipc/platform/win/mutex.h
+++ /dev/null
@@ -1,96 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <system_error>
-
-#include <Windows.h>
-
-#include "libipc/utility/log.h"
-
-#include "to_tchar.h"
-#include "get_sa.h"
-
-namespace ipc {
-namespace detail {
-namespace sync {
-
-class mutex {
-    HANDLE h_ = NULL;
-
-public:
-    mutex() noexcept = default;
-    ~mutex() noexcept = default;
-
-    HANDLE native() const noexcept {
-        return h_;
-    }
-
-    bool valid() const noexcept {
-        return h_ != NULL;
-    }
-
-    bool open(char const *name) noexcept {
-        close();
-        h_ = ::CreateMutex(detail::get_sa(), FALSE, ipc::detail::to_tchar(name).c_str());
-        if (h_ == NULL) {
-            ipc::error("fail CreateMutex[%lu]: %s\n", ::GetLastError(), name);
-            return false;
-        }
-        return true;
-    }
-
-    void close() noexcept {
-        if (!valid()) return;
-        ::CloseHandle(h_);
-        h_ = NULL;
-    }
-
-    bool lock(std::uint64_t tm) noexcept {
-        DWORD ret, ms = (tm == invalid_value) ? INFINITE : static_cast<DWORD>(tm);
-        for(;;) {
-            switch ((ret = ::WaitForSingleObject(h_, ms))) {
-            case WAIT_OBJECT_0:
-                return true;
-            case WAIT_TIMEOUT:
-                return false;
-            case WAIT_ABANDONED:
-                ipc::log("fail WaitForSingleObject[%lu]: WAIT_ABANDONED, try again.\n", ::GetLastError());
-                if (!unlock()) {
-                    return false;
-                }
-                break; // loop again
-            default:
-                ipc::error("fail WaitForSingleObject[%lu]: 0x%08X\n", ::GetLastError(), ret);
-                return false;
-            }
-        }
-    }
-
-    bool try_lock() noexcept(false) {
-        DWORD ret = ::WaitForSingleObject(h_, 0);
-        switch (ret) {
-        case WAIT_OBJECT_0:
-            return true;
-        case WAIT_TIMEOUT:
-            return false;
-        case WAIT_ABANDONED:
-            unlock();
-            IPC_FALLTHROUGH_;
-        default:
-            ipc::error("fail WaitForSingleObject[%lu]: 0x%08X\n", ::GetLastError(), ret);
-            throw std::system_error{static_cast<int>(ret), std::system_category()};
-        }
-    }
-
-    bool unlock() noexcept {
-        if (!::ReleaseMutex(h_)) {
-            ipc::error("fail ReleaseMutex[%lu]\n", ::GetLastError());
-            return false;
-        }
-        return true;
-    }
-};
-
-} // namespace sync
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/win/semaphore.h b/src/libipc/platform/win/semaphore.h
deleted file mode 100644
index 47fd45d..0000000
--- a/src/libipc/platform/win/semaphore.h
+++ /dev/null
@@ -1,74 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-#include <Windows.h>
-
-#include "libipc/utility/log.h"
-
-#include "to_tchar.h"
-#include "get_sa.h"
-
-namespace ipc {
-namespace detail {
-namespace sync {
-
-class semaphore {
-    HANDLE h_ = NULL;
-
-public:
-    semaphore() noexcept = default;
-    ~semaphore() noexcept = default;
-
-    HANDLE native() const noexcept {
-        return h_;
-    }
-
-    bool valid() const noexcept {
-        return h_ != NULL;
-    }
-
-    bool open(char const *name, std::uint32_t count) noexcept {
-        close();
-        h_ = ::CreateSemaphore(detail::get_sa(), 
-                               static_cast<LONG>(count), LONG_MAX, 
-                               ipc::detail::to_tchar(name).c_str());
-        if (h_ == NULL) {
-            ipc::error("fail CreateSemaphore[%lu]: %s\n", ::GetLastError(), name);
-            return false;
-        }
-        return true;
-    }
-
-    void close() noexcept {
-        if (!valid()) return;
-        ::CloseHandle(h_);
-        h_ = NULL;
-    }
-
-    bool wait(std::uint64_t tm) noexcept {
-        DWORD ret, ms = (tm == invalid_value) ? INFINITE : static_cast<DWORD>(tm);
-        switch ((ret = ::WaitForSingleObject(h_, ms))) {
-        case WAIT_OBJECT_0:
-            return true;
-        case WAIT_TIMEOUT:
-            return false;
-        case WAIT_ABANDONED:
-        default:
-            ipc::error("fail WaitForSingleObject[%lu]: 0x%08X\n", ::GetLastError(), ret);
-            return false;
-        }
-    }
-
-    bool post(std::uint32_t count) noexcept {
-        if (!::ReleaseSemaphore(h_, static_cast<LONG>(count), NULL)) {
-            ipc::error("fail ReleaseSemaphore[%lu]\n", ::GetLastError());
-            return false;
-        }
-        return true;
-    }
-};
-
-} // namespace sync
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/win/shm_win.cpp b/src/libipc/platform/win/shm_win.cpp
deleted file mode 100755
index 366e8bd..0000000
--- a/src/libipc/platform/win/shm_win.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-
-#include <Windows.h>
-
-#include <string>
-#include <utility>
-
-#include "libipc/shm.h"
-#include "libipc/def.h"
-#include "libipc/pool_alloc.h"
-
-#include "libipc/utility/log.h"
-#include "libipc/memory/resource.h"
-
-#include "to_tchar.h"
-#include "get_sa.h"
-
-namespace {
-
-struct id_info_t {
-    HANDLE      h_    = NULL;
-    void*       mem_  = nullptr;
-    std::size_t size_ = 0;
-};
-
-} // internal-linkage
-
-namespace ipc {
-namespace shm {
-
-id_t acquire(char const * name, std::size_t size, unsigned mode) {
-    if (name == nullptr || name[0] == '\0') {
-        ipc::error("fail acquire: name is empty\n");
-        return nullptr;
-    }
-    HANDLE h;
-    auto fmt_name = ipc::detail::to_tchar(ipc::string{"__IPC_SHM__"} + name);
-    // Opens a named file mapping object.
-    if (mode == open) {
-        h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());
-    }
-    // Creates or opens a named file mapping object for a specified file.
-    else {
-        h = ::CreateFileMapping(INVALID_HANDLE_VALUE, detail::get_sa(), PAGE_READWRITE | SEC_COMMIT,
-                                0, static_cast<DWORD>(size), fmt_name.c_str());
-        // If the object exists before the function call, the function returns a handle to the existing object 
-        // (with its current size, not the specified size), and GetLastError returns ERROR_ALREADY_EXISTS.
-        if ((mode == create) && (::GetLastError() == ERROR_ALREADY_EXISTS)) {
-            ::CloseHandle(h);
-            h = NULL;
-        }
-    }
-    if (h == NULL) {
-        ipc::error("fail CreateFileMapping/OpenFileMapping[%d]: %s\n", static_cast<int>(::GetLastError()), name);
-        return nullptr;
-    }
-    auto ii = mem::alloc<id_info_t>();
-    ii->h_    = h;
-    ii->size_ = size;
-    return ii;
-}
-
-std::int32_t get_ref(id_t) {
-    return 0;
-}
-
-void sub_ref(id_t) {
-    // Do Nothing.
-}
-
-void * get_mem(id_t id, std::size_t * size) {
-    if (id == nullptr) {
-        ipc::error("fail get_mem: invalid id (null)\n");
-        return nullptr;
-    }
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ != nullptr) {
-        if (size != nullptr) *size = ii->size_;
-        return ii->mem_;
-    }
-    if (ii->h_ == NULL) {
-        ipc::error("fail to_mem: invalid id (h = null)\n");
-        return nullptr;
-    }
-    LPVOID mem = ::MapViewOfFile(ii->h_, FILE_MAP_ALL_ACCESS, 0, 0, 0);
-    if (mem == NULL) {
-        ipc::error("fail MapViewOfFile[%d]\n", static_cast<int>(::GetLastError()));
-        return nullptr;
-    }
-    MEMORY_BASIC_INFORMATION mem_info;
-    if (::VirtualQuery(mem, &mem_info, sizeof(mem_info)) == 0) {
-        ipc::error("fail VirtualQuery[%d]\n", static_cast<int>(::GetLastError()));
-        return nullptr;
-    }
-    ii->mem_  = mem;
-    ii->size_ = static_cast<std::size_t>(mem_info.RegionSize);
-    if (size != nullptr) *size = ii->size_;
-    return static_cast<void *>(mem);
-}
-
-std::int32_t release(id_t id) {
-    if (id == nullptr) {
-        ipc::error("fail release: invalid id (null)\n");
-        return -1;
-    }
-    auto ii = static_cast<id_info_t*>(id);
-    if (ii->mem_ == nullptr || ii->size_ == 0) {
-        ipc::error("fail release: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
-    }
-    else ::UnmapViewOfFile(static_cast<LPCVOID>(ii->mem_));
-    if (ii->h_ == NULL) {
-        ipc::error("fail release: invalid id (h = null)\n");
-    }
-    else ::CloseHandle(ii->h_);
-    mem::free(ii);
-    return 0;
-}
-
-void remove(id_t id) {
-    if (id == nullptr) {
-        ipc::error("fail release: invalid id (null)\n");
-        return;
-    }
-    release(id);
-}
-
-void remove(char const * name) {
-    if (name == nullptr || name[0] == '\0') {
-        ipc::error("fail remove: name is empty\n");
-        return;
-    }
-    // Do Nothing.
-}
-
-} // namespace shm
-} // namespace ipc
diff --git a/src/libipc/platform/win/to_tchar.h b/src/libipc/platform/win/to_tchar.h
deleted file mode 100755
index 892177e..0000000
--- a/src/libipc/platform/win/to_tchar.h
+++ /dev/null
@@ -1,74 +0,0 @@
-#pragma once
-
-#include <Windows.h>
-
-#include <type_traits>
-#include <string>
-#include <locale>
-#include <codecvt>
-#include <cstring>
-#include <stdexcept>
-#include <cstddef>
-
-#include "libipc/utility/concept.h"
-#include "libipc/memory/resource.h"
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-namespace detail {
-
-struct has_value_type_ {
-    template <typename T> static std::true_type  check(typename T::value_type *);
-    template <typename T> static std::false_type check(...);
-};
-
-template <typename T, typename U, typename = decltype(has_value_type_::check<U>(nullptr))>
-struct is_same_char : std::is_same<T, U> {};
-
-template <typename T, typename U>
-struct is_same_char<T, U, std::true_type> : std::is_same<T, typename U::value_type> {};
-
-template <typename T, typename S, typename R = S>
-using IsSameChar = ipc::require<is_same_char<T, S>::value, R>;
-
-////////////////////////////////////////////////////////////////
-/// to_tchar implementation
-////////////////////////////////////////////////////////////////
-
-template <typename T = TCHAR>
-constexpr auto to_tchar(ipc::string &&str) -> IsSameChar<T, ipc::string, ipc::string &&> {
-    return std::move(str); // noconv
-}
-
-/**
- * @remarks codecvt_utf8_utf16/std::wstring_convert is deprecated
- * @see https://codingtidbit.com/2020/02/09/c17-codecvt_utf8-is-deprecated/
- *      https://stackoverflow.com/questions/42946335/deprecated-header-codecvt-replacement
- *      https://en.cppreference.com/w/cpp/locale/codecvt/in
- *      https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-multibytetowidechar
-*/
-template <typename T = TCHAR>
-auto to_tchar(ipc::string &&external) -> IsSameChar<T, ipc::wstring> {
-    if (external.empty()) {
-        return {}; // noconv
-    }
-    /**
-     * CP_ACP       : The system default Windows ANSI code page.
-     * CP_MACCP     : The current system Macintosh code page.
-     * CP_OEMCP     : The current system OEM code page.
-     * CP_SYMBOL    : Symbol code page (42).
-     * CP_THREAD_ACP: The Windows ANSI code page for the current thread.
-     * CP_UTF7      : UTF-7. Use this value only when forced by a 7-bit transport mechanism. Use of UTF-8 is preferred.
-     * CP_UTF8      : UTF-8.
-    */
-    int size_needed = ::MultiByteToWideChar(CP_UTF8, 0, &external[0], (int)external.size(), NULL, 0);
-    if (size_needed <= 0) {
-        return {};
-    }
-    ipc::wstring internal(size_needed, L'\0');
-    ::MultiByteToWideChar(CP_UTF8, 0, &external[0], (int)external.size(), &internal[0], size_needed);
-    return internal;
-}
-
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/policy.h b/src/libipc/policy.h
deleted file mode 100755
index 8959607..0000000
--- a/src/libipc/policy.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include <type_traits>
-
-#include "libipc/def.h"
-#include "libipc/prod_cons.h"
-
-#include "libipc/circ/elem_array.h"
-
-namespace ipc {
-namespace policy {
-
-template <template <typename, std::size_t...> class Elems, typename Flag>
-struct choose;
-
-template <typename Flag>
-struct choose<circ::elem_array, Flag> {
-    using flag_t = Flag;
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    using elems_t = circ::elem_array<ipc::prod_cons_impl<flag_t>, DataSize, AlignSize>;
-};
-
-} // namespace policy
-} // namespace ipc
diff --git a/src/libipc/pool_alloc.cpp b/src/libipc/pool_alloc.cpp
deleted file mode 100755
index d19a13c..0000000
--- a/src/libipc/pool_alloc.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "libipc/pool_alloc.h"
-
-#include "libipc/memory/resource.h"
-
-namespace ipc {
-namespace mem {
-
-void* pool_alloc::alloc(std::size_t size) {
-    return async_pool_alloc::alloc(size);
-}
-
-void pool_alloc::free(void* p, std::size_t size) {
-    async_pool_alloc::free(p, size);
-}
-
-} // namespace mem
-} // namespace ipc
diff --git a/src/libipc/prod_cons.h b/src/libipc/prod_cons.h
deleted file mode 100755
index 1763209..0000000
--- a/src/libipc/prod_cons.h
+++ /dev/null
@@ -1,315 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <utility>
-#include <cstring>
-#include <type_traits>
-#include <cstdint>
-
-#include "libipc/def.h"
-
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_def.h"
-#include "libipc/utility/log.h"
-#include "libipc/utility/utility.h"
-
-namespace ipc {
-
-////////////////////////////////////////////////////////////////
-/// producer-consumer implementation
-////////////////////////////////////////////////////////////////
-
-template <typename Flag>
-struct prod_cons_impl;
-
-template <>
-struct prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> rd_; // read index
-    alignas(cache_line_size) std::atomic<circ::u2_t> wt_; // write index
-
-    constexpr circ::u2_t cursor() const noexcept {
-        return 0;
-    }
-
-    template <typename F, typename E>
-    bool push(F&& f, E* elems) {
-        auto cur_wt = circ::index_of(wt_.load(std::memory_order_relaxed));
-        if (cur_wt == circ::index_of(rd_.load(std::memory_order_acquire) - 1)) {
-            return false; // full
-        }
-        std::forward<F>(f)(&(elems[cur_wt].data_));
-        wt_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-
-    template <typename F, typename E>
-    bool pop(circ::u2_t& /*cur*/, F&& f, E* elems) {
-        auto cur_rd = circ::index_of(rd_.load(std::memory_order_relaxed));
-        if (cur_rd == circ::index_of(wt_.load(std::memory_order_acquire))) {
-            return false; // empty
-        }
-        std::forward<F>(f)(&(elems[cur_rd].data_));
-        rd_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::single, relat::multi , trans::unicast>>
-     : prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
-
-    template <typename F, 
-              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
-    bool pop(circ::u2_t& /*cur*/, F&& f, E<DS, AS>* elems) {
-        for (unsigned k = 0;;) {
-            auto cur_rd = rd_.load(std::memory_order_relaxed);
-            if (circ::index_of(cur_rd) ==
-                circ::index_of(wt_.load(std::memory_order_acquire))) {
-                return false; // empty
-            }
-            if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
-                std::forward<F>(f)(&(elems[circ::index_of(cur_rd)].data_));
-                return true;
-            }
-            ipc::yield(k);
-        }
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::multi , relat::multi, trans::unicast>>
-     : prod_cons_impl<wr<relat::single, relat::multi, trans::unicast>> {
-
-    using flag_t = std::uint64_t;
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-        std::atomic<flag_t> f_ct_ { 0 }; // commit flag
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> ct_; // commit index
-
-    template <typename F, typename E>
-    bool push(F&& f, E* elems) {
-        circ::u2_t cur_ct, nxt_ct;
-        for (unsigned k = 0;;) {
-            cur_ct = ct_.load(std::memory_order_relaxed);
-            if (circ::index_of(nxt_ct = cur_ct + 1) ==
-                circ::index_of(rd_.load(std::memory_order_acquire))) {
-                return false; // full
-            }
-            if (ct_.compare_exchange_weak(cur_ct, nxt_ct, std::memory_order_acq_rel)) {
-                break;
-            }
-            ipc::yield(k);
-        }
-        auto* el = elems + circ::index_of(cur_ct);
-        std::forward<F>(f)(&(el->data_));
-        // set flag & try update wt
-        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
-        while (1) {
-            auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
-            if (cur_ct != wt_.load(std::memory_order_relaxed)) {
-                return true;
-            }
-            if ((~cac_ct) != cur_ct) {
-                return true;
-            }
-            if (!el->f_ct_.compare_exchange_strong(cac_ct, 0, std::memory_order_relaxed)) {
-                return true;
-            }
-            wt_.store(nxt_ct, std::memory_order_release);
-            cur_ct = nxt_ct;
-            nxt_ct = cur_ct + 1;
-            el = elems + circ::index_of(cur_ct);
-        }
-        return true;
-    }
-
-    template <typename F, 
-              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
-    bool pop(circ::u2_t& /*cur*/, F&& f, E<DS, AS>* elems) {
-        for (unsigned k = 0;;) {
-            auto cur_rd = rd_.load(std::memory_order_relaxed);
-            auto cur_wt = wt_.load(std::memory_order_acquire);
-            auto id_rd  = circ::index_of(cur_rd);
-            auto id_wt  = circ::index_of(cur_wt);
-            if (id_rd == id_wt) {
-                auto* el = elems + id_wt;
-                auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
-                if ((~cac_ct) != cur_wt) {
-                    return false; // empty
-                }
-                if (el->f_ct_.compare_exchange_weak(cac_ct, 0, std::memory_order_relaxed)) {
-                    wt_.store(cur_wt + 1, std::memory_order_release);
-                }
-                k = 0;
-            }
-            else if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
-                std::forward<F>(f)(&(elems[id_rd].data_));
-                return true;
-            }
-            ipc::yield(k);
-        }
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::single, relat::multi, trans::broadcast>> {
-
-    using flag_t = std::uint64_t;
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-        std::atomic<flag_t> f_rc_ { 0 }; // read-flag
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> wt_;   // write index
-
-    circ::u2_t cursor() const noexcept {
-        return wt_.load(std::memory_order_acquire);
-    }
-
-    template <typename F, typename E>
-    bool push(F&& f, E* elems) {
-        E* el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
-        auto cur_rc = el->f_rc_.exchange(~0ull, std::memory_order_acq_rel);
-        // check for consumers to read this element
-        if (cur_rc != 0) {
-            return false; // full
-        }
-        std::forward<F>(f)(&(el->data_));
-        wt_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-
-    template <typename F, typename E>
-    bool pop(circ::u2_t& cur, F&& f, E* elems) {
-        if (cur == cursor()) return false; // empty
-        E* el = elems + circ::index_of(cur++);
-        std::forward<F>(f)(&(el->data_));
-        el->f_rc_.store(0, std::memory_order_release);
-        return true;
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::multi, relat::multi, trans::broadcast>> {
-
-    using flag_t = std::uint64_t;
-
-    enum : flag_t {
-        pushing = 1ull,
-        pushed  = ~0ull,
-        popped  = 0ull,
-    };
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-        std::atomic<flag_t> f_rc_ { 0 }; // read-flag
-        std::atomic<flag_t> f_ct_ { 0 }; // commit-flag
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> ct_;   // commit index
-    alignas(cache_line_size) std::atomic<circ::u2_t> wt_;   // write index
-
-    circ::u2_t cursor() const noexcept {
-        return wt_.load(std::memory_order_acquire);
-    }
-
-    template <typename F, typename E>
-    bool push(F&& f, E* elems) {
-        E* el;
-        circ::u2_t cur_ct, nxt_ct;
-        for (unsigned k = 0;;) {
-            auto cac_ct = ct_.load(std::memory_order_relaxed);
-            cur_ct = cac_ct;
-            nxt_ct = cur_ct + 1;
-            el = elems + circ::index_of(cac_ct);
-            for (unsigned k = 0;;) {
-                auto cur_rc = el->f_rc_.load(std::memory_order_acquire);
-                switch (cur_rc) {
-                // helper
-                case pushing:
-                    ct_.compare_exchange_strong(cac_ct, nxt_ct, std::memory_order_release);
-                    goto try_next;
-                // full
-                case pushed:
-                    return false;
-                // writable
-                default:
-                    break;
-                }
-                if (el->f_rc_.compare_exchange_weak(cur_rc, pushing, std::memory_order_release)) {
-                    break;
-                }
-                ipc::yield(k);
-            }
-            ct_.compare_exchange_strong(cac_ct, nxt_ct, std::memory_order_relaxed);
-            el->f_rc_.store(pushed, std::memory_order_relaxed);
-            std::atomic_thread_fence(std::memory_order_release);
-            break;
-        try_next:
-            ipc::yield(k);
-        }
-        std::forward<F>(f)(&(el->data_));
-        // set flag & try update wt
-        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
-        while (1) {
-            auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
-            if (cur_ct != wt_.load(std::memory_order_relaxed)) {
-                return true;
-            }
-            if ((~cac_ct) != cur_ct) {
-                return true;
-            }
-            if (!el->f_ct_.compare_exchange_strong(cac_ct, 0, std::memory_order_relaxed)) {
-                return true;
-            }
-            wt_.store(nxt_ct, std::memory_order_release);
-            cur_ct = nxt_ct;
-            nxt_ct = cur_ct + 1;
-            el = elems + circ::index_of(cur_ct);
-        }
-        return true;
-    }
-
-    template <typename F, typename E, std::size_t N>
-    bool pop(circ::u2_t& cur, F&& f, E(& elems)[N]) {
-        for (unsigned k = 0;;) {
-            auto cur_wt = wt_.load(std::memory_order_acquire);
-            auto id_rd  = circ::index_of(cur);
-            auto id_wt  = circ::index_of(cur_wt);
-            if (id_rd == id_wt) {
-                auto* el = elems + id_wt;
-                auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
-                if ((~cac_ct) != cur_wt) {
-                    return false; // empty
-                }
-                if (el->f_ct_.compare_exchange_weak(cac_ct, 0, std::memory_order_relaxed)) {
-                    wt_.store(cur_wt + 1, std::memory_order_release);
-                }
-                k = 0;
-            }
-            else {
-                ++cur;
-                auto* el = elems + id_rd;
-                std::forward<F>(f)(&(el->data_));
-                el->f_rc_.store(popped, std::memory_order_release);
-                return true;
-            }
-            ipc::yield(k);
-        }
-    }
-};
-
-} // namespace ipc
diff --git a/src/libipc/queue.h b/src/libipc/queue.h
deleted file mode 100755
index 5fe77a2..0000000
--- a/src/libipc/queue.h
+++ /dev/null
@@ -1,198 +0,0 @@
-#pragma once
-
-#include <type_traits>
-#include <new>
-#include <utility>  // [[since C++14]]: std::exchange
-#include <algorithm>
-#include <atomic>
-#include <tuple>
-#include <thread>
-#include <chrono>
-#include <string>
-#include <cassert>  // assert
-
-#include "libipc/def.h"
-#include "libipc/shm.h"
-#include "libipc/rw_lock.h"
-
-#include "libipc/utility/log.h"
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_def.h"
-
-namespace ipc {
-namespace detail {
-
-class queue_conn {
-protected:
-    circ::cc_t connected_ = 0;
-    shm::handle elems_h_;
-
-    template <typename Elems>
-    Elems* open(char const * name) {
-        if (name == nullptr || name[0] == '\0') {
-            ipc::error("fail open waiter: name is empty!\n");
-            return nullptr;
-        }
-        if (!elems_h_.acquire(name, sizeof(Elems))) {
-            return nullptr;
-        }
-        auto elems = static_cast<Elems*>(elems_h_.get());
-        if (elems == nullptr) {
-            ipc::error("fail acquire elems: %s\n", name);
-            return nullptr;
-        }
-        elems->init();
-        return elems;
-    }
-
-    void close() {
-        elems_h_.release();
-    }
-
-public:
-    queue_conn() = default;
-    queue_conn(const queue_conn&) = delete;
-    queue_conn& operator=(const queue_conn&) = delete;
-
-    bool connected() const noexcept {
-        return connected_ != 0;
-    }
-
-    circ::cc_t connected_id() const noexcept {
-        return connected_;
-    }
-
-    template <typename Elems>
-    auto connect(Elems* elems) noexcept
-                         /*needs 'optional' here*/
-     -> std::tuple<bool, bool, decltype(std::declval<Elems>().cursor())> {
-        if (elems == nullptr) return {};
-        // if it's already connected, just return
-        if (connected()) return {connected(), false, 0};
-        connected_ = elems->connect_receiver();
-        return {connected(), true, elems->cursor()};
-    }
-
-    template <typename Elems>
-    bool disconnect(Elems* elems) noexcept {
-        if (elems == nullptr) return false;
-        // if it's already disconnected, just return false
-        if (!connected()) return false;
-        elems->disconnect_receiver(std::exchange(connected_, 0));
-        return true;
-    }
-};
-
-template <typename Elems>
-class queue_base : public queue_conn {
-    using base_t = queue_conn;
-
-public:
-    using elems_t  = Elems;
-    using policy_t = typename elems_t::policy_t;
-
-protected:
-    elems_t * elems_ = nullptr;
-    decltype(std::declval<elems_t>().cursor()) cursor_ = 0;
-    bool sender_flag_ = false;
-
-public:
-    using base_t::base_t;
-
-    queue_base() = default;
-
-    explicit queue_base(char const * name)
-        : queue_base{} {
-        elems_ = open<elems_t>(name);
-    }
-
-    explicit queue_base(elems_t * elems) noexcept
-        : queue_base{} {
-        assert(elems != nullptr);
-        elems_ = elems;
-    }
-
-    /* not virtual */ ~queue_base() {
-        base_t::close();
-    }
-
-    elems_t       * elems()       noexcept { return elems_; }
-    elems_t const * elems() const noexcept { return elems_; }
-
-    bool ready_sending() noexcept {
-        if (elems_ == nullptr) return false;
-        return sender_flag_ || (sender_flag_ = elems_->connect_sender());
-    }
-
-    void shut_sending() noexcept {
-        if (elems_ == nullptr) return;
-        if (!sender_flag_) return;
-        elems_->disconnect_sender();
-    }
-
-    bool connect() noexcept {
-        auto tp = base_t::connect(elems_);
-        if (std::get<0>(tp) && std::get<1>(tp)) {
-            cursor_ = std::get<2>(tp);
-            return true;
-        }
-        return std::get<0>(tp);
-    }
-
-    bool disconnect() noexcept {
-        return base_t::disconnect(elems_);
-    }
-
-    std::size_t conn_count() const noexcept {
-        return (elems_ == nullptr) ? static_cast<std::size_t>(invalid_value) : elems_->conn_count();
-    }
-
-    bool valid() const noexcept {
-        return elems_ != nullptr;
-    }
-
-    bool empty() const noexcept {
-        return !valid() || (cursor_ == elems_->cursor());
-    }
-
-    template <typename T, typename F, typename... P>
-    bool push(F&& prep, P&&... params) {
-        if (elems_ == nullptr) return false;
-        return elems_->push([&](void* p) {
-            if (prep(p)) ::new (p) T(std::forward<P>(params)...);
-        });
-    }
-
-    template <typename T>
-    bool pop(T& item) {
-        if (elems_ == nullptr) {
-            return false;
-        }
-        return elems_->pop(&(this->cursor_), [&item](void* p) {
-            ::new (&item) T(std::move(*static_cast<T*>(p)));
-        });
-    }
-};
-
-} // namespace detail
-
-template <typename T, typename Policy>
-class queue final : public detail::queue_base<typename Policy::template elems_t<sizeof(T), alignof(T)>> {
-    using base_t = detail::queue_base<typename Policy::template elems_t<sizeof(T), alignof(T)>>;
-
-public:
-    using value_t = T;
-
-    using base_t::base_t;
-
-    template <typename... P>
-    bool push(P&&... params) {
-        return base_t::template push<T>(std::forward<P>(params)...);
-    }
-
-    bool pop(T& item) {
-        return base_t::pop(item);
-    }
-};
-
-} // namespace ipc
diff --git a/src/libipc/shm.cpp b/src/libipc/shm.cpp
deleted file mode 100755
index 92f96ef..0000000
--- a/src/libipc/shm.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-
-#include <string>
-#include <utility>
-
-#include "libipc/shm.h"
-
-#include "libipc/utility/pimpl.h"
-#include "libipc/memory/resource.h"
-
-namespace ipc {
-namespace shm {
-
-class handle::handle_ : public pimpl<handle_> {
-public:
-    shm::id_t id_ = nullptr;
-    void*     m_  = nullptr;
-
-    ipc::string n_;
-    std::size_t s_ = 0;
-};
-
-handle::handle()
-    : p_(p_->make()) {
-}
-
-handle::handle(char const * name, std::size_t size, unsigned mode)
-    : handle() {
-    acquire(name, size, mode);
-}
-
-handle::handle(handle&& rhs)
-    : handle() {
-    swap(rhs);
-}
-
-handle::~handle() {
-    release();
-    p_->clear();
-}
-
-void handle::swap(handle& rhs) {
-    std::swap(p_, rhs.p_);
-}
-
-handle& handle::operator=(handle rhs) {
-    swap(rhs);
-    return *this;
-}
-
-bool handle::valid() const noexcept {
-    return impl(p_)->m_ != nullptr;
-}
-
-std::size_t handle::size() const noexcept {
-    return impl(p_)->s_;
-}
-
-char const * handle::name() const noexcept {
-    return impl(p_)->n_.c_str();
-}
-
-std::int32_t handle::ref() const noexcept {
-    return shm::get_ref(impl(p_)->id_);
-}
-
-void handle::sub_ref() noexcept {
-    shm::sub_ref(impl(p_)->id_);
-}
-
-bool handle::acquire(char const * name, std::size_t size, unsigned mode) {
-    release();
-    impl(p_)->id_ = shm::acquire((impl(p_)->n_ = name).c_str(), size, mode);
-    impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
-    return valid();
-}
-
-std::int32_t handle::release() {
-    if (impl(p_)->id_ == nullptr) return -1;
-    return shm::release(detach());
-}
-
-void* handle::get() const {
-    return impl(p_)->m_;
-}
-
-void handle::attach(id_t id) {
-    if (id == nullptr) return;
-    release();
-    impl(p_)->id_ = id;
-    impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
-}
-
-id_t handle::detach() {
-    auto old = impl(p_)->id_;
-    impl(p_)->id_ = nullptr;
-    impl(p_)->m_  = nullptr;
-    impl(p_)->s_  = 0;
-    impl(p_)->n_.clear();
-    return old;
-}
-
-} // namespace shm
-} // namespace ipc
diff --git a/src/libipc/sync/condition.cpp b/src/libipc/sync/condition.cpp
deleted file mode 100644
index 06d90e1..0000000
--- a/src/libipc/sync/condition.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-
-#include "libipc/condition.h"
-
-#include "libipc/utility/pimpl.h"
-#include "libipc/memory/resource.h"
-#include "libipc/platform/detail.h"
-#if defined(IPC_OS_WINDOWS_)
-#include "libipc/platform/win/condition.h"
-#elif defined(IPC_OS_LINUX_)
-#include "libipc/platform/linux/condition.h"
-#elif defined(IPC_OS_QNX_)
-#include "libipc/platform/posix/condition.h"
-#else/*IPC_OS*/
-#   error "Unsupported platform."
-#endif
-
-namespace ipc {
-namespace sync {
-
-class condition::condition_ : public ipc::pimpl<condition_> {
-public:
-    ipc::detail::sync::condition cond_;
-};
-
-condition::condition()
-    : p_(p_->make()) {
-}
-
-condition::condition(char const * name)
-    : condition() {
-    open(name);
-}
-
-condition::~condition() {
-    close();
-    p_->clear();
-}
-
-void const *condition::native() const noexcept {
-    return impl(p_)->cond_.native();
-}
-
-void *condition::native() noexcept {
-    return impl(p_)->cond_.native();
-}
-
-bool condition::valid() const noexcept {
-    return impl(p_)->cond_.valid();
-}
-
-bool condition::open(char const *name) noexcept {
-    return impl(p_)->cond_.open(name);
-}
-
-void condition::close() noexcept {
-    impl(p_)->cond_.close();
-}
-
-bool condition::wait(ipc::sync::mutex &mtx, std::uint64_t tm) noexcept {
-    return impl(p_)->cond_.wait(mtx, tm);
-}
-
-bool condition::notify(ipc::sync::mutex &mtx) noexcept {
-    return impl(p_)->cond_.notify(mtx);
-}
-
-bool condition::broadcast(ipc::sync::mutex &mtx) noexcept {
-    return impl(p_)->cond_.broadcast(mtx);
-}
-
-} // namespace sync
-} // namespace ipc
diff --git a/src/libipc/sync/mutex.cpp b/src/libipc/sync/mutex.cpp
deleted file mode 100644
index 79f1a91..0000000
--- a/src/libipc/sync/mutex.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-
-#include "libipc/mutex.h"
-
-#include "libipc/utility/pimpl.h"
-#include "libipc/memory/resource.h"
-#include "libipc/platform/detail.h"
-#if defined(IPC_OS_WINDOWS_)
-#include "libipc/platform/win/mutex.h"
-#elif defined(IPC_OS_LINUX_)
-#include "libipc/platform/linux/mutex.h"
-#elif defined(IPC_OS_QNX_)
-#include "libipc/platform/posix/mutex.h"
-#else/*IPC_OS*/
-#   error "Unsupported platform."
-#endif
-
-namespace ipc {
-namespace sync {
-
-class mutex::mutex_ : public ipc::pimpl<mutex_> {
-public:
-    ipc::detail::sync::mutex lock_;
-};
-
-mutex::mutex()
-    : p_(p_->make()) {
-}
-
-mutex::mutex(char const * name)
-    : mutex() {
-    open(name);
-}
-
-mutex::~mutex() {
-    close();
-    p_->clear();
-}
-
-void const *mutex::native() const noexcept {
-    return impl(p_)->lock_.native();
-}
-
-void *mutex::native() noexcept {
-    return impl(p_)->lock_.native();
-}
-
-bool mutex::valid() const noexcept {
-    return impl(p_)->lock_.valid();
-}
-
-bool mutex::open(char const *name) noexcept {
-    return impl(p_)->lock_.open(name);
-}
-
-void mutex::close() noexcept {
-    impl(p_)->lock_.close();
-}
-
-bool mutex::lock(std::uint64_t tm) noexcept {
-    return impl(p_)->lock_.lock(tm);
-}
-
-bool mutex::try_lock() noexcept(false) {
-    return impl(p_)->lock_.try_lock();
-}
-
-bool mutex::unlock() noexcept {
-    return impl(p_)->lock_.unlock();
-}
-
-} // namespace sync
-} // namespace ipc
diff --git a/src/libipc/sync/semaphore.cpp b/src/libipc/sync/semaphore.cpp
deleted file mode 100644
index 23f6bdc..0000000
--- a/src/libipc/sync/semaphore.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-
-#include "libipc/semaphore.h"
-
-#include "libipc/utility/pimpl.h"
-#include "libipc/memory/resource.h"
-#include "libipc/platform/detail.h"
-#if defined(IPC_OS_WINDOWS_)
-#include "libipc/platform/win/semaphore.h"
-#elif defined(IPC_OS_LINUX_) || defined(IPC_OS_QNX_)
-#include "libipc/platform/posix/semaphore_impl.h"
-#else/*IPC_OS*/
-#   error "Unsupported platform."
-#endif
-
-namespace ipc {
-namespace sync {
-
-class semaphore::semaphore_ : public ipc::pimpl<semaphore_> {
-public:
-    ipc::detail::sync::semaphore sem_;
-};
-
-semaphore::semaphore()
-    : p_(p_->make()) {
-}
-
-semaphore::semaphore(char const * name, std::uint32_t count)
-    : semaphore() {
-    open(name, count);
-}
-
-semaphore::~semaphore() {
-    close();
-    p_->clear();
-}
-
-void const *semaphore::native() const noexcept {
-    return impl(p_)->sem_.native();
-}
-
-void *semaphore::native() noexcept {
-    return impl(p_)->sem_.native();
-}
-
-bool semaphore::valid() const noexcept {
-    return impl(p_)->sem_.valid();
-}
-
-bool semaphore::open(char const *name, std::uint32_t count) noexcept {
-    return impl(p_)->sem_.open(name, count);
-}
-
-void semaphore::close() noexcept {
-    impl(p_)->sem_.close();
-}
-
-bool semaphore::wait(std::uint64_t tm) noexcept {
-    return impl(p_)->sem_.wait(tm);
-}
-
-bool semaphore::post(std::uint32_t count) noexcept {
-    return impl(p_)->sem_.post(count);
-}
-
-} // namespace sync
-} // namespace ipc
diff --git a/src/libipc/utility/concept.h b/src/libipc/utility/concept.h
deleted file mode 100755
index 9325ddc..0000000
--- a/src/libipc/utility/concept.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <type_traits>  // std::enable_if
-
-namespace ipc {
-
-// concept helpers
-
-template <bool Cond, typename R = void>
-using require = typename std::enable_if<Cond, R>::type;
-
-#ifdef IPC_CONCEPT_
-#   error "IPC_CONCEPT_ has been defined."
-#endif
-
-#define IPC_CONCEPT_(NAME, WHAT)                                       \
-template <typename T>                                                  \
-class NAME {                                                           \
-private:                                                               \
-    template <typename Type>                                           \
-    static std::true_type check(decltype(std::declval<Type>().WHAT)*); \
-    template <typename Type>                                           \
-    static std::false_type check(...);                                 \
-public:                                                                \
-    using type = decltype(check<T>(nullptr));                          \
-    constexpr static auto value = type::value;                         \
-}
-
-} // namespace ipc
diff --git a/src/libipc/utility/id_pool.h b/src/libipc/utility/id_pool.h
deleted file mode 100755
index 24d32e4..0000000
--- a/src/libipc/utility/id_pool.h
+++ /dev/null
@@ -1,103 +0,0 @@
-#pragma once
-
-#include <type_traits>  // std::aligned_storage_t
-#include <cstring>      // std::memcmp
-#include <cstdint>
-
-#include "libipc/def.h"
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-
-using storage_id_t = std::int32_t;
-
-template <std::size_t DataSize, std::size_t AlignSize>
-struct id_type;
-
-template <std::size_t AlignSize>
-struct id_type<0, AlignSize> {
-    uint_t<8> id_;
-
-    id_type& operator=(storage_id_t val) {
-        id_ = static_cast<uint_t<8>>(val);
-        return (*this);
-    }
-
-    operator uint_t<8>() const {
-        return id_;
-    }
-};
-
-template <std::size_t DataSize, std::size_t AlignSize>
-struct id_type : id_type<0, AlignSize> {
-    std::aligned_storage_t<DataSize, AlignSize> data_;
-};
-
-template <std::size_t DataSize  = 0,
-          std::size_t AlignSize = (ipc::detail::min)(DataSize, alignof(std::max_align_t))>
-class id_pool {
-
-    static constexpr std::size_t limited_max_count() {
-        return ipc::detail::min<std::size_t>(large_msg_cache, (std::numeric_limits<uint_t<8>>::max)());
-    }
-
-public:
-    enum : std::size_t {
-        /* eliminate error: taking address of temporary */
-        max_count = limited_max_count()
-    };
-
-private:
-    id_type<DataSize, AlignSize> next_[max_count];
-    uint_t<8> cursor_ = 0;
-    bool prepared_ = false;
-
-public:
-    void prepare() {
-        if (!prepared_ && this->invalid()) this->init();
-        prepared_ = true;
-    }
-
-    void init() {
-        for (storage_id_t i = 0; i < max_count;) {
-            i = next_[i] = (i + 1);
-        }
-    }
-
-    bool invalid() const {
-        static id_pool inv;
-        return std::memcmp(this, &inv, sizeof(id_pool)) == 0;
-    }
-
-    bool empty() const {
-        return cursor_ == max_count;
-    }
-
-    storage_id_t acquire() {
-        if (empty()) return -1;
-        storage_id_t id = cursor_;
-        cursor_ = next_[id]; // point to next
-        return id;
-    }
-
-    bool release(storage_id_t id) {
-        if (id < 0) return false;
-        next_[id] = cursor_;
-        cursor_ = static_cast<uint_t<8>>(id); // put it back
-        return true;
-    }
-
-    void       * at(storage_id_t id)       { return &(next_[id].data_); }
-    void const * at(storage_id_t id) const { return &(next_[id].data_); }
-};
-
-template <typename T>
-class obj_pool : public id_pool<sizeof(T), alignof(T)> {
-    using base_t = id_pool<sizeof(T), alignof(T)>;
-
-public:
-    T       * at(storage_id_t id)       { return reinterpret_cast<T       *>(base_t::at(id)); }
-    T const * at(storage_id_t id) const { return reinterpret_cast<T const *>(base_t::at(id)); }
-};
-
-} // namespace ipc
diff --git a/src/libipc/utility/log.h b/src/libipc/utility/log.h
deleted file mode 100755
index bb1dcea..0000000
--- a/src/libipc/utility/log.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include <cstdio>
-#include <utility>
-
-namespace ipc {
-namespace detail {
-
-template <typename O>
-void print(O out, char const * str) {
-    std::fprintf(out, "%s", str);
-}
-
-template <typename O, typename P1, typename... P>
-void print(O out, char const * fmt, P1&& p1, P&&... params) {
-    std::fprintf(out, fmt, std::forward<P1>(p1), std::forward<P>(params)...);
-}
-
-} // namespace detail
-
-inline void log(char const * fmt) {
-    ipc::detail::print(stdout, fmt);
-}
-
-template <typename P1, typename... P>
-void log(char const * fmt, P1&& p1, P&&... params) {
-    ipc::detail::print(stdout, fmt, std::forward<P1>(p1), std::forward<P>(params)...);
-}
-
-inline void error(char const * str) {
-    ipc::detail::print(stderr, str);
-}
-
-template <typename P1, typename... P>
-void error(char const * fmt, P1&& p1, P&&... params) {
-    ipc::detail::print(stderr, fmt, std::forward<P1>(p1), std::forward<P>(params)...);
-}
-
-} // namespace ipc
diff --git a/src/libipc/utility/pimpl.h b/src/libipc/utility/pimpl.h
deleted file mode 100755
index ca0edd3..0000000
--- a/src/libipc/utility/pimpl.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#pragma once
-
-#include <new>
-#include <utility>
-
-#include "libipc/platform/detail.h"
-#include "libipc/utility/concept.h"
-#include "libipc/pool_alloc.h"
-
-namespace ipc {
-
-// pimpl small object optimization helpers
-
-template <typename T, typename R = T*>
-using IsImplComfortable = ipc::require<(sizeof(T) <= sizeof(T*)), R>;
-
-template <typename T, typename R = T*>
-using IsImplUncomfortable = ipc::require<(sizeof(T) > sizeof(T*)), R>;
-
-template <typename T, typename... P>
-IPC_CONSTEXPR_ auto make_impl(P&&... params) -> IsImplComfortable<T> {
-    T* buf {};
-    ::new (&buf) T { std::forward<P>(params)... };
-    return buf;
-}
-
-template <typename T>
-IPC_CONSTEXPR_ auto impl(T* const (& p)) -> IsImplComfortable<T> {
-    return reinterpret_cast<T*>(&const_cast<char &>(reinterpret_cast<char const &>(p)));
-}
-
-template <typename T>
-IPC_CONSTEXPR_ auto clear_impl(T* p) -> IsImplComfortable<T, void> {
-    if (p != nullptr) impl(p)->~T();
-}
-
-template <typename T, typename... P>
-IPC_CONSTEXPR_ auto make_impl(P&&... params) -> IsImplUncomfortable<T> {
-    return mem::alloc<T>(std::forward<P>(params)...);
-}
-
-template <typename T>
-IPC_CONSTEXPR_ auto clear_impl(T* p) -> IsImplUncomfortable<T, void> {
-    mem::free(p);
-}
-
-template <typename T>
-IPC_CONSTEXPR_ auto impl(T* const (& p)) -> IsImplUncomfortable<T> {
-    return p;
-}
-
-template <typename T>
-struct pimpl {
-    template <typename... P>
-    IPC_CONSTEXPR_ static T* make(P&&... params) {
-        return make_impl<T>(std::forward<P>(params)...);
-    }
-
-    IPC_CONSTEXPR_ void clear() {
-        clear_impl(static_cast<T*>(const_cast<pimpl*>(this)));
-    }
-};
-
-} // namespace ipc
diff --git a/src/libipc/utility/scope_guard.h b/src/libipc/utility/scope_guard.h
deleted file mode 100644
index 9f42149..0000000
--- a/src/libipc/utility/scope_guard.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#pragma once
-
-#include <utility>      // std::forward, std::move
-#include <algorithm>    // std::swap
-#include <type_traits>  // std::decay
-
-namespace ipc {
-
-////////////////////////////////////////////////////////////////
-/// Execute guard function when the enclosing scope exits
-////////////////////////////////////////////////////////////////
-
-template <typename F>
-class scope_guard {
-    F destructor_;
-    mutable bool dismiss_;
-
-public:
-    template <typename D>
-    scope_guard(D && destructor)
-        : destructor_(std::forward<D>(destructor))
-        , dismiss_(false) {
-    }
-
-    scope_guard(scope_guard&& rhs)
-        : destructor_(std::move(rhs.destructor_))
-        , dismiss_(true) /* dismiss rhs */ {
-        std::swap(dismiss_, rhs.dismiss_);
-    }
-
-    ~scope_guard() {
-        try { do_exit(); }
-        /**
-         * In the realm of exceptions, it is fundamental that you can do nothing
-         * if your "undo/recover" action fails.
-        */
-        catch (...) { /* Do nothing */ }
-    }
-
-    void swap(scope_guard & rhs) {
-        std::swap(destructor_, rhs.destructor_);
-        std::swap(dismiss_   , rhs.dismiss_);
-    }
-
-    void dismiss() const noexcept {
-        dismiss_ = true;
-    }
-
-    void do_exit() {
-        if (!dismiss_) {
-            dismiss_ = true;
-            destructor_();
-        }
-    }
-};
-
-template <typename D>
-constexpr auto guard(D && destructor) noexcept {
-    return scope_guard<std::decay_t<D>> {
-        std::forward<D>(destructor)
-    };
-}
-
-} // namespace ipc
\ No newline at end of file
diff --git a/src/libipc/utility/utility.h b/src/libipc/utility/utility.h
deleted file mode 100755
index 79424d9..0000000
--- a/src/libipc/utility/utility.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#pragma once
-
-#include <utility>      // std::forward, std::integer_sequence
-#include <cstddef>      // std::size_t
-#include <new>          // std::hardware_destructive_interference_size
-#include <type_traits>  // std::is_trivially_copyable
-
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-
-template <typename F, typename D>
-constexpr decltype(auto) static_switch(std::size_t /*i*/, std::index_sequence<>, F&& /*f*/, D&& def) {
-    return std::forward<D>(def)();
-}
-
-template <typename F, typename D, std::size_t N, std::size_t...I>
-constexpr decltype(auto) static_switch(std::size_t i, std::index_sequence<N, I...>, F&& f, D&& def) {
-    return (i == N) ? std::forward<F>(f)(std::integral_constant<std::size_t, N>{}) :
-                      static_switch(i, std::index_sequence<I...>{}, std::forward<F>(f), std::forward<D>(def));
-}
-
-template <std::size_t N, typename F, typename D>
-constexpr decltype(auto) static_switch(std::size_t i, F&& f, D&& def) {
-    return static_switch(i, std::make_index_sequence<N>{}, std::forward<F>(f), std::forward<D>(def));
-}
-
-template <typename F, std::size_t...I>
-IPC_CONSTEXPR_ void static_for(std::index_sequence<I...>, F&& f) {
-    IPC_UNUSED_ auto expand = { (std::forward<F>(f)(std::integral_constant<std::size_t, I>{}), 0)... };
-}
-
-template <std::size_t N, typename F>
-IPC_CONSTEXPR_ void static_for(F&& f) {
-    static_for(std::make_index_sequence<N>{}, std::forward<F>(f));
-}
-
-// Minimum offset between two objects to avoid false sharing.
-enum {
-// #if __cplusplus >= 201703L
-//     cache_line_size = std::hardware_destructive_interference_size
-// #else /*__cplusplus < 201703L*/
-    cache_line_size = 64
-// #endif/*__cplusplus < 201703L*/
-};
-
-template <typename T, typename U>
-auto horrible_cast(U rhs) noexcept
-    -> typename std::enable_if<std::is_trivially_copyable<T>::value
-                            && std::is_trivially_copyable<U>::value, T>::type {
-    union {
-        T t;
-        U u;
-    } r = {};
-    r.u = rhs;
-    return r.t;
-}
-
-IPC_CONSTEXPR_ std::size_t make_align(std::size_t align, std::size_t size) {
-    // align must be 2^n
-    return (size + align - 1) & ~(align - 1);
-}
-
-} // namespace ipc
diff --git a/src/libipc/waiter.h b/src/libipc/waiter.h
deleted file mode 100644
index 130bc98..0000000
--- a/src/libipc/waiter.h
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-
-#include <utility>
-#include <string>
-#include <mutex>
-#include <atomic>
-
-#include "libipc/def.h"
-#include "libipc/mutex.h"
-#include "libipc/condition.h"
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-namespace detail {
-
-class waiter {
-    ipc::sync::condition cond_;
-    ipc::sync::mutex     lock_;
-    std::atomic<bool>    quit_ {false};
-
-public:
-    waiter() = default;
-    waiter(char const *name) {
-        open(name);
-    }
-
-    ~waiter() {
-        close();
-    }
-
-    bool valid() const noexcept {
-        return cond_.valid() && lock_.valid();
-    }
-
-    bool open(char const *name) noexcept {
-        quit_.store(false, std::memory_order_relaxed);
-        if (!cond_.open((std::string{"_waiter_cond_"} + name).c_str())) {
-            return false;
-        }
-        if (!lock_.open((std::string{"_waiter_lock_"} + name).c_str())) {
-            cond_.close();
-            return false;
-        }
-        return valid();
-    }
-
-    void close() noexcept {
-        cond_.close();
-        lock_.close();
-    }
-
-    template <typename F>
-    bool wait_if(F &&pred, std::uint64_t tm = ipc::invalid_value) noexcept {
-        IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> guard {lock_};
-        while ([this, &pred] {
-                    return !quit_.load(std::memory_order_relaxed)
-                        && std::forward<F>(pred)();
-                }()) {
-            if (!cond_.wait(lock_, tm)) return false;
-        }
-        return true;
-    }
-
-    bool notify() noexcept {
-        { IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> guard {lock_}; } // barrier
-        return cond_.notify(lock_);
-    }
-
-    bool broadcast() noexcept {
-        { IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> guard {lock_}; } // barrier
-        return cond_.broadcast(lock_);
-    }
-
-    bool quit_waiting() {
-        quit_.store(true, std::memory_order_release);
-        return broadcast();
-    }
-};
-
-} // namespace detail
-} // namespace ipc
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9398aa3..dfd7fc2 100755
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -9,16 +9,13 @@ if(NOT MSVC)
 endif()
 
 include_directories(
-    ${LIBIPC_PROJECT_DIR}/include 
-    ${LIBIPC_PROJECT_DIR}/src
-    ${LIBIPC_PROJECT_DIR}/test
-    ${LIBIPC_PROJECT_DIR}/3rdparty
-    ${LIBIPC_PROJECT_DIR}/3rdparty/gtest/include)
+  ${LIBIPC_PROJECT_DIR}/include 
+  ${LIBIPC_PROJECT_DIR}/src
+  ${LIBIPC_PROJECT_DIR}/test
+  ${LIBIPC_PROJECT_DIR}/3rdparty
+  ${LIBIPC_PROJECT_DIR}/3rdparty/gtest/include)
 
-file(GLOB SRC_FILES
-    ${LIBIPC_PROJECT_DIR}/test/*.cpp
-    # ${LIBIPC_PROJECT_DIR}/test/profiler/*.cpp
-    )
+file(GLOB SRC_FILES  ${LIBIPC_PROJECT_DIR}/test/*.cpp)
 file(GLOB HEAD_FILES ${LIBIPC_PROJECT_DIR}/test/*.h)
 
 add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
diff --git a/test/test.h b/test/test.h
deleted file mode 100755
index 19bd22b..0000000
--- a/test/test.h
+++ /dev/null
@@ -1,86 +0,0 @@
-#pragma once
-
-#include <iostream>
-#include <atomic>
-#include <thread>
-#include <string>
-#include <memory>
-#include <mutex>
-#include <utility>
-
-#include "gtest/gtest.h"
-
-#include "capo/stopwatch.hpp"
-
-#include "thread_pool.h"
-
-namespace ipc_ut {
-
-template <typename Dur>
-struct unit;
-
-template <> struct unit<std::chrono::nanoseconds> {
-    constexpr static char const * str() noexcept {
-        return "ns";
-    }
-};
-
-template <> struct unit<std::chrono::microseconds> {
-    constexpr static char const * str() noexcept {
-        return "us";
-    }
-};
-
-template <> struct unit<std::chrono::milliseconds> {
-    constexpr static char const * str() noexcept {
-        return "ms";
-    }
-};
-
-template <> struct unit<std::chrono::seconds> {
-    constexpr static char const * str() noexcept {
-        return "sec";
-    }
-};
-
-struct test_stopwatch {
-    capo::stopwatch<> sw_;
-    std::atomic_flag started_ = ATOMIC_FLAG_INIT;
-
-    void start() {
-        if (!started_.test_and_set()) {
-            sw_.start();
-        }
-    }
-
-    template <typename ToDur = std::chrono::nanoseconds>
-    void print_elapsed(int N, int Loops, char const * message = "") {
-        auto ts = sw_.elapsed<ToDur>();
-        std::cout << "[" << N << ", \t" << Loops << "] " << message << "\t"
-                  << (double(ts) / double(Loops)) << " " << unit<ToDur>::str() << std::endl;
-    }
-
-    template <int Factor, typename ToDur = std::chrono::nanoseconds>
-    void print_elapsed(int N, int M, int Loops, char const * message = "") {
-        auto ts = sw_.elapsed<ToDur>();
-        std::cout << "[" << N << "-" << M << ", \t" << Loops << "] " << message << "\t"
-                  << (double(ts) / double(Factor ? (Loops * Factor) : (Loops * N))) << " " << unit<ToDur>::str() << std::endl;
-    }
-
-    template <typename ToDur = std::chrono::nanoseconds>
-    void print_elapsed(int N, int M, int Loops, char const * message = "") {
-        print_elapsed<0, ToDur>(N, M, Loops, message);
-    }
-};
-
-inline static thread_pool & sender() {
-    static thread_pool pool;
-    return pool;
-}
-
-inline static thread_pool & reader() {
-    static thread_pool pool;
-    return pool;
-}
-
-} // namespace ipc_ut
\ No newline at end of file
diff --git a/test/test_detect_plat.cpp b/test/test_detect_plat.cpp
new file mode 100644
index 0000000..ca62b1c
--- /dev/null
+++ b/test/test_detect_plat.cpp
@@ -0,0 +1,79 @@
+
+#include <iostream>
+#include <cstdint>
+
+#include "gtest/gtest.h"
+
+#include "libipc/detect_plat.h"
+
+namespace {
+
+} // namespace
+
+TEST(detect_plat, os) {
+#if defined(LIBIPC_OS_WINCE)
+  std::cout << "LIBIPC_OS_WINCE\n";
+#elif defined(LIBIPC_OS_WIN)
+  std::cout << "LIBIPC_OS_WIN\n";
+#elif defined(LIBIPC_OS_LINUX)
+  std::cout << "LIBIPC_OS_LINUX\n";
+#elif defined(LIBIPC_OS_QNX)
+  std::cout << "LIBIPC_OS_QNX\n";
+#elif defined(LIBIPC_OS_ANDROID)
+  std::cout << "LIBIPC_OS_ANDROID\n";
+#else
+  ASSERT_TRUE(false);
+#endif
+}
+
+TEST(detect_plat, cc) {
+#if defined(LIBIPC_CC_MSVC)
+  std::cout << "LIBIPC_CC_MSVC\n";
+#elif defined(LIBIPC_CC_GNUC)
+  std::cout << "LIBIPC_CC_GNUC\n";
+#else
+  ASSERT_TRUE(false);
+#endif
+}
+
+TEST(detect_plat, byte_order) {
+  auto is_endian_little = [] {
+    union {
+      std::int32_t a;
+      std::int8_t  b;
+    } c;
+    c.a = 1;
+    return c.b == 1;
+  };
+  EXPECT_EQ(!!LIBIPC_ENDIAN_LIT, is_endian_little());
+  EXPECT_NE(!!LIBIPC_ENDIAN_BIG, is_endian_little());
+}
+
+TEST(detect_plat, fallthrough) {
+  switch (0) {
+  case 1:
+    std::cout << "fallthrough 0\n";
+    LIBIPC_FALLTHROUGH;
+  case 0:
+    std::cout << "fallthrough 1\n";
+    LIBIPC_FALLTHROUGH;
+  default:
+    std::cout << "fallthrough default\n";
+    break;
+  }
+}
+
+TEST(detect_plat, unused) {
+  LIBIPC_UNUSED int abc;
+}
+
+TEST(detect_plat, likely_unlikely) {
+  int xx = sizeof(int);
+  if LIBIPC_LIKELY(xx < sizeof(long long)) {
+    std::cout << "sizeof(int) < sizeof(long long)\n";
+  } else if LIBIPC_UNLIKELY(xx < sizeof(char)) {
+    std::cout << "sizeof(int) < sizeof(char)\n";
+  } else {
+    std::cout << "sizeof(int) < whatever\n";
+  }
+}
\ No newline at end of file
diff --git a/test/test_ipc.cpp b/test/test_ipc.cpp
deleted file mode 100755
index 695e674..0000000
--- a/test/test_ipc.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-
-#include <vector>
-#include <iostream>
-#include <mutex>
-#include <atomic>
-#include <cstring>
-
-#include "libipc/ipc.h"
-#include "libipc/buffer.h"
-#include "libipc/memory/resource.h"
-
-#include "test.h"
-#include "thread_pool.h"
-
-#include "capo/random.hpp"
-
-using namespace ipc;
-
-namespace {
-
-constexpr int LoopCount   = 10000;
-constexpr int MultiMax    = 8;
-constexpr int TestBuffMax = 65536;
-
-struct msg_head {
-    int id_;
-};
-
-class rand_buf : public buffer {
-public:
-    rand_buf() {
-        int size = capo::random<>{(int)sizeof(msg_head), TestBuffMax}();
-        *this = buffer(new char[size], size, [](void * p, std::size_t) {
-            delete [] static_cast<char *>(p);
-        });
-    }
-
-    rand_buf(msg_head const &msg) {
-        *this = buffer(new msg_head{msg}, sizeof(msg), [](void * p, std::size_t) {
-            delete static_cast<msg_head *>(p);
-        });
-    }
-
-    rand_buf(rand_buf &&) = default;
-    rand_buf(rand_buf const & rhs) {
-        if (rhs.empty()) return;
-        void * mem = new char[rhs.size()];
-        std::memcpy(mem, rhs.data(), rhs.size());
-        *this = buffer(mem, rhs.size(), [](void * p, std::size_t) {
-            delete [] static_cast<char *>(p);
-        });
-    }
-
-    rand_buf(buffer && rhs)
-        : buffer(std::move(rhs)) {
-    }
-
-    void set_id(int k) noexcept {
-        get<msg_head *>()->id_ = k;
-    }
-
-    int get_id() const noexcept {
-        return get<msg_head *>()->id_;
-    }
-
-    using buffer::operator=;
-};
-
-template <relat Rp, relat Rc, trans Ts>
-void test_basic(char const * name) {
-    using que_t = chan<Rp, Rc, Ts>;
-    rand_buf test1, test2;
-
-    que_t que1 { name };
-    EXPECT_FALSE(que1.send(test1));
-
-    que_t que2 { que1.name(), ipc::receiver };
-    ASSERT_TRUE(que1.send(test1));
-
-    EXPECT_EQ(que2.recv(), test1);
-    EXPECT_EQ(que2.recv(), test2);
-}
-
-class data_set {
-    std::vector<rand_buf> datas_;
-
-public:
-    data_set() {
-        datas_.resize(LoopCount);
-        for (int i = 0; i < LoopCount; ++i) {
-            datas_[i].set_id(i);
-        }
-    }
-
-    std::vector<rand_buf> const &get() const noexcept {
-        return datas_;
-    }
-} const data_set__;
-
-template <relat Rp, relat Rc, trans Ts, typename Que = chan<Rp, Rc, Ts>>
-void test_sr(char const * name, int s_cnt, int r_cnt) {
-    ipc_ut::sender().start(static_cast<std::size_t>(s_cnt));
-    ipc_ut::reader().start(static_cast<std::size_t>(r_cnt));
-
-    std::atomic_thread_fence(std::memory_order_seq_cst);
-    ipc_ut::test_stopwatch sw;
-
-    for (int k = 0; k < s_cnt; ++k) {
-        ipc_ut::sender() << [name, &sw, r_cnt, k] {
-            Que que { name, ipc::sender };
-            ASSERT_TRUE(que.wait_for_recv(r_cnt));
-            sw.start();
-            for (int i = 0; i < (int)data_set__.get().size(); ++i) {
-                ASSERT_TRUE(que.send(data_set__.get()[i]));
-            }
-        };
-    }
-
-    for (int k = 0; k < r_cnt; ++k) {
-        ipc_ut::reader() << [name] {
-            Que que { name, ipc::receiver };
-            for (;;) {
-                rand_buf got { que.recv() };
-                ASSERT_FALSE(got.empty());
-                int i = got.get_id();
-                if (i == -1) {
-                    return;
-                }
-                ASSERT_TRUE((i >= 0) && (i < (int)data_set__.get().size()));
-                auto const &data_set = data_set__.get()[i];
-                if (data_set != got) {
-                    printf("data_set__.get()[%d] != got, size = %zd/%zd\n", 
-                            i, data_set.size(), got.size());
-                    ASSERT_TRUE(false);
-                }
-            }
-        };
-    }
-
-    ipc_ut::sender().wait_for_done();
-    Que que { name };
-    ASSERT_TRUE(que.wait_for_recv(r_cnt));
-    for (int k = 0; k < r_cnt; ++k) {
-        que.send(rand_buf{msg_head{-1}});
-    }
-    ipc_ut::reader().wait_for_done();
-    sw.print_elapsed<std::chrono::microseconds>(s_cnt, r_cnt, (int)data_set__.get().size(), name);
-}
-
-} // internal-linkage
-
-TEST(IPC, basic) {
-    test_basic<relat::single, relat::single, trans::unicast  >("ssu");
-    //test_basic<relat::single, relat::multi , trans::unicast  >("smu");
-    //test_basic<relat::multi , relat::multi , trans::unicast  >("mmu");
-    test_basic<relat::single, relat::multi , trans::broadcast>("smb");
-    test_basic<relat::multi , relat::multi , trans::broadcast>("mmb");
-}
-
-TEST(IPC, 1v1) {
-    test_sr<relat::single, relat::single, trans::unicast  >("ssu", 1, 1);
-    //test_sr<relat::single, relat::multi , trans::unicast  >("smu", 1, 1);
-    //test_sr<relat::multi , relat::multi , trans::unicast  >("mmu", 1, 1);
-    test_sr<relat::single, relat::multi , trans::broadcast>("smb", 1, 1);
-    test_sr<relat::multi , relat::multi , trans::broadcast>("mmb", 1, 1);
-}
-
-TEST(IPC, 1vN) {
-    //test_sr<relat::single, relat::multi , trans::unicast  >("smu", 1, MultiMax);
-    //test_sr<relat::multi , relat::multi , trans::unicast  >("mmu", 1, MultiMax);
-    test_sr<relat::single, relat::multi , trans::broadcast>("smb", 1, MultiMax);
-    test_sr<relat::multi , relat::multi , trans::broadcast>("mmb", 1, MultiMax);
-}
-
-TEST(IPC, Nv1) {
-    //test_sr<relat::multi , relat::multi , trans::unicast  >("mmu", MultiMax, 1);
-    test_sr<relat::multi , relat::multi , trans::broadcast>("mmb", MultiMax, 1);
-}
-
-TEST(IPC, NvN) {
-    //test_sr<relat::multi , relat::multi , trans::unicast  >("mmu", MultiMax, MultiMax);
-    test_sr<relat::multi , relat::multi , trans::broadcast>("mmb", MultiMax, MultiMax);
-}
diff --git a/test/test_mem.cpp b/test/test_mem.cpp
deleted file mode 100755
index 16a5ad1..0000000
--- a/test/test_mem.cpp
+++ /dev/null
@@ -1,218 +0,0 @@
-#include <vector>
-#include <array>
-#include <thread>
-#include <atomic>
-#include <cstddef>
-
-#include "capo/random.hpp"
-
-#include "libipc/memory/resource.h"
-#include "libipc/pool_alloc.h"
-
-// #include "gperftools/tcmalloc.h"
-
-#include "test.h"
-#include "thread_pool.h"
-
-namespace {
-
-constexpr int DataMin   = 4;
-constexpr int DataMax   = 256;
-constexpr int LoopCount = 8388608;
-constexpr int ThreadMax = 8;
-
-// constexpr int DataMin   = 256;
-// constexpr int DataMax   = 512;
-// constexpr int LoopCount = 2097152;
-
-std::vector<std::size_t> sizes__;
-std::vector<void*> ptr_cache__[ThreadMax];
-
-template <typename M>
-struct alloc_ix_t {
-    static std::vector<int> ix_;
-    static bool inited_;
-
-    alloc_ix_t() {
-        if (inited_) return;
-        inited_ = true;
-        M::init();
-    }
-
-    template <int ThreadsN>
-    static int index(std::size_t /*pid*/, std::size_t /*k*/, std::size_t n) {
-        return ix_[n];
-    }
-};
-
-template <typename M>
-std::vector<int> alloc_ix_t<M>::ix_(LoopCount);
-template <typename M>
-bool alloc_ix_t<M>::inited_ = false;
-
-struct alloc_FIFO : alloc_ix_t<alloc_FIFO> {
-    static void init() {
-        for (int i = 0; i < LoopCount; ++i) {
-            ix_[static_cast<std::size_t>(i)] = i;
-        }
-    }
-};
-
-struct alloc_LIFO : alloc_ix_t<alloc_LIFO> {
-    static void init() {
-        for (int i = 0; i < LoopCount; ++i) {
-            ix_[static_cast<std::size_t>(i)] = i;
-        }
-    }
-
-    template <int ThreadsN>
-    static int index(std::size_t pid, std::size_t k, std::size_t n) {
-        constexpr static int CacheSize = LoopCount / ThreadsN;
-        if (k) {
-            return ix_[(CacheSize * (2 * pid + 1)) - 1 - n];
-        }
-        else return ix_[n];
-    }
-};
-
-struct alloc_Random : alloc_ix_t<alloc_Random> {
-    static void init() {
-        capo::random<> rdm_index(0, LoopCount - 1);
-        for (int i = 0; i < LoopCount; ++i) {
-            ix_[static_cast<std::size_t>(i)] = rdm_index();
-        }
-    }
-};
-
-struct Init {
-    Init() {
-        capo::random<> rdm{ DataMin, DataMax };
-        for (int i = 0; i < LoopCount; ++i) {
-            sizes__.emplace_back(static_cast<std::size_t>(rdm()));
-        }
-        for (auto& vec : ptr_cache__) {
-            vec.resize(LoopCount, nullptr);
-        }
-    }
-} init__;
-
-template <typename AllocT, int ThreadsN>
-void benchmark_alloc(char const * message) {
-    std::string msg = std::to_string(ThreadsN) + "\t" + message;
-
-    constexpr static int CacheSize = LoopCount / ThreadsN;
-    ipc_ut::sender().start(static_cast<std::size_t>(ThreadsN));
-    ipc_ut::test_stopwatch sw;
-
-    for (int pid = 0; pid < ThreadsN; ++pid) {
-        ipc_ut::sender() << [&, pid] {
-            sw.start();
-            for (int n = (CacheSize * pid); n < (CacheSize * (pid + 1)); ++n) {
-                std::size_t s = sizes__[n];
-                AllocT::free(AllocT::alloc(s), s);
-            }
-        };
-    }
-
-    ipc_ut::sender().wait_for_done();
-    sw.print_elapsed<1>(DataMin, DataMax, LoopCount, msg.c_str());
-}
-
-template <typename AllocT, typename ModeT, int ThreadsN>
-void benchmark_alloc(char const * message) {
-    std::string msg = std::to_string(ThreadsN) + "\t" + message;
-
-    constexpr static int CacheSize = LoopCount / ThreadsN;
-    ModeT mode;
-    ipc_ut::sender().start(static_cast<std::size_t>(ThreadsN));
-    ipc_ut::test_stopwatch sw;
-
-    for (int pid = 0; pid < ThreadsN; ++pid) {
-        ipc_ut::sender() << [&, pid] {
-            auto& vec = ptr_cache__[pid];
-            sw.start();
-            for (std::size_t k = 0; k < 2; ++k)
-            for (int n = (CacheSize * pid); n < (CacheSize * (pid + 1)); ++n) {
-                int    m = mode.template index<ThreadsN>(pid, k, n);
-                void*& p = vec[static_cast<std::size_t>(m)];
-                std::size_t s  = sizes__[static_cast<std::size_t>(m)];
-                if (p == nullptr) {
-                    p = AllocT::alloc(s);
-                }
-                else {
-                    AllocT::free(p, s);
-                    p = nullptr;
-                }
-            }
-        };
-    }
-
-    ipc_ut::sender().wait_for_done();
-    sw.print_elapsed<1>(DataMin, DataMax, LoopCount, msg.c_str());
-}
-
-template <typename AllocT, typename ModeT, int ThreadsN>
-struct test_performance {
-    static void start(char const * message) {
-        test_performance<AllocT, ModeT, ThreadsN / 2>::start(message);
-        benchmark_alloc<AllocT, ModeT, ThreadsN>(message);
-    }
-};
-
-template <typename AllocT, typename ModeT>
-struct test_performance<AllocT, ModeT, 1> {
-    static void start(char const * message) {
-        benchmark_alloc<AllocT, ModeT, 1>(message);
-    }
-};
-
-template <typename AllocT, int ThreadsN>
-struct test_performance<AllocT, void, ThreadsN> {
-    static void start(char const * message) {
-        test_performance<AllocT, void, ThreadsN / 2>::start(message);
-        benchmark_alloc<AllocT, ThreadsN>(message);
-    }
-};
-
-template <typename AllocT>
-struct test_performance<AllocT, void, 1> {
-    static void start(char const * message) {
-        benchmark_alloc<AllocT, 1>(message);
-    }
-};
-
-// class tc_alloc {
-// public:
-//    static void clear() {}
-
-//    static void* alloc(std::size_t size) {
-//        return size ? tc_malloc(size) : nullptr;
-//    }
-
-//    static void free(void* p, std::size_t size) {
-//        tc_free_sized(p, size);
-//    }
-// };
-/*
-TEST(Memory, static_alloc) {
-    test_performance<ipc::mem::static_alloc, void        , ThreadMax>::start("alloc-free");
-    test_performance<ipc::mem::static_alloc, alloc_FIFO  , ThreadMax>::start("alloc-FIFO");
-    test_performance<ipc::mem::static_alloc, alloc_LIFO  , ThreadMax>::start("alloc-LIFO");
-    test_performance<ipc::mem::static_alloc, alloc_Random, ThreadMax>::start("alloc-Rand");
-}
-
-TEST(Memory, pool_alloc) {
-    test_performance<ipc::mem::async_pool_alloc, void        , ThreadMax>::start("alloc-free");
-    test_performance<ipc::mem::async_pool_alloc, alloc_FIFO  , ThreadMax>::start("alloc-FIFO");
-    test_performance<ipc::mem::async_pool_alloc, alloc_LIFO  , ThreadMax>::start("alloc-LIFO");
-    test_performance<ipc::mem::async_pool_alloc, alloc_Random, ThreadMax>::start("alloc-Rand");
-}
-*/
-// TEST(Memory, tc_alloc) {
-//     test_performance<tc_alloc, void       , ThreadMax>::start();
-//     test_performance<tc_alloc, alloc_FIFO  , ThreadMax>::start();
-//     test_performance<tc_alloc, alloc_LIFO  , ThreadMax>::start();
-//     test_performance<tc_alloc, alloc_Random, ThreadMax>::start();
-// }
-
-} // internal-linkage
diff --git a/test/test_platform.cpp b/test/test_platform.cpp
deleted file mode 100644
index 65fa513..0000000
--- a/test/test_platform.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__) || \
-    defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || \
-    defined(WINCE) || defined(_WIN32_WCE)
-
-#include <locale>
-#include <iostream>
-//#include <fstream>
-
-#include "test.h"
-
-#include "libipc/platform/win/to_tchar.h"
-
-TEST(Platform, to_tchar) {
-    char const *utf8 = "hello world, "
-                       "\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc"
-                       "\x8c\xe3\x81\x93\xe3\x82\x93\xe3"
-                       "\x81\xab\xe3\x81\xa1\xe3\x81\xaf";
-    wchar_t const *utf16 = L"hello world, \u4f60\u597d\uff0c\u3053\u3093\u306b\u3061\u306f";
-    {
-        ipc::string str = ipc::detail::to_tchar<char>(utf8);
-        EXPECT_STREQ(str.c_str(), utf8);
-    }
-    {
-        ipc::wstring wtr = ipc::detail::to_tchar<wchar_t>(utf8);
-        EXPECT_STREQ(wtr.c_str(), utf16);
-        //std::ofstream out("out.txt", std::ios::binary|std::ios::out);
-        //out.write((char const *)wtr.c_str(), wtr.size() * sizeof(wchar_t));
-    }
-}
-
-#endif/*WIN*/
\ No newline at end of file
diff --git a/test/test_queue.cpp b/test/test_queue.cpp
deleted file mode 100755
index 1d2c732..0000000
--- a/test/test_queue.cpp
+++ /dev/null
@@ -1,299 +0,0 @@
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <memory>
-#include <new>
-#include <vector>
-#include <unordered_map>
-
-#include "libipc/prod_cons.h"
-#include "libipc/policy.h"
-#include "libipc/circ/elem_array.h"
-#include "libipc/queue.h"
-
-#include "test.h"
-
-namespace {
-
-struct msg_t {
-    int pid_;
-    int dat_;
-
-    msg_t() = default;
-    msg_t(int p, int d) : pid_(p), dat_(d) {}
-};
-
-template <ipc::relat Rp, ipc::relat Rc, ipc::trans Ts>
-using queue_t = ipc::queue<msg_t, ipc::policy::choose<ipc::circ::elem_array, ipc::wr<Rp, Rc, Ts>>>;
-
-template <ipc::relat Rp, ipc::relat Rc, ipc::trans Ts>
-struct elems_t : public queue_t<Rp, Rc, Ts>::elems_t {};
-
-bool operator==(msg_t const & m1, msg_t const & m2) noexcept {
-    return (m1.pid_ == m2.pid_) && (m1.dat_ == m2.dat_);
-}
-
-bool operator!=(msg_t const & m1, msg_t const & m2) noexcept {
-    return !(m1 == m2);
-}
-
-constexpr int LoopCount = 1000000;
-constexpr int PushRetry = 1000000;
-constexpr int ThreadMax = 8;
-
-template <typename Que>
-void push(Que & que, int p, int d) {
-    for (int n = 0; !que.push([](void*) { return true; }, p, d); ++n) {
-        ASSERT_NE(n, PushRetry);
-        std::this_thread::yield();
-    }
-}
-
-template <typename Que>
-msg_t pop(Que & que) {
-    msg_t msg;
-    while (!que.pop(msg)) {
-        std::this_thread::yield();
-    }
-    return msg;
-}
-
-template <ipc::trans Ts>
-struct quitter;
-
-template <>
-struct quitter<ipc::trans::unicast> {
-    template <typename Que>
-    static void emit(Que && que, int r_cnt) {
-        for (int k = 0; k < r_cnt; ++k) {
-            push(que, -1, -1);
-        }
-    }
-};
-
-template <>
-struct quitter<ipc::trans::broadcast> {
-    template <typename Que>
-    static void emit(Que && que, int /*r_cnt*/) {
-        push(que, -1, -1);
-    }
-};
-
-template <ipc::relat Rp, ipc::relat Rc, ipc::trans Ts>
-void test_sr(elems_t<Rp, Rc, Ts> && elems, int s_cnt, int r_cnt, char const * message) {
-    ipc_ut::sender().start(static_cast<std::size_t>(s_cnt));
-    ipc_ut::reader().start(static_cast<std::size_t>(r_cnt));
-    ipc_ut::test_stopwatch sw;
-
-    for (int k = 0; k < s_cnt; ++k) {
-        ipc_ut::sender() << [&elems, &sw, r_cnt, k] {
-            queue_t<Rp, Rc, Ts> que { &elems };
-            while (que.conn_count() != static_cast<std::size_t>(r_cnt)) {
-                std::this_thread::yield();
-            }
-            sw.start();
-            for (int i = 0; i < LoopCount; ++i) {
-                push(que, k, i);
-            }
-        };
-    }
-    for (int k = 0; k < r_cnt; ++k) {
-        ipc_ut::reader() << [&elems, k] {
-            queue_t<Rp, Rc, Ts> que { &elems };
-            ASSERT_TRUE(que.connect());
-            while (pop(que).pid_ >= 0) ;
-            ASSERT_TRUE(que.disconnect());
-        };
-    }
-
-    ipc_ut::sender().wait_for_done();
-    quitter<Ts>::emit(queue_t<Rp, Rc, Ts> { &elems }, r_cnt);
-    ipc_ut::reader().wait_for_done();
-    sw.print_elapsed(s_cnt, r_cnt, LoopCount, message);
-}
-
-} // internal-linkage
-
-TEST(Queue, check_size) {
-    using el_t = elems_t<ipc::relat::single, ipc::relat::multi, ipc::trans::broadcast>;
-
-    std::cout << "cq_t::head_size  = " << el_t::head_size << std::endl;
-    std::cout << "cq_t::data_size  = " << el_t::data_size << std::endl;
-    std::cout << "cq_t::elem_size  = " << el_t::elem_size << std::endl;
-    std::cout << "cq_t::block_size = " << el_t::block_size << std::endl;
-
-    EXPECT_EQ(static_cast<std::size_t>(el_t::data_size), sizeof(msg_t));
-
-    std::cout << "sizeof(elems_t<s, m, b>) = " << sizeof(el_t) << std::endl;
-}
-
-TEST(Queue, el_connection) {
-    {
-        elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
-        EXPECT_TRUE(el.connect_sender());
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_FALSE(el.connect_sender());
-        }
-        el.disconnect_sender();
-        EXPECT_TRUE(el.connect_sender());
-    }
-    {
-        elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::unicast> el;
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_TRUE(el.connect_sender());
-        }
-        el.disconnect_sender();
-        EXPECT_TRUE(el.connect_sender());
-    }
-    {
-        elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
-        auto cc = el.connect_receiver();
-        EXPECT_NE(cc, 0);
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_EQ(el.connect_receiver(), 0);
-        }
-        EXPECT_EQ(el.disconnect_receiver(cc), 0);
-        EXPECT_EQ(el.connect_receiver(), cc);
-    }
-    {
-        elems_t<ipc::relat::single, ipc::relat::multi, ipc::trans::broadcast> el;
-        auto cc = el.connect_receiver();
-        EXPECT_EQ(cc, 1);
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_NE(el.connect_receiver(), 0);
-        }
-        EXPECT_EQ(el.disconnect_receiver(cc), 10000);
-        EXPECT_EQ(el.connect_receiver(), 10000 + cc);
-    }
-}
-
-TEST(Queue, connection) {
-    {
-        elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
-        queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
-        // sending
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_TRUE(que.ready_sending());
-        }
-        for (std::size_t i = 0; i < 10000; ++i) {
-            queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
-            ASSERT_FALSE(que.ready_sending());
-        }
-        for (std::size_t i = 0; i < 10000; ++i) {
-            que.shut_sending();
-        }
-        {
-            queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
-            EXPECT_TRUE(que.ready_sending());
-        }
-        // receiving
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_TRUE(que.connect());
-        }
-        for (std::size_t i = 0; i < 10000; ++i) {
-            queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
-            ASSERT_FALSE(que.connect());
-        }
-        EXPECT_TRUE(que.disconnect());
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_FALSE(que.disconnect());
-        }
-        {
-            queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
-            EXPECT_TRUE(que.connect());
-        }
-        for (std::size_t i = 0; i < 10000; ++i) {
-            queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
-            ASSERT_FALSE(que.connect());
-        }
-    }
-    {
-        elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> el;
-        queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-        // sending
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_TRUE(que.ready_sending());
-        }
-        for (std::size_t i = 0; i < 10000; ++i) {
-            queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            ASSERT_TRUE(que.ready_sending());
-        }
-        for (std::size_t i = 0; i < 10000; ++i) {
-            que.shut_sending();
-        }
-        for (std::size_t i = 0; i < 10000; ++i) {
-            queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            ASSERT_TRUE(que.ready_sending());
-        }
-        // receiving
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_TRUE(que.connect());
-        }
-        for (std::size_t i = 0; i < 10000; ++i) {
-            queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            ASSERT_TRUE(que.connect());
-        }
-        ASSERT_TRUE(que.disconnect());
-        for (std::size_t i = 0; i < 10000; ++i) {
-            ASSERT_FALSE(que.disconnect());
-        }
-        for (std::size_t i = 0; i < 10000; ++i) {
-            queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            ASSERT_TRUE(que.connect());
-            ASSERT_TRUE(que.disconnect());
-        }
-    }
-}
-
-TEST(Queue, prod_cons_1v1_unicast) {
-    test_sr(elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast>{}, 1, 1, "ssu");
-    test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::unicast>{}, 1, 1, "smu");
-    test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, 1, 1, "mmu");
-}
-
-TEST(Queue, prod_cons_1v1_broadcast) {
-    test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::broadcast>{}, 1, 1, "smb");
-    test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, 1, 1, "mmb");
-}
-
-TEST(Queue, prod_cons_1vN_unicast) {
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::unicast>{}, 1, i, "smu");
-    }
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, 1, i, "mmu");
-    }
-}
-
-TEST(Queue, prod_cons_1vN_broadcast) {
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::single, ipc::relat::multi , ipc::trans::broadcast>{}, 1, i, "smb");
-    }
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, 1, i, "mmb");
-    }
-}
-
-TEST(Queue, prod_cons_NvN_unicast) {
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, 1, i, "mmu");
-    }
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, i, 1, "mmu");
-    }
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::unicast>{}, i, i, "mmu");
-    }
-}
-
-TEST(Queue, prod_cons_NvN_broadcast) {
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, 1, i, "mmb");
-    }
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, i, 1, "mmb");
-    }
-    for (int i = 1; i <= ThreadMax; ++i) {
-        test_sr(elems_t<ipc::relat::multi , ipc::relat::multi , ipc::trans::broadcast>{}, i, i, "mmb");
-    }
-}
diff --git a/test/test_shm.cpp b/test/test_shm.cpp
deleted file mode 100755
index 3272dcc..0000000
--- a/test/test_shm.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include <cstring>
-#include <cstdint>
-#include <thread>
-
-#include "libipc/shm.h"
-#include "test.h"
-
-using namespace ipc::shm;
-
-namespace {
-
-TEST(SHM, acquire) {
-    handle shm_hd;
-    EXPECT_FALSE(shm_hd.valid());
-
-    EXPECT_TRUE(shm_hd.acquire("my-test-1", 1024));
-    EXPECT_TRUE(shm_hd.valid());
-    EXPECT_STREQ(shm_hd.name(), "my-test-1");
-
-    EXPECT_TRUE(shm_hd.acquire("my-test-2", 2048));
-    EXPECT_TRUE(shm_hd.valid());
-    EXPECT_STREQ(shm_hd.name(), "my-test-2");
-
-    EXPECT_TRUE(shm_hd.acquire("my-test-3", 4096));
-    EXPECT_TRUE(shm_hd.valid());
-    EXPECT_STREQ(shm_hd.name(), "my-test-3");
-}
-
-TEST(SHM, release) {
-    handle shm_hd;
-    EXPECT_FALSE(shm_hd.valid());
-    shm_hd.release();
-    EXPECT_FALSE(shm_hd.valid());
-    EXPECT_TRUE(shm_hd.acquire("release-test-1", 512));
-    EXPECT_TRUE(shm_hd.valid());
-    shm_hd.release();
-    EXPECT_FALSE(shm_hd.valid());
-}
-
-TEST(SHM, get) {
-    handle shm_hd;
-    EXPECT_TRUE(shm_hd.get() == nullptr);
-    EXPECT_TRUE(shm_hd.acquire("get-test", 2048));
-
-    auto mem = shm_hd.get();
-    EXPECT_TRUE(mem != nullptr);
-    EXPECT_TRUE(mem == shm_hd.get());
-
-    std::uint8_t buf[1024] = {};
-    EXPECT_TRUE(memcmp(mem, buf, sizeof(buf)) == 0);
-
-    handle shm_other(shm_hd.name(), shm_hd.size());
-    EXPECT_TRUE(shm_other.get() != shm_hd.get());
-}
-
-TEST(SHM, hello) {
-    handle shm_hd;
-    EXPECT_TRUE(shm_hd.acquire("hello-test", 128));
-    auto mem = shm_hd.get();
-    EXPECT_TRUE(mem != nullptr);
-
-    constexpr char hello[] = "hello!";
-    std::memcpy(mem, hello, sizeof(hello));
-    EXPECT_STREQ((char const *)shm_hd.get(), hello);
-
-    shm_hd.release();
-    EXPECT_TRUE(shm_hd.get() == nullptr);
-    EXPECT_TRUE(shm_hd.acquire("hello-test", 1024));
-
-    mem = shm_hd.get();
-    EXPECT_TRUE(mem != nullptr);
-    std::uint8_t buf[1024] = {};
-    EXPECT_TRUE(memcmp(mem, buf, sizeof(buf)) == 0);
-
-    std::memcpy(mem, hello, sizeof(hello));
-    EXPECT_STREQ((char const *)shm_hd.get(), hello);
-}
-
-TEST(SHM, mt) {
-    handle shm_hd;
-    EXPECT_TRUE(shm_hd.acquire("mt-test", 256));
-    constexpr char hello[] = "hello!";
-    std::memcpy(shm_hd.get(), hello, sizeof(hello));
-
-    std::thread {
-        [&shm_hd] {
-            handle shm_mt(shm_hd.name(), shm_hd.size());
-            shm_hd.release();
-            constexpr char hello[] = "hello!";
-            EXPECT_STREQ((char const *)shm_mt.get(), hello);
-        }
-    }.join();
-
-    EXPECT_TRUE(shm_hd.get() == nullptr);
-    EXPECT_FALSE(shm_hd.valid());
-
-    EXPECT_TRUE(shm_hd.acquire("mt-test", 1024));
-    std::uint8_t buf[1024] = {};
-    EXPECT_TRUE(memcmp(shm_hd.get(), buf, sizeof(buf)) == 0);
-}
-
-} // internal-linkage
diff --git a/test/test_sync.cpp b/test/test_sync.cpp
deleted file mode 100644
index 4cb82e6..0000000
--- a/test/test_sync.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-
-#include <thread>
-#include <iostream>
-#include <mutex>
-#include <chrono>
-#include <deque>
-#include <array>
-#include <cstdio>
-
-#include "test.h"
-
-#include "libipc/platform/detail.h"
-#if defined(IPC_OS_LINUX_)
-#include <pthread.h>
-#include <time.h>
-
-TEST(PThread, Robust) {
-    pthread_mutexattr_t ma;
-    pthread_mutexattr_init(&ma);
-    pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED);
-    pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
-    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    pthread_mutex_init(&mutex, &ma);
-
-    std::thread{[&mutex] {
-        pthread_mutex_lock(&mutex);
-        // pthread_mutex_unlock(&mutex);
-    }}.join();
-
-    struct timespec tout;
-    clock_gettime(CLOCK_REALTIME, &tout);
-    int r = pthread_mutex_timedlock(&mutex, &tout);
-    EXPECT_EQ(r, EOWNERDEAD);
-
-    pthread_mutex_consistent(&mutex);
-    pthread_mutex_unlock(&mutex);
-    pthread_mutex_destroy(&mutex);
-}
-#elif defined(IPC_OS_WINDOWS_)
-#include <Windows.h>
-#include <tchar.h>
-
-TEST(PThread, Robust) {
-    HANDLE lock = CreateMutex(NULL, FALSE, _T("test-robust"));
-    std::thread{[] {
-        HANDLE lock = CreateMutex(NULL, FALSE, _T("test-robust"));
-        WaitForSingleObject(lock, 0);
-    }}.join();
-
-    DWORD r = WaitForSingleObject(lock, 0);
-    EXPECT_EQ(r, WAIT_ABANDONED);
-
-    CloseHandle(lock);
-}
-#endif // OS
-
-#include "libipc/mutex.h"
-
-TEST(Sync, Mutex) {
-    ipc::sync::mutex lock;
-    EXPECT_TRUE(lock.open("test-mutex-robust"));
-    std::thread{[] {
-        ipc::sync::mutex lock {"test-mutex-robust"};
-        EXPECT_TRUE(lock.valid());
-        EXPECT_TRUE(lock.lock());
-    }}.join();
-
-    EXPECT_THROW(lock.try_lock(), std::system_error);
-
-    // int i = 0;
-    // EXPECT_TRUE(lock.lock());
-    // i = 100;
-    // auto t2 = std::thread{[&i] {
-    //     ipc::sync::mutex lock {"test-mutex-robust"};
-    //     EXPECT_TRUE(lock.valid());
-    //     EXPECT_FALSE(lock.try_lock());
-    //     EXPECT_TRUE(lock.lock());
-    //     i += i;
-    //     EXPECT_TRUE(lock.unlock());
-    // }};
-    // std::this_thread::sleep_for(std::chrono::seconds(1));
-    // EXPECT_EQ(i, 100);
-    // EXPECT_TRUE(lock.unlock());
-    // t2.join();
-    // EXPECT_EQ(i, 200);
-}
-
-#include "libipc/semaphore.h"
-
-TEST(Sync, Semaphore) {
-    ipc::sync::semaphore sem;
-    EXPECT_TRUE(sem.open("test-sem"));
-    std::thread{[] {
-        ipc::sync::semaphore sem {"test-sem"};
-        EXPECT_TRUE(sem.post(1000));
-    }}.join();
-
-    for (int i = 0; i < 1000; ++i) {
-        EXPECT_TRUE(sem.wait(0));
-    }
-    EXPECT_FALSE(sem.wait(0));
-}
-
-#include "libipc/condition.h"
-
-TEST(Sync, Condition) {
-    ipc::sync::condition cond;
-    EXPECT_TRUE(cond.open("test-cond"));
-    ipc::sync::mutex lock;
-    EXPECT_TRUE(lock.open("test-mutex"));
-    std::deque<int> que;
-
-    auto job = [&que](int num) {
-        ipc::sync::condition cond {"test-cond"};
-        ipc::sync::mutex lock {"test-mutex"};
-        for (int i = 0; i < 10; ++i) {
-            int val = 0;
-            {
-                std::lock_guard<ipc::sync::mutex> guard {lock};
-                while (que.empty()) {
-                    ASSERT_TRUE(cond.wait(lock));
-                }
-                val = que.front();
-                que.pop_front();
-            }
-            EXPECT_NE(val, 0);
-            std::printf("test-cond-%d: %d\n", num, val);
-        }
-        for (;;) {
-            int val = 0;
-            {
-                std::lock_guard<ipc::sync::mutex> guard {lock};
-                while (que.empty()) {
-                    EXPECT_TRUE(cond.wait(lock, 1000));
-                }
-                val = que.front();
-                que.pop_front();
-            }
-            if (val == 0) {
-                std::printf("test-cond-%d: exit.\n", num);
-                return;
-            }
-            std::printf("test-cond-%d: %d\n", num, val);
-        }
-    };
-    std::array<std::thread, 10> test_conds;
-    for (int i = 0; i < (int)test_conds.size(); ++i) {
-        test_conds[i] = std::thread{job, i};
-    }
-
-    for (int i = 1; i < 100; ++i) {
-        {
-            std::lock_guard<ipc::sync::mutex> guard {lock};
-            que.push_back(i);
-            ASSERT_TRUE(cond.notify(lock));
-        }
-        std::this_thread::sleep_for(std::chrono::milliseconds(20));
-    }
-    for (int i = 1; i < 100; ++i) {
-        {
-            std::lock_guard<ipc::sync::mutex> guard {lock};
-            que.push_back(i);
-            ASSERT_TRUE(cond.broadcast(lock));
-        }
-        std::this_thread::sleep_for(std::chrono::milliseconds(20));
-    }
-    {
-        std::lock_guard<ipc::sync::mutex> guard {lock};
-        for (int i = 0; i < (int)test_conds.size(); ++i) {
-            que.push_back(0);
-        }
-        ASSERT_TRUE(cond.broadcast(lock));
-    }
-
-    for (auto &t : test_conds) t.join();
-}
-
-/**
- * https://stackoverflow.com/questions/51730660/is-this-a-bug-in-glibc-pthread
-*/
-TEST(Sync, ConditionRobust) {
-    printf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1\n");
-    ipc::sync::condition cond {"test-cond"};
-    printf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 2\n");
-    ipc::sync::mutex lock {"test-mutex"};
-    printf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 3\n");
-    ASSERT_TRUE(lock.lock());
-    std::thread unlock {[] {
-        printf("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWW 1\n");
-        ipc::sync::condition cond {"test-cond"};
-        printf("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWW 2\n");
-        ipc::sync::mutex lock {"test-mutex"};
-        printf("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWW 3\n");
-        {
-            std::lock_guard<ipc::sync::mutex> guard {lock};
-        }
-        std::this_thread::sleep_for(std::chrono::seconds(1));
-        printf("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWW 4\n");
-        ASSERT_TRUE(cond.broadcast(lock));
-        printf("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWW 5\n");
-    }};
-    printf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 4\n");
-    ASSERT_TRUE(cond.wait(lock));
-    printf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 5\n");
-    ASSERT_TRUE(lock.unlock());
-    printf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 6\n");
-    unlock.join();
-}
\ No newline at end of file
diff --git a/test/test_thread_utility.cpp b/test/test_thread_utility.cpp
deleted file mode 100755
index 02dd0c2..0000000
--- a/test/test_thread_utility.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-#include <type_traits>
-#include <iostream>
-#include <shared_mutex> // std::shared_lock
-#include <utility>
-#include <thread>
-#include <future>       // std::async
-#include <atomic>
-#include <string>       // std::string
-
-#include "capo/spin_lock.hpp"
-#include "capo/type_name.hpp"
-
-#include "libipc/rw_lock.h"
-
-#include "test.h"
-#include "thread_pool.h"
-
-namespace {
-
-constexpr int LoopCount = 100000;
-constexpr int ThreadMax = 8;
-
-template <typename T>
-constexpr T acc(T b, T e) noexcept {
-    return (e + b) * (e - b + 1) / 2;
-}
-
-template <typename Mutex>
-struct lc_wrapper : Mutex {
-    void lock_shared  () { Mutex::lock  (); }
-    void unlock_shared() { Mutex::unlock(); }
-};
-
-template <typename Lc, int Loops = LoopCount>
-void benchmark_lc(int w, int r, char const * message) {
-    ipc_ut::sender().start(static_cast<std::size_t>(w));
-    ipc_ut::reader().start(static_cast<std::size_t>(r));
-    ipc_ut::test_stopwatch sw;
-
-    std::uint64_t data = 0;
-    std::uint64_t sum  = acc<std::uint64_t>(1, Loops) * w;
-    Lc lc;
-
-    for (int k = 0; k < r; ++k) {
-        ipc_ut::reader() << [sum, &lc, &data] {
-            while (1) {
-                {
-                    std::shared_lock<Lc> guard { lc };
-                    if (data == sum) break;
-                }
-                std::this_thread::yield();
-            }
-        };
-    }
-
-    for (int k = 0; k < w; ++k) {
-        ipc_ut::sender() << [&sw, &lc, &data] {
-            sw.start();
-            for (int i = 1; i <= Loops; ++i) {
-                {
-                    std::lock_guard<Lc> guard { lc };
-                    data += i;
-                }
-                std::this_thread::yield();
-            }
-        };
-    }
-
-    ipc_ut::sender().wait_for_done();
-    sw.print_elapsed(w, r, Loops, message);
-    ipc_ut::reader().wait_for_done();
-}
-
-void test_lock_performance(int w, int r) {
-    std::cout << "test_lock_performance: [" << w << "-" << r << "]" << std::endl;
-    benchmark_lc<ipc::rw_lock               >(w, r, "ipc::rw_lock");
-    benchmark_lc<lc_wrapper< ipc::spin_lock>>(w, r, "ipc::spin_lock");
-    benchmark_lc<lc_wrapper<capo::spin_lock>>(w, r, "capo::spin_lock");
-    benchmark_lc<lc_wrapper<std::mutex>     >(w, r, "std::mutex");
-    // benchmark_lc<std::shared_mutex          >(w, r, "std::shared_mutex");
-}
-
-} // internal-linkage
-
-//TEST(Thread, rw_lock) {
-//    for (int i = 1; i <= ThreadMax; ++i) test_lock_performance(i, 0);
-//    for (int i = 1; i <= ThreadMax; ++i) test_lock_performance(1, i);
-//    for (int i = 2; i <= ThreadMax; ++i) test_lock_performance(i, i);
-//}
-
-#if 0 // disable ipc::tls
-TEST(Thread, tls_main_thread) {
-    ipc::tls::pointer<int> p;
-    EXPECT_FALSE(p);
-    EXPECT_NE(p.create(123), nullptr);
-    EXPECT_EQ(*p, 123);
-}
-
-namespace {
-
-struct Foo {
-    std::atomic<int> * px_;
-    Foo(std::atomic<int> * px) : px_(px) {}
-    ~Foo() {
-        px_->fetch_add(1, std::memory_order_relaxed);
-    }
-};
-
-} // namespace
-
-TEST(Thread, tls_create_once) {
-    std::atomic<int> x { 0 };
-    Foo { &x };
-    EXPECT_EQ(x, 1);
-    {
-        ipc::tls::pointer<Foo> foo;
-        EXPECT_NE(foo.create(&x), nullptr);
-        EXPECT_EQ(x, 1);
-
-        std::thread {[&foo, &x] {
-            auto foo1 = foo.create_once(&x);
-            auto foo2 = foo.create_once(&x);
-            EXPECT_EQ(foo1, foo2);
-        }}.join();
-        EXPECT_EQ(x, 2);
-    }
-    EXPECT_EQ(x, 3);
-}
-
-TEST(Thread, tls_multi_thread) {
-    std::atomic<int> x { 0 };
-    {
-        ipc::tls::pointer<Foo> foo; // no create
-        EXPECT_EQ(x, 0);
-
-        ipc_ut::thread_pool pool { 10 };
-        for (int i = 0; i < 1000; ++i) {
-          pool << [&foo, &x] {
-            // foo.create_once(&x);
-            std::this_thread::sleep_for(std::chrono::milliseconds(1));
-          };
-        }
-        pool.wait_for_done();
-        EXPECT_EQ(x, 0); // thread_pool hasn't destructed.
-    }
-    // EXPECT_EQ(x, 10);
-}
-
-namespace {
-
-template <typename Tls, typename T>
-void benchmark_tls(char const * message) {
-    ipc_ut::thread_pool pool { static_cast<std::size_t>(ThreadMax) };
-    ipc_ut::test_stopwatch sw;
-    pool.wait_for_started();
-
-    for (int k = 0; k < ThreadMax; ++k) {
-        pool << [&sw] {
-            sw.start();
-            for (int i = 0; i < LoopCount * 10; ++i) {
-                *Tls::template get<T>() = i;
-            }
-        };
-    }
-
-    pool.wait_for_done();
-    sw.print_elapsed(ThreadMax, LoopCount * 10, message);
-}
-
-struct ipc_tls {
-    template <typename T>
-    static T * get() {
-        static ipc::tls::pointer<T> p;
-        return p.create_once();
-    }
-};
-
-struct std_tls {
-    template <typename T>
-    static T * get() {
-        thread_local T p;
-        return &p;
-    }
-};
-
-struct Str {
-    std::string str_;
-
-    Str & operator=(int i) {
-        str_ = std::to_string(i);
-        return *this;
-    }
-};
-
-} // internal-linkage
-
-TEST(Thread, tls_benchmark) {
-    benchmark_tls<std_tls, int>("std_tls: int");
-    benchmark_tls<ipc_tls, int>("ipc_tls: int");
-    benchmark_tls<std_tls, Str>("std_tls: Str");
-    benchmark_tls<ipc_tls, Str>("ipc_tls: Str");
-}
-#endif
\ No newline at end of file
diff --git a/test/test_waiter.cpp b/test/test_waiter.cpp
deleted file mode 100755
index 727cca0..0000000
--- a/test/test_waiter.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include <thread>
-#include <iostream>
-
-#include "libipc/waiter.h"
-#include "test.h"
-
-namespace {
-
-TEST(Waiter, broadcast) {
-    for (int i = 0; i < 10; ++i) {
-        ipc::detail::waiter waiter;
-        std::thread ts[10];
-
-        int k = 0;
-        for (auto& t : ts) {
-            t = std::thread([&k] {
-                ipc::detail::waiter waiter {"test-ipc-waiter"};
-                EXPECT_TRUE(waiter.valid());
-                for (int i = 0; i < 9; ++i) {
-                    while (!waiter.wait_if([&k, &i] { return k == i; })) ;
-                }
-            });
-        }
-
-        EXPECT_TRUE(waiter.open("test-ipc-waiter"));
-        std::cout << "waiting for broadcast...\n";
-        for (k = 1; k < 10; ++k) {
-            std::cout << "broadcast: " << k << "\n";
-            ASSERT_TRUE(waiter.broadcast());
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        }
-        for (auto& t : ts) t.join();
-        std::cout << "quit... " << i << "\n";
-    }
-}
-
-TEST(Waiter, quit_waiting) {
-    ipc::detail::waiter waiter;
-    EXPECT_TRUE(waiter.open("test-ipc-waiter"));
-
-    std::thread t1 {
-        [&waiter] {
-            EXPECT_TRUE(waiter.wait_if([] { return true; }));
-        }
-    };
-
-    bool quit = false;
-    std::thread t2 {
-        [&quit] {
-            ipc::detail::waiter waiter {"test-ipc-waiter"};
-            EXPECT_TRUE(waiter.wait_if([&quit] { return !quit; }));
-        }
-    };
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    EXPECT_TRUE(waiter.quit_waiting());
-    t1.join();
-    ASSERT_TRUE(t2.joinable());
-
-    EXPECT_TRUE(waiter.open("test-ipc-waiter"));
-    std::cout << "nofify quit...\n";
-    quit = true;
-    EXPECT_TRUE(waiter.notify());
-    t2.join();
-    std::cout << "quit... \n";
-}
-
-} // internal-linkage
diff --git a/test/thread_pool.h b/test/thread_pool.h
deleted file mode 100755
index 03b7e8f..0000000
--- a/test/thread_pool.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#pragma once
-
-#include <thread>             // std::thread
-#include <mutex>              // std::mutex
-#include <condition_variable> // std::condition_variable
-#include <deque>              // std::deque
-#include <functional>         // std::function
-#include <utility>            // std::forward, std::move
-#include <cstddef>            // std::size_t
-#include <cassert>            // assert
-
-#include "capo/scope_guard.hpp"
-
-namespace ipc_ut {
-
-class thread_pool final {
-
-  std::deque<std::thread> workers_;
-  std::deque<std::function<void()>> jobs_;
-
-  std::mutex lock_;
-  std::condition_variable cv_jobs_;
-  std::condition_variable cv_empty_;
-
-  std::size_t waiting_cnt_ = 0;
-  bool quit_ = false;
-
-  static void proc(thread_pool * pool) {
-    assert(pool != nullptr);
-    std::function<void()> job;
-    for (;;) {
-      {
-        std::unique_lock<std::mutex> guard { pool->lock_ };
-        if (pool->quit_) return;
-        if (pool->jobs_.empty()) {
-          pool->waiting_cnt_ += 1;
-          CAPO_SCOPE_GUARD_ = [pool] {
-              pool->waiting_cnt_ -= 1;
-          };
-
-          if (pool->waiting_cnt_ == pool->workers_.size()) {
-            pool->cv_empty_.notify_all();
-          }
-          assert(pool->waiting_cnt_ <= pool->workers_.size());
-          do {
-            pool->cv_jobs_.wait(guard);
-            if (pool->quit_) return;
-          } while (pool->jobs_.empty());
-        }
-        assert(!pool->jobs_.empty());
-        job = std::move(pool->jobs_.front());
-        pool->jobs_.pop_front();
-      }
-      if (job) job();
-    }
-  }
-
-public:
-  thread_pool() = default;
-
-  ~thread_pool() {
-    {
-      std::lock_guard<std::mutex> guard { lock_ };
-      static_cast<void>(guard);
-      quit_ = true;
-    }
-    cv_jobs_.notify_all();
-    cv_empty_.notify_all();
-    for (auto & trd : workers_) trd.join();
-  }
-
-  explicit thread_pool(std::size_t n) : thread_pool() {
-    start(n);
-  }
-
-  void start(std::size_t n) {
-    std::unique_lock<std::mutex> guard { lock_ };
-    if (n <= workers_.size()) return;
-    for (std::size_t i = workers_.size(); i < n; ++i) {
-      workers_.push_back(std::thread { &thread_pool::proc, this });
-    }
-  }
-
-  std::size_t size() const noexcept {
-    return workers_.size();
-  }
-
-  std::size_t jobs_size() const noexcept {
-    return jobs_.size();
-  }
-
-  void wait_for_started() {
-    std::unique_lock<std::mutex> guard { lock_ };
-    if (quit_) return;
-    while (!workers_.empty() && (waiting_cnt_ != workers_.size())) {
-      cv_empty_.wait(guard);
-      if (quit_) return;
-    }
-  }
-
-  void wait_for_done() {
-    std::unique_lock<std::mutex> guard { lock_ };
-    if (quit_) return;
-    while (!jobs_.empty() || (waiting_cnt_ != workers_.size())) {
-      assert(waiting_cnt_ <= workers_.size());
-      cv_empty_.wait(guard);
-      if (quit_) return;
-    }
-  }
-
-  template <typename F>
-  thread_pool & operator<<(F && job) {
-    {
-      std::lock_guard<std::mutex> guard { lock_ };
-      static_cast<void>(guard);
-      jobs_.emplace_back(std::forward<F>(job));
-    }
-    cv_jobs_.notify_one();
-    return *this;
-  }
-};
-
-} // namespace ipc_ut
\ No newline at end of file