add sync::mutex for windows/linux

Author: mutouyun

.gitignore

@@ -44,3 +44,4 @@ CMakeLists.txt.user*
 
 # My output files
 build
+.vscode

include/libipc/def.h

@@ -25,13 +25,16 @@ using uint_t = typename uint<N>::type;
 
 // constants
 
+enum : std::uint32_t {
+    invalid_value   = (std::numeric_limits<std::uint32_t>::max)(),
+    default_timeout = 100, // ms
+};
+
 enum : std::size_t {
-    invalid_value   = (std::numeric_limits<std::size_t>::max)(),
     data_length     = 64,
     large_msg_limit = data_length,
     large_msg_align = 512,
     large_msg_cache = 32,
-    default_timeout = 100 // ms
 };
 
 enum class relat { // multiplicity of the relationship

include/libipc/ipc.h

@@ -27,12 +27,12 @@ struct IPC_EXPORT chan_impl {
     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::size_t tm);
+    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::size_t tm);
-    static buff_t recv(ipc::handle_t h, std::size_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 bool   try_send(ipc::handle_t h, void const * data, std::size_t size, std::size_t tm);
+    static bool   try_send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm);
     static buff_t try_recv(ipc::handle_t h);
 };
 
@@ -120,41 +120,41 @@ class chan_wrapper {
         return detail_t::recv_count(h_);
     }
 
-    bool wait_for_recv(std::size_t r_count, std::size_t tm = invalid_value) const {
+    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::size_t tm = invalid_value) {
+    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);
     }
 
     /**
      * If timeout, this function would call 'force_push' to send the data forcibly.
     */
-    bool send(void const * data, std::size_t size, std::size_t tm = default_timeout) {
+    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::size_t tm = default_timeout) {
+    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::size_t tm = default_timeout) {
+    bool send(std::string const & str, std::uint64_t tm = default_timeout) {
         return this->send(str.c_str(), str.size() + 1, tm);
     }
 
     /**
      * If timeout, this function would just return false.
     */
-    bool try_send(void const * data, std::size_t size, std::size_t tm = default_timeout) {
+    bool try_send(void const * data, std::size_t size, std::uint64_t tm = default_timeout) {
         return detail_t::try_send(h_, data, size, tm);
     }
-    bool try_send(buff_t const & buff, std::size_t tm = default_timeout) {
+    bool try_send(buff_t const & buff, std::uint64_t tm = default_timeout) {
         return this->try_send(buff.data(), buff.size(), tm);
     }
-    bool try_send(std::string const & str, std::size_t tm = default_timeout) {
+    bool try_send(std::string const & str, std::uint64_t tm = default_timeout) {
         return this->try_send(str.c_str(), str.size() + 1, tm);
     }
 
-    buff_t recv(std::size_t tm = invalid_value) {
+    buff_t recv(std::uint64_t tm = invalid_value) {
         return detail_t::recv(h_, tm);
     }
 

include/libipc/mutex.h

@@ -0,0 +1,38 @@
+#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

include/libipc/shm.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstddef>
+#include <cstdint>
 
 #include "libipc/export.h"
 
@@ -20,6 +21,9 @@ IPC_EXPORT void   release(id_t id);
 IPC_EXPORT void   remove (id_t id);
 IPC_EXPORT void   remove (char const * name);
 
+IPC_EXPORT std::uint32_t get_ref(id_t id);
+IPC_EXPORT void sub_ref(id_t id);
+
 class IPC_EXPORT handle {
 public:
     handle();
@@ -31,9 +35,12 @@ class IPC_EXPORT handle {
     void swap(handle& rhs);
     handle& operator=(handle rhs);
 
-    bool         valid() const;
-    std::size_t  size () const;
-    char const * name () const;
+    bool         valid() const noexcept;
+    std::size_t  size () const noexcept;
+    char const * name () const noexcept;
+
+    std::uint32_t ref() const noexcept;
+    void sub_ref() noexcept;
 
     bool acquire(char const * name, std::size_t size, unsigned mode = create | open);
     void release();

include/libipc/waiter.h

@@ -54,7 +54,7 @@ class IPC_EXPORT semaphore {
     bool open (char const * name, long count = 0);
     void close();
 
-    bool wait(std::size_t tm = invalid_value);
+    bool wait(std::uint64_t tm = invalid_value);
     bool post(long count = 1);
 
 private:
@@ -81,7 +81,7 @@ class IPC_EXPORT condition {
     bool open (char const * name);
     void close();
 
-    bool wait(mutex&, std::size_t tm = invalid_value);
+    bool wait(mutex&, std::uint64_t tm = invalid_value);
     bool notify();
     bool broadcast();
 

src/ipc.cpp

@@ -291,7 +291,7 @@ struct conn_info_head {
 };
 
 template <typename W, typename F>
-bool wait_for(W& waiter, F&& pred, std::size_t tm) {
+bool wait_for(W& waiter, F&& pred, std::uint64_t tm) {
     if (tm == 0) return !pred();
     for (unsigned k = 0; pred();) {
         bool loop = true, ret = true;
@@ -403,7 +403,7 @@ static std::size_t recv_count(ipc::handle_t h) noexcept {
     return que->conn_count();
 }
 
-static bool wait_for_recv(ipc::handle_t h, std::size_t r_count, std::size_t tm) {
+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;
@@ -475,7 +475,7 @@ static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t s
     return true;
 }
 
-static bool send(ipc::handle_t h, void const * data, std::size_t size, std::size_t tm) {
+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_, [&] {
@@ -500,7 +500,7 @@ static bool send(ipc::handle_t h, void const * data, std::size_t size, std::size
     }, h, data, size);
 }
 
-static bool try_send(ipc::handle_t h, void const * data, std::size_t size, std::size_t tm) {
+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 [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
             if (!wait_for(info->wt_waiter_, [&] {
@@ -514,7 +514,7 @@ static bool try_send(ipc::handle_t h, void const * data, std::size_t size, std::
     }, h, data, size);
 }
 
-static ipc::buff_t recv(ipc::handle_t h, std::size_t tm) {
+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");
@@ -630,22 +630,22 @@ std::size_t chan_impl<Flag>::recv_count(ipc::handle_t h) {
 }
 
 template <typename Flag>
-bool chan_impl<Flag>::wait_for_recv(ipc::handle_t h, std::size_t r_count, std::size_t tm) {
+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::size_t tm) {
+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::size_t tm) {
+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>
-bool chan_impl<Flag>::try_send(ipc::handle_t h, void const * data, std::size_t size, std::size_t tm) {
+bool chan_impl<Flag>::try_send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
     return detail_impl<policy_t<Flag>>::try_send(h, data, size, tm);
 }
 

src/libipc/platform/detail.h

@@ -22,6 +22,18 @@
 #   error "IPC_CONSTEXPR_ has been defined."
 #endif
 
+// 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_
+#endif/*WIN*/
+
+#if defined(__linux__) || defined(__linux)
+#   define IPC_OS_LINUX_
+#endif/*linux*/
+
 #if __cplusplus >= 201703L
 
 #define IPC_UNUSED_      [[maybe_unused]]

src/libipc/platform/get_wait_time.h

@@ -0,0 +1,39 @@
+#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