diff --git a/.gitignore b/.gitignore
index 9bca0610..b8573713 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,6 +28,7 @@ ui_*.h
 *.jsc
 Makefile*
 *build-*
+*build_*
 
 # Qt unit tests
 target_wrapper.*
diff --git a/3rdparty/gtest/src/gtest-death-test.cc b/3rdparty/gtest/src/gtest-death-test.cc
index da09a1cf..7419ba2c 100644
--- a/3rdparty/gtest/src/gtest-death-test.cc
+++ b/3rdparty/gtest/src/gtest-death-test.cc
@@ -1296,8 +1296,8 @@ static void StackLowerThanAddress(const void* ptr, bool* result) {
 GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
 GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
 static bool StackGrowsDown() {
-  int dummy;
-  bool result;
+  int dummy {};
+  bool result {};
   StackLowerThanAddress(&dummy, &result);
   return result;
 }
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6d9b2a57..7e07dd3c 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -59,6 +59,13 @@ if (LIBIPC_BUILD_DEMOS)
     add_subdirectory(demo/chat)
     add_subdirectory(demo/msg_que)
     add_subdirectory(demo/send_recv)
+    if (MSVC)
+        add_subdirectory(demo/win_service/service)
+        add_subdirectory(demo/win_service/client)
+    else()
+        add_subdirectory(demo/linux_service/service)
+        add_subdirectory(demo/linux_service/client)
+    endif()
 endif()
 
 install(
diff --git a/demo/linux_service/client/CMakeLists.txt b/demo/linux_service/client/CMakeLists.txt
new file mode 100644
index 00000000..b7d83920
--- /dev/null
+++ b/demo/linux_service/client/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(linux_client)
+
+file(GLOB SRC_FILES ./*.cpp)
+file(GLOB HEAD_FILES ./*.h)
+
+add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
+
+target_link_libraries(${PROJECT_NAME} ipc)
diff --git a/demo/linux_service/client/main.cpp b/demo/linux_service/client/main.cpp
new file mode 100644
index 00000000..9839be92
--- /dev/null
+++ b/demo/linux_service/client/main.cpp
@@ -0,0 +1,28 @@
+/// \brief To create a basic command line program.
+
+#include <stdio.h>
+#include <thread>
+#include <chrono>
+
+#include "libipc/ipc.h"
+
+int main(int argc, char *argv[]) {
+    printf("My Sample Client: Entry\n");
+    ipc::channel ipc_r{"service ipc r", ipc::receiver};
+    ipc::channel ipc_w{"service ipc w", ipc::sender};
+    while (1) {
+        auto msg = ipc_r.recv();
+        if (msg.empty()) {
+            printf("My Sample Client: message recv error\n");
+            return -1;
+        }
+        printf("My Sample Client: message recv: [%s]\n", (char const *)msg.data());
+        while (!ipc_w.send("Copy.")) {
+            printf("My Sample Client: message send error\n");
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+        printf("My Sample Client: message send [Copy]\n");
+    }
+    printf("My Sample Client: Exit\n");
+    return 0;
+}
diff --git a/demo/linux_service/service/CMakeLists.txt b/demo/linux_service/service/CMakeLists.txt
new file mode 100644
index 00000000..a8773377
--- /dev/null
+++ b/demo/linux_service/service/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(linux_service)
+
+file(GLOB SRC_FILES ./*.cpp)
+file(GLOB HEAD_FILES ./*.h)
+
+add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
+
+target_link_libraries(${PROJECT_NAME} ipc)
diff --git a/demo/linux_service/service/main.cpp b/demo/linux_service/service/main.cpp
new file mode 100644
index 00000000..cf8dec37
--- /dev/null
+++ b/demo/linux_service/service/main.cpp
@@ -0,0 +1,34 @@
+/// \brief To create a basic command line program.
+
+#include <stdio.h>
+#include <string>
+#include <thread>
+#include <chrono>
+
+#include "libipc/ipc.h"
+
+int main(int argc, char *argv[]) {
+    printf("My Sample Service: Main: Entry\n");
+
+    ipc::channel ipc_r{"service ipc r", ipc::sender};
+    ipc::channel ipc_w{"service ipc w", ipc::receiver};
+
+    while (1) {
+        if (!ipc_r.send("Hello, World!")) {
+            printf("My Sample Service: send failed.\n");
+        }
+        else {
+            printf("My Sample Service: send [Hello, World!]\n");
+            auto msg = ipc_w.recv(1000);
+            if (msg.empty()) {
+                printf("My Sample Service: recv error\n");
+            } else {
+                printf("%s\n", (std::string{"My Sample Service: recv ["} + msg.get<char const *>() + "]").c_str());
+            }
+        }
+        std::this_thread::sleep_for(std::chrono::seconds(3));
+    }
+
+    printf("My Sample Service: Main: Exit\n");
+    return 0;
+}
diff --git a/demo/win_service/client/CMakeLists.txt b/demo/win_service/client/CMakeLists.txt
new file mode 100644
index 00000000..2dc03d5a
--- /dev/null
+++ b/demo/win_service/client/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(win_client)
+
+file(GLOB SRC_FILES ./*.cpp)
+file(GLOB HEAD_FILES ./*.h)
+
+add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
+
+target_link_libraries(${PROJECT_NAME} ipc)
diff --git a/demo/win_service/client/main.cpp b/demo/win_service/client/main.cpp
new file mode 100644
index 00000000..44a9ba62
--- /dev/null
+++ b/demo/win_service/client/main.cpp
@@ -0,0 +1,41 @@
+/// \brief To create a basic Windows command line program.
+
+#include <Windows.h>
+#include <tchar.h>
+#include <stdio.h>
+
+#include "libipc/ipc.h"
+
+int _tmain (int argc, TCHAR *argv[]) {
+    _tprintf(_T("My Sample Client: Entry\n"));
+    ipc::channel ipc_r{ipc::prefix{"Global\\"}, "service ipc r", ipc::receiver};
+    ipc::channel ipc_w{ipc::prefix{"Global\\"}, "service ipc w", ipc::sender};
+    while (1) {
+        if (!ipc_r.reconnect(ipc::receiver)) {
+            Sleep(1000);
+            continue;
+        }
+        auto msg = ipc_r.recv();
+        if (msg.empty()) {
+            _tprintf(_T("My Sample Client: message recv error\n"));
+            ipc_r.disconnect();
+            continue;
+        }
+        printf("My Sample Client: message recv: [%s]\n", (char const *)msg.data());
+        for (;;) {
+            if (!ipc_w.reconnect(ipc::sender)) {
+                Sleep(1000);
+                continue;
+            }
+            if (ipc_w.send("Copy.")) {
+                break;
+            }
+            _tprintf(_T("My Sample Client: message send error\n"));
+            ipc_w.disconnect();
+            Sleep(1000);
+        }
+        _tprintf(_T("My Sample Client: message send [Copy]\n"));
+    }
+    _tprintf(_T("My Sample Client: Exit\n"));
+    return 0;
+}
diff --git a/demo/win_service/service/CMakeLists.txt b/demo/win_service/service/CMakeLists.txt
new file mode 100644
index 00000000..b7bb3574
--- /dev/null
+++ b/demo/win_service/service/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(win_service)
+
+file(GLOB SRC_FILES ./*.cpp)
+file(GLOB HEAD_FILES ./*.h)
+
+add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
+
+target_link_libraries(${PROJECT_NAME} ipc)
diff --git a/demo/win_service/service/main.cpp b/demo/win_service/service/main.cpp
new file mode 100644
index 00000000..ce522280
--- /dev/null
+++ b/demo/win_service/service/main.cpp
@@ -0,0 +1,189 @@
+/// \brief To create a basic Windows Service in C++.
+/// \see https://www.codeproject.com/Articles/499465/Simple-Windows-Service-in-Cplusplus
+
+#include <Windows.h>
+#include <tchar.h>
+#include <string>
+
+#include "libipc/ipc.h"
+
+SERVICE_STATUS        g_ServiceStatus = {0};
+SERVICE_STATUS_HANDLE g_StatusHandle = NULL;
+HANDLE                g_ServiceStopEvent = INVALID_HANDLE_VALUE;
+
+VOID WINAPI ServiceMain (DWORD argc, LPTSTR *argv);
+VOID WINAPI ServiceCtrlHandler (DWORD);
+DWORD WINAPI ServiceWorkerThread (LPVOID lpParam);
+
+#define SERVICE_NAME  _T("My Sample Service")
+
+int _tmain (int argc, TCHAR *argv[]) {
+    OutputDebugString(_T("My Sample Service: Main: Entry"));
+
+    SERVICE_TABLE_ENTRY ServiceTable[] = {
+        {SERVICE_NAME, (LPSERVICE_MAIN_FUNCTION) ServiceMain},
+        {NULL, NULL}
+    };
+
+    if (StartServiceCtrlDispatcher (ServiceTable) == FALSE) {
+        OutputDebugString(_T("My Sample Service: Main: StartServiceCtrlDispatcher returned error"));
+        return GetLastError ();
+    }
+
+    OutputDebugString(_T("My Sample Service: Main: Exit"));
+    return 0;
+}
+
+VOID WINAPI ServiceMain (DWORD argc, LPTSTR *argv) {
+    DWORD Status = E_FAIL;
+
+    OutputDebugString(_T("My Sample Service: ServiceMain: Entry"));
+
+    g_StatusHandle = RegisterServiceCtrlHandler (SERVICE_NAME, ServiceCtrlHandler);
+
+    if (g_StatusHandle == NULL) {
+        OutputDebugString(_T("My Sample Service: ServiceMain: RegisterServiceCtrlHandler returned error"));
+        goto EXIT;
+    }
+
+    // Tell the service controller we are starting
+    ZeroMemory (&g_ServiceStatus, sizeof (g_ServiceStatus));
+    g_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+    g_ServiceStatus.dwControlsAccepted = 0;
+    g_ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
+    g_ServiceStatus.dwWin32ExitCode = 0;
+    g_ServiceStatus.dwServiceSpecificExitCode = 0;
+    g_ServiceStatus.dwCheckPoint = 0;
+
+    if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+        OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+    }
+
+    /* 
+     * Perform tasks neccesary to start the service here
+     */
+    OutputDebugString(_T("My Sample Service: ServiceMain: Performing Service Start Operations"));
+
+    // Create stop event to wait on later.
+    g_ServiceStopEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
+    if (g_ServiceStopEvent == NULL) {
+        OutputDebugString(_T("My Sample Service: ServiceMain: CreateEvent(g_ServiceStopEvent) returned error"));
+
+        g_ServiceStatus.dwControlsAccepted = 0;
+        g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
+        g_ServiceStatus.dwWin32ExitCode = GetLastError();
+        g_ServiceStatus.dwCheckPoint = 1;
+
+        if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+            OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+        }
+        goto EXIT; 
+    }    
+
+    // Tell the service controller we are started
+    g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
+    g_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
+    g_ServiceStatus.dwWin32ExitCode = 0;
+    g_ServiceStatus.dwCheckPoint = 0;
+
+    if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+        OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+    }
+
+    // Start the thread that will perform the main task of the service
+    HANDLE hThread = CreateThread (NULL, 0, ServiceWorkerThread, NULL, 0, NULL);
+
+    OutputDebugString(_T("My Sample Service: ServiceMain: Waiting for Worker Thread to complete"));
+
+    // Wait until our worker thread exits effectively signaling that the service needs to stop
+    WaitForSingleObject (hThread, INFINITE);
+    
+    OutputDebugString(_T("My Sample Service: ServiceMain: Worker Thread Stop Event signaled"));
+    
+    
+    /* 
+     * Perform any cleanup tasks
+     */
+    OutputDebugString(_T("My Sample Service: ServiceMain: Performing Cleanup Operations"));
+
+    CloseHandle (g_ServiceStopEvent);
+
+    g_ServiceStatus.dwControlsAccepted = 0;
+    g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
+    g_ServiceStatus.dwWin32ExitCode = 0;
+    g_ServiceStatus.dwCheckPoint = 3;
+
+    if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+        OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+    }
+    
+EXIT:
+    OutputDebugString(_T("My Sample Service: ServiceMain: Exit"));
+    return;
+}
+
+VOID WINAPI ServiceCtrlHandler (DWORD CtrlCode) {
+    OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: Entry"));
+
+    switch (CtrlCode) {
+    case SERVICE_CONTROL_STOP :
+
+        OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: SERVICE_CONTROL_STOP Request"));
+
+        if (g_ServiceStatus.dwCurrentState != SERVICE_RUNNING)
+           break;
+
+        /* 
+         * Perform tasks neccesary to stop the service here 
+         */
+        
+        g_ServiceStatus.dwControlsAccepted = 0;
+        g_ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
+        g_ServiceStatus.dwWin32ExitCode = 0;
+        g_ServiceStatus.dwCheckPoint = 4;
+
+        if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+            OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: SetServiceStatus returned error"));
+        }
+
+        // This will signal the worker thread to start shutting down
+        SetEvent (g_ServiceStopEvent);
+
+        break;
+
+    default:
+        break;
+    }
+
+    OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: Exit"));
+}
+
+DWORD WINAPI ServiceWorkerThread (LPVOID lpParam) {
+    OutputDebugString(_T("My Sample Service: ServiceWorkerThread: Entry"));
+    ipc::channel ipc_r{ipc::prefix{"Global\\"}, "service ipc r", ipc::sender};
+    ipc::channel ipc_w{ipc::prefix{"Global\\"}, "service ipc w", ipc::receiver};
+
+    //  Periodically check if the service has been requested to stop
+    while (WaitForSingleObject(g_ServiceStopEvent, 0) != WAIT_OBJECT_0) {        
+        /* 
+         * Perform main service function here
+         */
+        if (!ipc_r.send("Hello, World!")) {
+            OutputDebugString(_T("My Sample Service: send failed."));
+        }
+        else {
+            OutputDebugString(_T("My Sample Service: send [Hello, World!]"));
+            auto msg = ipc_w.recv(1000);
+            if (msg.empty()) {
+                OutputDebugString(_T("My Sample Service: recv error"));
+            } else {
+                OutputDebugStringA((std::string{"My Sample Service: recv ["} + msg.get<char const *>() + "]").c_str());
+            }
+        }
+        Sleep(3000);
+    }
+
+    OutputDebugString(_T("My Sample Service: ServiceWorkerThread: Exit"));
+
+    return ERROR_SUCCESS;
+}
diff --git a/include/libipc/def.h b/include/libipc/def.h
index 8c1a72ba..45cd7801 100755
--- a/include/libipc/def.h
+++ b/include/libipc/def.h
@@ -65,4 +65,9 @@ struct relat_trait<wr<Rp, Rc, Ts>> {
 template <template <typename> class Policy, typename Flag>
 struct relat_trait<Policy<Flag>> : relat_trait<Flag> {};
 
+// the prefix tag of a channel
+struct prefix {
+    char const *str;
+};
+
 } // namespace ipc
diff --git a/include/libipc/ipc.h b/include/libipc/ipc.h
index 882367c8..881ef260 100755
--- a/include/libipc/ipc.h
+++ b/include/libipc/ipc.h
@@ -22,6 +22,7 @@ struct IPC_EXPORT chan_impl {
     static ipc::handle_t inited();
 
     static bool connect   (ipc::handle_t * ph, char const * name, unsigned mode);
+    static bool connect   (ipc::handle_t * ph, prefix, 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);
@@ -54,6 +55,10 @@ class chan_wrapper {
         : connected_{this->connect(name, mode)} {
     }
 
+    chan_wrapper(prefix pref, char const * name, unsigned mode = ipc::sender)
+        : connected_{this->connect(pref, name, mode)} {
+    }
+
     chan_wrapper(chan_wrapper&& rhs) noexcept
         : chan_wrapper{} {
         swap(rhs);
@@ -102,6 +107,11 @@ class chan_wrapper {
         detail_t::disconnect(h_); // clear old connection
         return connected_ = detail_t::connect(&h_, name, mode_ = mode);
     }
+    bool connect(prefix pref, 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_, pref, name, mode_ = mode);
+    }
 
     /**
      * Try connecting with new mode flags.
@@ -169,26 +179,22 @@ 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.
+ * \class route
  *
- * A route could only be used in 1 to N
- * (one producer/writer to multi consumers/readers)
+ * \note 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
+ * \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.
+ * \note 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/src/libipc/circ/elem_array.h b/src/libipc/circ/elem_array.h
index 0b21f486..adadf941 100755
--- a/src/libipc/circ/elem_array.h
+++ b/src/libipc/circ/elem_array.h
@@ -37,8 +37,8 @@ class elem_array : public ipc::circ::conn_head<Policy> {
     elem_t   block_[elem_max] {};
 
     /**
-     * @remarks 'warning C4348: redefinition of default parameter' with MSVC.
-     * @see
+     * \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
     */
diff --git a/src/libipc/ipc.cpp b/src/libipc/ipc.cpp
index f09f9725..6b6432e1 100755
--- a/src/libipc/ipc.cpp
+++ b/src/libipc/ipc.cpp
@@ -9,6 +9,7 @@
 #include <vector>
 #include <array>
 #include <cassert>
+#include <mutex>
 
 #include "libipc/ipc.h"
 #include "libipc/def.h"
@@ -69,6 +70,23 @@ ipc::buff_t make_cache(T& data, std::size_t size) {
     return { ptr, size, ipc::mem::free };
 }
 
+acc_t *cc_acc(ipc::string const &pref) {
+    static ipc::unordered_map<ipc::string, ipc::shm::handle> handles;
+    static std::mutex lock;
+    std::lock_guard<std::mutex> guard {lock};
+    auto it = handles.find(pref);
+    if (it == handles.end()) {
+        ipc::string shm_name {ipc::make_prefix(pref, {"CA_CONN__"})};
+        ipc::shm::handle h;
+        if (!h.acquire(shm_name.c_str(), sizeof(acc_t))) {
+            ipc::error("[cc_acc] acquire failed: %s\n", shm_name.c_str());
+            return nullptr;
+        }
+        it = handles.emplace(pref, std::move(h)).first;
+    }
+    return static_cast<acc_t *>(it->second.get());
+}
+
 struct cache_t {
     std::size_t fill_;
     ipc::buff_t buff_;
@@ -85,10 +103,54 @@ struct cache_t {
     }
 };
 
-auto cc_acc() {
-    static ipc::shm::handle acc_h("__CA_CONN__", sizeof(acc_t));
-    return static_cast<acc_t*>(acc_h.get());
-}
+struct conn_info_head {
+
+    ipc::string prefix_;
+    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 * prefix, char const * name)
+        : prefix_{ipc::make_string(prefix)}
+        , name_  {ipc::make_string(name)}
+        , cc_id_ {} {}
+
+    void init() {
+        if (!cc_waiter_.valid()) cc_waiter_.open(ipc::make_prefix(prefix_, {"CC_CONN__", name_}).c_str());
+        if (!wt_waiter_.valid()) wt_waiter_.open(ipc::make_prefix(prefix_, {"WT_CONN__", name_}).c_str());
+        if (!rd_waiter_.valid()) rd_waiter_.open(ipc::make_prefix(prefix_, {"RD_CONN__", name_}).c_str());
+        if (!acc_h_.valid()) acc_h_.acquire(ipc::make_prefix(prefix_, {"AC_CONN__", name_}).c_str(), sizeof(acc_t));
+        if (cc_id_ != 0) {
+            return;
+        }
+        acc_t *pacc = cc_acc(prefix_);
+        if (pacc == nullptr) {
+            // Failed to obtain the global accumulator.
+            return;
+        }
+        cc_id_ = pacc->fetch_add(1, std::memory_order_relaxed) + 1;
+        if (cc_id_ == 0) {
+            // The identity cannot be 0.
+            cc_id_ = pacc->fetch_add(1, std::memory_order_relaxed) + 1;
+        }
+    }
+
+    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;
+    }
+};
 
 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;
@@ -130,17 +192,32 @@ struct chunk_info_t {
 
 auto& chunk_storages() {
     class chunk_handle_t {
-        ipc::shm::handle handle_;
+        ipc::unordered_map<ipc::string, ipc::shm::handle> handles_;
+        std::mutex lock_;
 
-    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) )) {
+        static bool make_handle(ipc::shm::handle &h, ipc::string const &shm_name, std::size_t chunk_size) {
+            if (!h.valid() &&
+                !h.acquire( shm_name.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;
+                return false;
+            }
+            return true;
+        }
+
+    public:
+        chunk_info_t *get_info(conn_info_head *inf, std::size_t chunk_size) {
+            ipc::string pref {(inf == nullptr) ? ipc::string{} : inf->prefix_};
+            ipc::string shm_name {ipc::make_prefix(pref, {"CHUNK_INFO__", ipc::to_string(chunk_size)})};
+            ipc::shm::handle *h;
+            {
+                std::lock_guard<std::mutex> guard {lock_};
+                h = &(handles_[pref]);
+                if (!make_handle(*h, shm_name, chunk_size)) {
+                    return nullptr;
+                }
             }
-            auto info = static_cast<chunk_info_t*>(handle_.get());
+            auto *info = static_cast<chunk_info_t*>(h->get());
             if (info == nullptr) {
                 ipc::error("[chunk_storages] chunk_shm.id_info_.get failed: chunk_size = %zd\n", chunk_size);
                 return nullptr;
@@ -148,29 +225,35 @@ auto& chunk_storages() {
             return info;
         }
     };
-    static ipc::map<std::size_t, chunk_handle_t> chunk_hs;
+    using deleter_t = void (*)(chunk_handle_t*);
+    using chunk_handle_ptr_t = std::unique_ptr<chunk_handle_t, deleter_t>;
+    static ipc::map<std::size_t, chunk_handle_ptr_t> chunk_hs;
     return chunk_hs;
 }
 
-chunk_info_t *chunk_storage_info(std::size_t chunk_size) {
+chunk_info_t *chunk_storage_info(conn_info_head *inf, 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;
+            using chunk_handle_ptr_t = std::decay_t<decltype(storages)>::value_type::second_type;
+            using chunk_handle_t     = chunk_handle_ptr_t::element_type;
             guard.unlock();
             IPC_UNUSED_ std::lock_guard<ipc::rw_lock> guard {lock};
-            it = storages.emplace(chunk_size, chunk_handle_t{}).first;
+            it = storages.emplace(chunk_size, chunk_handle_ptr_t{
+                ipc::mem::alloc<chunk_handle_t>(), [](chunk_handle_t *p) {
+                    ipc::mem::destruct(p);
+                }}).first;
         }
     }
-    return it->second.get_info(chunk_size);
+    return it->second->get_info(inf, chunk_size);
 }
 
-std::pair<ipc::storage_id_t, void*> acquire_storage(std::size_t size, ipc::circ::cc_t conns) {
+std::pair<ipc::storage_id_t, void*> acquire_storage(conn_info_head *inf, 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);
+    auto info = chunk_storage_info(inf, chunk_size);
     if (info == nullptr) return {};
 
     info->lock_.lock();
@@ -185,24 +268,24 @@ std::pair<ipc::storage_id_t, void*> acquire_storage(std::size_t size, ipc::circ:
     return { id, chunk->data() };
 }
 
-void *find_storage(ipc::storage_id_t id, std::size_t size) {
+void *find_storage(ipc::storage_id_t id, conn_info_head *inf, 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);
+    auto info = chunk_storage_info(inf, 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) {
+void release_storage(ipc::storage_id_t id, conn_info_head *inf, 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);
+    auto info = chunk_storage_info(inf, chunk_size);
     if (info == nullptr) return;
     info->lock_.lock();
     info->pool_.release(id);
@@ -229,13 +312,13 @@ bool sub_rc(ipc::wr<Rp, Rc, ipc::trans::broadcast>,
 }
 
 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) {
+void recycle_storage(ipc::storage_id_t id, conn_info_head *inf, 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);
+    auto info = chunk_storage_info(inf, chunk_size);
     if (info == nullptr) return;
 
     auto chunk = info->at(chunk_size, id);
@@ -250,7 +333,7 @@ void recycle_storage(ipc::storage_id_t id, std::size_t size, ipc::circ::cc_t cur
 }
 
 template <typename MsgT>
-bool clear_message(void* p) {
+bool clear_message(conn_info_head *inf, 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_;
@@ -258,45 +341,12 @@ bool clear_message(void* p) {
             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));
+        release_storage(*reinterpret_cast<ipc::storage_id_t*>(&msg->data_),
+                        inf, 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();
@@ -322,11 +372,18 @@ struct queue_generator {
     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()} {
+        conn_info_t(char const * pref, char const * name)
+            : conn_info_head{pref, name} { init(); }
+
+        void init() {
+            conn_info_head::init();
+            if (!que_.valid()) {
+                que_.open(ipc::make_prefix(prefix_, {
+                          "QU_CONN__",
+                          ipc::to_string(DataSize), "__",
+                          ipc::to_string(AlignSize), "__", 
+                          this->name_}).c_str());
+            }
         }
 
         void disconnect_receiver() {
@@ -357,6 +414,18 @@ constexpr static queue_t* queue_of(ipc::handle_t h) noexcept {
 
 /* API implementations */
 
+static bool connect(ipc::handle_t * ph, ipc::prefix pref, char const * name, bool start_to_recv) {
+    assert(ph != nullptr);
+    if (*ph == nullptr) {
+        *ph = ipc::mem::alloc<conn_info_t>(pref.str, name);
+    }
+    return reconnect(ph, start_to_recv);
+}
+
+static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
+    return connect(ph, {nullptr}, name, start_to_recv);
+}
+
 static void disconnect(ipc::handle_t h) {
     auto que = queue_of(h);
     if (que == nullptr) {
@@ -374,6 +443,7 @@ static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
     if (que == nullptr) {
         return false;
     }
+    info_of(*ph)->init();
     if (start_to_recv) {
         que->shut_sending();
         if (que->connect()) { // wouldn't connect twice
@@ -389,14 +459,6 @@ static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
     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));
@@ -445,15 +507,16 @@ static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t s
         return false;
     }
     // calc a new message id
-    auto acc = info_of(h)->acc();
+    conn_info_t *inf = info_of(h);
+    auto acc = inf->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);
+    auto try_push = std::forward<F>(gen_push)(inf, que, msg_id);
     if (size > ipc::large_msg_limit) {
-        auto   dat = acquire_storage(size, conns);
+        auto   dat = acquire_storage(inf, size, conns);
         void * buf = dat.second;
         if (buf != nullptr) {
             std::memcpy(buf, data, size);
@@ -484,7 +547,7 @@ static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t s
 }
 
 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 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(
@@ -493,7 +556,7 @@ static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint
                 }, tm)) {
                 ipc::log("force_push: msg_id = %zd, remain = %d, size = %zd\n", msg_id, remain, size);
                 if (!que->force_push(
-                        clear_message<typename queue_t::value_t>,
+                        [info](void* p) { return clear_message<typename queue_t::value_t>(info, p); },
                         info->cc_id_, msg_id, remain, data, size)) {
                     return false;
                 }
@@ -505,7 +568,7 @@ static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint
 }
 
 static bool try_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 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(
@@ -530,18 +593,19 @@ static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
         // hasn't connected yet, just return.
         return {};
     }
-    auto& rc = info_of(h)->recv_cache();
+    conn_info_t *inf = info_of(h);
+    auto& rc = inf->recv_cache();
     for (;;) {
         // pop a new message
         typename queue_t::value_t msg {};
-        if (!wait_for(info_of(h)->rd_waiter_, [que, &msg] {
+        if (!wait_for(inf->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_)) {
+        inf->wt_waiter_.broadcast();
+        if ((inf->acc() != nullptr) && (msg.cc_id_ == inf->cc_id_)) {
             continue; // ignore message to self
         }
         // msg.remain_ may minus & abs(msg.remain_) < data_length
@@ -554,14 +618,18 @@ static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
         // 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);
+            void* buf = find_storage(buf_id, inf, msg_size);
             if (buf != nullptr) {
                 struct recycle_t {
                     ipc::storage_id_t storage_id;
+                    conn_info_t *     inf;
                     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()
+                    buf_id, 
+                    inf, 
+                    que->elems()->connections(std::memory_order_relaxed), 
+                    que->connected_id()
                 });
                 if (r_info == nullptr) {
                     ipc::log("fail: ipc::mem::alloc<recycle_t>.\n");
@@ -572,7 +640,11 @@ static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
                         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);
+                        recycle_storage<flag_t>(r_info->storage_id, 
+                                                r_info->inf, 
+                                                size, 
+                                                r_info->curr_conns, 
+                                                r_info->conn_id);
                     }, r_info};
                 }
             } else {
@@ -641,6 +713,11 @@ bool chan_impl<Flag>::connect(ipc::handle_t * ph, char const * name, unsigned mo
     return detail_impl<policy_t<Flag>>::connect(ph, name, mode & receiver);
 }
 
+template <typename Flag>
+bool chan_impl<Flag>::connect(ipc::handle_t * ph, prefix pref, char const * name, unsigned mode) {
+    return detail_impl<policy_t<Flag>>::connect(ph, pref, 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);
@@ -658,7 +735,7 @@ void chan_impl<Flag>::destroy(ipc::handle_t h) {
 
 template <typename Flag>
 char const * chan_impl<Flag>::name(ipc::handle_t h) {
-    auto info = detail_impl<policy_t<Flag>>::info_of(h);
+    auto *info = detail_impl<policy_t<Flag>>::info_of(h);
     return (info == nullptr) ? nullptr : info->name_.c_str();
 }
 
diff --git a/src/libipc/memory/resource.h b/src/libipc/memory/resource.h
index 38b6fb68..cb50c92c 100755
--- a/src/libipc/memory/resource.h
+++ b/src/libipc/memory/resource.h
@@ -87,4 +87,24 @@ ipc::string to_string(T val) {
     return {};
 }
 
+/// \brief Check string validity.
+constexpr bool is_valid_string(char const *str) noexcept {
+    return (str != nullptr) && (str[0] != '\0');
+}
+
+/// \brief Make a valid string.
+inline ipc::string make_string(char const *str) {
+    return is_valid_string(str) ? ipc::string{str} : ipc::string{};
+}
+
+/// \brief Combine prefix from a list of strings.
+inline ipc::string make_prefix(ipc::string prefix, std::initializer_list<ipc::string> args) {
+    prefix += "__IPC_SHM__";
+    for (auto const &txt: args) {
+        if (txt.empty()) continue;
+        prefix += txt;
+    }
+    return prefix;
+}
+
 } // namespace ipc
diff --git a/src/libipc/platform/detail.h b/src/libipc/platform/detail.h
index e93c1d29..4d6a27cf 100755
--- a/src/libipc/platform/detail.h
+++ b/src/libipc/platform/detail.h
@@ -133,4 +133,4 @@ constexpr const T& (min)(const T& a, const T& b) {
 } // namespace ipc
 
 #endif // defined(__cplusplus)
-#endif // LIBIPC_SRC_PLATFORM_DETAIL_H_
\ No newline at end of file
+#endif // LIBIPC_SRC_PLATFORM_DETAIL_H_
diff --git a/src/libipc/platform/posix/shm_posix.cpp b/src/libipc/platform/posix/shm_posix.cpp
index 7f70b070..e29bd6f2 100644
--- a/src/libipc/platform/posix/shm_posix.cpp
+++ b/src/libipc/platform/posix/shm_posix.cpp
@@ -45,11 +45,13 @@ namespace ipc {
 namespace shm {
 
 id_t acquire(char const * name, std::size_t size, unsigned mode) {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail acquire: name is empty\n");
         return nullptr;
     }
-    ipc::string op_name = ipc::string{"__IPC_SHM__"} + name;
+    // For portable use, a shared memory object should be identified by name of the form /somename.
+    // see: https://man7.org/linux/man-pages/man3/shm_open.3.html
+    ipc::string op_name = ipc::string{"/"} + name;
     // Open the object for read-write access.
     int flag = O_RDWR;
     switch (mode) {
@@ -70,7 +72,7 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
                                                S_IRGRP | S_IWGRP |
                                                S_IROTH | S_IWOTH);
     if (fd == -1) {
-        ipc::error("fail shm_open[%d]: %s\n", errno, name);
+        ipc::error("fail shm_open[%d]: %s\n", errno, op_name.c_str());
         return nullptr;
     }
     auto ii = mem::alloc<id_info_t>();
@@ -159,7 +161,8 @@ std::int32_t release(id_t id) {
     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_);
+        ipc::error("fail release: invalid id (mem = %p, size = %zd), name = %s\n", 
+                    ii->mem_, ii->size_, ii->name_.c_str());
     }
     else if ((ret = acc_of(ii->mem_, ii->size_).fetch_sub(1, std::memory_order_acq_rel)) <= 1) {
         ::munmap(ii->mem_, ii->size_);
@@ -186,11 +189,11 @@ void remove(id_t id) {
 }
 
 void remove(char const * name) {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail remove: name is empty\n");
         return;
     }
-    ::shm_unlink((ipc::string{"__IPC_SHM__"} + name).c_str());
+    ::shm_unlink(name);
 }
 
 } // namespace shm
diff --git a/src/libipc/platform/win/condition.h b/src/libipc/platform/win/condition.h
index e477bff0..538aa082 100644
--- a/src/libipc/platform/win/condition.h
+++ b/src/libipc/platform/win/condition.h
@@ -44,15 +44,15 @@ class condition {
 
     bool open(char const *name) noexcept {
         close();
-        if (!sem_.open((std::string{"_cond_sem_"} + name).c_str())) {
+        if (!sem_.open((std::string{name} + "_COND_SEM_").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())) {
+        if (!lock_.open((std::string{name} + "_COND_LOCK_").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))) {
+        if (!shm_.acquire((std::string{name} + "_COND_SHM_").c_str(), sizeof(std::int32_t))) {
             return false;
         }
         finally_lock.dismiss();
@@ -76,7 +76,7 @@ class condition {
         }
         DWORD ms = (tm == invalid_value) ? INFINITE : static_cast<DWORD>(tm);
         /**
-         * @see
+         * \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
         */
diff --git a/src/libipc/platform/win/mutex.h b/src/libipc/platform/win/mutex.h
index 8ecaf476..c0cb543d 100644
--- a/src/libipc/platform/win/mutex.h
+++ b/src/libipc/platform/win/mutex.h
@@ -33,7 +33,7 @@ class mutex {
 
     bool open(char const *name) noexcept {
         close();
-        h_ = ::CreateMutex(detail::get_sa(), FALSE, ipc::detail::to_tchar(name).c_str());
+        h_ = ::CreateMutex(detail::get_sa(), FALSE, detail::to_tchar(name).c_str());
         if (h_ == NULL) {
             ipc::error("fail CreateMutex[%lu]: %s\n", ::GetLastError(), name);
             return false;
diff --git a/src/libipc/platform/win/semaphore.h b/src/libipc/platform/win/semaphore.h
index 47fd45d1..5c44846b 100644
--- a/src/libipc/platform/win/semaphore.h
+++ b/src/libipc/platform/win/semaphore.h
@@ -32,7 +32,7 @@ class semaphore {
         close();
         h_ = ::CreateSemaphore(detail::get_sa(), 
                                static_cast<LONG>(count), LONG_MAX, 
-                               ipc::detail::to_tchar(name).c_str());
+                               detail::to_tchar(name).c_str());
         if (h_ == NULL) {
             ipc::error("fail CreateSemaphore[%lu]: %s\n", ::GetLastError(), name);
             return false;
diff --git a/src/libipc/platform/win/shm_win.cpp b/src/libipc/platform/win/shm_win.cpp
index 366e8bd1..4b7016ef 100755
--- a/src/libipc/platform/win/shm_win.cpp
+++ b/src/libipc/platform/win/shm_win.cpp
@@ -28,30 +28,35 @@ namespace ipc {
 namespace shm {
 
 id_t acquire(char const * name, std::size_t size, unsigned mode) {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail acquire: name is empty\n");
         return nullptr;
     }
     HANDLE h;
-    auto fmt_name = ipc::detail::to_tchar(ipc::string{"__IPC_SHM__"} + name);
+    auto fmt_name = ipc::detail::to_tchar(name);
     // Opens a named file mapping object.
     if (mode == open) {
         h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());
+        if (h == NULL) {
+          ipc::error("fail OpenFileMapping[%d]: %s\n", static_cast<int>(::GetLastError()), name);
+          return nullptr;
+        }
     }
     // 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());
+        DWORD err = ::GetLastError();
         // 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);
+        if ((mode == create) && (err == ERROR_ALREADY_EXISTS)) {
+            if (h != NULL) ::CloseHandle(h);
             h = NULL;
         }
-    }
-    if (h == NULL) {
-        ipc::error("fail CreateFileMapping/OpenFileMapping[%d]: %s\n", static_cast<int>(::GetLastError()), name);
-        return nullptr;
+        if (h == NULL) {
+          ipc::error("fail CreateFileMapping[%d]: %s\n", static_cast<int>(err), name);
+          return nullptr;
+        }
     }
     auto ii = mem::alloc<id_info_t>();
     ii->h_    = h;
@@ -124,7 +129,7 @@ void remove(id_t id) {
 }
 
 void remove(char const * name) {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail remove: name is empty\n");
         return;
     }
diff --git a/src/libipc/platform/win/to_tchar.h b/src/libipc/platform/win/to_tchar.h
index 892177e2..94bc83e8 100755
--- a/src/libipc/platform/win/to_tchar.h
+++ b/src/libipc/platform/win/to_tchar.h
@@ -41,8 +41,8 @@ constexpr auto to_tchar(ipc::string &&str) -> IsSameChar<T, ipc::string, ipc::st
 }
 
 /**
- * @remarks codecvt_utf8_utf16/std::wstring_convert is deprecated
- * @see https://codingtidbit.com/2020/02/09/c17-codecvt_utf8-is-deprecated/
+ * \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
diff --git a/src/libipc/queue.h b/src/libipc/queue.h
index f66860b8..e38fe778 100755
--- a/src/libipc/queue.h
+++ b/src/libipc/queue.h
@@ -18,6 +18,7 @@
 #include "libipc/utility/log.h"
 #include "libipc/platform/detail.h"
 #include "libipc/circ/elem_def.h"
+#include "libipc/memory/resource.h"
 
 namespace ipc {
 namespace detail {
@@ -29,7 +30,7 @@ class queue_conn {
 
     template <typename Elems>
     Elems* open(char const * name) {
-        if (name == nullptr || name[0] == '\0') {
+        if (!is_valid_string(name)) {
             ipc::error("fail open waiter: name is empty!\n");
             return nullptr;
         }
@@ -103,7 +104,7 @@ class queue_base : public queue_conn {
 
     explicit queue_base(char const * name)
         : queue_base{} {
-        elems_ = open<elems_t>(name);
+        elems_ = queue_conn::template open<elems_t>(name);
     }
 
     explicit queue_base(elems_t * elems) noexcept
@@ -116,6 +117,12 @@ class queue_base : public queue_conn {
         base_t::close();
     }
 
+    bool open(char const * name) noexcept {
+        base_t::close();
+        elems_ = queue_conn::template open<elems_t>(name);
+        return elems_ != nullptr;
+    }
+
     elems_t       * elems()       noexcept { return elems_; }
     elems_t const * elems() const noexcept { return elems_; }
 
diff --git a/src/libipc/shm.cpp b/src/libipc/shm.cpp
index 92f96ef4..08454741 100755
--- a/src/libipc/shm.cpp
+++ b/src/libipc/shm.cpp
@@ -5,6 +5,7 @@
 #include "libipc/shm.h"
 
 #include "libipc/utility/pimpl.h"
+#include "libipc/utility/log.h"
 #include "libipc/memory/resource.h"
 
 namespace ipc {
@@ -68,8 +69,17 @@ void handle::sub_ref() noexcept {
 }
 
 bool handle::acquire(char const * name, std::size_t size, unsigned mode) {
+    if (!is_valid_string(name)) {
+        ipc::error("fail acquire: name is empty\n");
+        return false;
+    }
+    if (size == 0) {
+        ipc::error("fail acquire: size is 0\n");
+        return false;
+    }
     release();
-    impl(p_)->id_ = shm::acquire((impl(p_)->n_ = name).c_str(), size, mode);
+    impl(p_)->n_  = name;
+    impl(p_)->id_ = shm::acquire(name, size, mode);
     impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
     return valid();
 }
diff --git a/src/libipc/sync/condition.cpp b/src/libipc/sync/condition.cpp
index 06d90e19..36896a7e 100644
--- a/src/libipc/sync/condition.cpp
+++ b/src/libipc/sync/condition.cpp
@@ -2,6 +2,7 @@
 #include "libipc/condition.h"
 
 #include "libipc/utility/pimpl.h"
+#include "libipc/utility/log.h"
 #include "libipc/memory/resource.h"
 #include "libipc/platform/detail.h"
 #if defined(IPC_OS_WINDOWS_)
@@ -49,6 +50,10 @@ bool condition::valid() const noexcept {
 }
 
 bool condition::open(char const *name) noexcept {
+    if (!is_valid_string(name)) {
+        ipc::error("fail condition open: name is empty\n");
+        return false;
+    }
     return impl(p_)->cond_.open(name);
 }
 
diff --git a/src/libipc/sync/mutex.cpp b/src/libipc/sync/mutex.cpp
index 79f1a910..91bd0bbc 100644
--- a/src/libipc/sync/mutex.cpp
+++ b/src/libipc/sync/mutex.cpp
@@ -2,6 +2,7 @@
 #include "libipc/mutex.h"
 
 #include "libipc/utility/pimpl.h"
+#include "libipc/utility/log.h"
 #include "libipc/memory/resource.h"
 #include "libipc/platform/detail.h"
 #if defined(IPC_OS_WINDOWS_)
@@ -49,6 +50,10 @@ bool mutex::valid() const noexcept {
 }
 
 bool mutex::open(char const *name) noexcept {
+    if (!is_valid_string(name)) {
+        ipc::error("fail mutex open: name is empty\n");
+        return false;
+    }
     return impl(p_)->lock_.open(name);
 }
 
diff --git a/src/libipc/sync/semaphore.cpp b/src/libipc/sync/semaphore.cpp
index 23f6bdce..e58e8ec4 100644
--- a/src/libipc/sync/semaphore.cpp
+++ b/src/libipc/sync/semaphore.cpp
@@ -2,6 +2,7 @@
 #include "libipc/semaphore.h"
 
 #include "libipc/utility/pimpl.h"
+#include "libipc/utility/log.h"
 #include "libipc/memory/resource.h"
 #include "libipc/platform/detail.h"
 #if defined(IPC_OS_WINDOWS_)
@@ -47,6 +48,10 @@ bool semaphore::valid() const noexcept {
 }
 
 bool semaphore::open(char const *name, std::uint32_t count) noexcept {
+    if (!is_valid_string(name)) {
+        ipc::error("fail semaphore open: name is empty\n");
+        return false;
+    }
     return impl(p_)->sem_.open(name, count);
 }
 
diff --git a/src/libipc/waiter.h b/src/libipc/waiter.h
index ee45fe35..628ce5ea 100644
--- a/src/libipc/waiter.h
+++ b/src/libipc/waiter.h
@@ -36,10 +36,10 @@ class waiter {
 
     bool open(char const *name) noexcept {
         quit_.store(false, std::memory_order_relaxed);
-        if (!cond_.open((std::string{"_waiter_cond_"} + name).c_str())) {
+        if (!cond_.open((std::string{name} + "_WAITER_COND_").c_str())) {
             return false;
         }
-        if (!lock_.open((std::string{"_waiter_lock_"} + name).c_str())) {
+        if (!lock_.open((std::string{name} + "_WAITER_LOCK_").c_str())) {
             cond_.close();
             return false;
         }
@@ -64,12 +64,16 @@ class waiter {
     }
 
     bool notify() noexcept {
-        std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
+        {
+            IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> barrier{lock_}; // barrier
+        }
         return cond_.notify(lock_);
     }
 
     bool broadcast() noexcept {
-        std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
+        {
+            IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> barrier{lock_}; // barrier
+        }
         return cond_.broadcast(lock_);
     }
 
diff --git a/test/test_ipc.cpp b/test/test_ipc.cpp
index a1f01083..fb46670a 100755
--- a/test/test_ipc.cpp
+++ b/test/test_ipc.cpp
@@ -151,11 +151,15 @@ void test_sr(char const * name, int s_cnt, int r_cnt) {
 
 } // internal-linkage
 
-TEST(IPC, basic) {
+TEST(IPC, basic_ssu) {
     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(IPC, basic_smb) {
     test_basic<relat::single, relat::multi , trans::broadcast>("smb");
+}
+
+TEST(IPC, basic_mmb) {
     test_basic<relat::multi , relat::multi , trans::broadcast>("mmb");
 }
 
diff --git a/test/test_sync.cpp b/test/test_sync.cpp
index 4cb82e68..e905df98 100644
--- a/test/test_sync.cpp
+++ b/test/test_sync.cpp
@@ -131,7 +131,7 @@ TEST(Sync, Condition) {
             {
                 std::lock_guard<ipc::sync::mutex> guard {lock};
                 while (que.empty()) {
-                    EXPECT_TRUE(cond.wait(lock, 1000));
+                    ASSERT_TRUE(cond.wait(lock, 1000));
                 }
                 val = que.front();
                 que.pop_front();