- Add OS-native functions to obatin sistemwide thread IDs

- Rework OS_systemwide_thread_id_t to be portable between different native implementation and old emulation code

Author: igaztanaga

include/boost/interprocess/detail/os_thread_functions.hpp

@@ -45,16 +45,32 @@
 #  include <sched.h>
 #  include <time.h>
 #  include <errno.h>
+#  include <sys/types.h>
 #  ifdef BOOST_INTERPROCESS_BSD_DERIVATIVE
       //Some *BSD systems (OpenBSD & NetBSD) need sys/param.h before sys/sysctl.h, whereas
       //others (FreeBSD & Darwin) need sys/types.h
-#     include <sys/types.h>
 #     include <sys/param.h>
 #     include <sys/sysctl.h>
 #  endif
 #if defined(__VXWORKS__) 
 #include <vxCpuLib.h>
 #endif 
+
+#if defined(__linux__)
+   #include <sys/syscall.h>
+#elif defined(__FreeBSD__)
+   #include <pthread_np.h>
+#elif defined(__APPLE__)
+   #include <pthread.h>
+#elif defined(__NetBSD__)
+    #include <lwp.h>
+#elif defined(__OpenBSD__)
+    #include <unistd.h>
+#elif defined(__sun) && defined(__SVR4)
+    #include <thread.h>
+#endif
+
+
 //According to the article "C/C++ tip: How to measure elapsed real time for benchmarking"
 //Check MacOs first as macOS 10.12 SDK defines both CLOCK_MONOTONIC and
 //CLOCK_MONOTONIC_RAW and no clock_gettime.
@@ -95,8 +111,6 @@ struct OS_thread_t
    void* m_handle;
 };
 
-typedef OS_thread_id_t OS_systemwide_thread_id_t;
-
 //process
 inline OS_process_id_t get_current_process_id()
 {  return winapi::get_current_process_id();  }
@@ -198,26 +212,32 @@ inline void thread_yield()
 inline void thread_sleep_ms(unsigned int ms)
 {  winapi::sleep(ms);  }
 
-//systemwide thread
-inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
-{
-   return get_current_thread_id();
-}
 
-inline void systemwide_thread_id_copy
-   (const volatile OS_systemwide_thread_id_t &from, volatile OS_systemwide_thread_id_t &to)
+class OS_systemwide_thread_id_t
 {
-   to = from;
-}
+   OS_thread_id_t m_thrhnd;
+
+   public:
+   explicit OS_systemwide_thread_id_t(OS_thread_id_t thid)
+      : m_thrhnd(thid)
+   {}
+
+   OS_systemwide_thread_id_t()
+      : m_thrhnd(get_invalid_thread_id())
+   {}
 
-inline bool equal_systemwide_thread_id(const OS_systemwide_thread_id_t &id1, const OS_systemwide_thread_id_t &id2)
+   friend bool operator == (const OS_systemwide_thread_id_t &id1, const OS_systemwide_thread_id_t &id2)
+   {  return id1.m_thrhnd == id2.m_thrhnd;  }
+};
+
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
 {
-   return equal_thread_id(id1, id2);
+   return OS_systemwide_thread_id_t(get_current_thread_id());
 }
 
 inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
 {
-   return get_invalid_thread_id();
+   return OS_systemwide_thread_id_t(get_invalid_thread_id());
 }
 
 inline unsigned long long get_current_process_creation_time()
@@ -248,8 +268,95 @@ typedef pthread_t OS_thread_t;
 typedef pthread_t OS_thread_id_t;
 typedef pid_t     OS_process_id_t;
 
-struct OS_systemwide_thread_id_t
+//process
+inline OS_process_id_t get_current_process_id()
+{  return ::getpid();  }
+
+inline OS_process_id_t get_invalid_process_id()
+{  return pid_t(0);  }
+
+//thread
+inline OS_thread_id_t get_current_thread_id()
+{  return ::pthread_self();  }
+
+inline OS_thread_id_t get_invalid_thread_id()
+{
+   static pthread_t invalid_id;
+   return invalid_id;
+}
+
+inline bool equal_thread_id(OS_thread_id_t id1, OS_thread_id_t id2)
+{  return 0 != pthread_equal(id1, id2);  }
+
+
+#if defined(__linux__)
+
+typedef pid_t OS_systemwide_thread_id_t;
+
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
+{  return (pid_t)syscall(SYS_gettid);  }
+
+inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
+{  return (pid_t)(-1); }
+
+#elif defined(__FreeBSD__)
+
+typedef int OS_systemwide_thread_id_t;
+
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
+{  return pthread_getthreadid_np();  }
+
+inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
+{  return -1;   }
+
+#elif defined(__APPLE__)
+
+typedef uint64_t OS_systemwide_thread_id_t;
+
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
+{  uint64_t tid; pthread_threadid_np(NULL, &tid); return tid;   }
+
+inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
+{  return (uint64_t)(-1);  }
+
+#elif defined(__NetBSD__)
+
+typedef lwpid_t OS_systemwide_thread_id_t;
+
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
+{  return _lwp_self();   }
+
+inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
+{  return (lwpid_t)(-1);  }
+
+#elif defined(__OpenBSD__)
+
+typedef pid_t OS_systemwide_thread_id_t;
+
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
+{  return getthrid();   }
+
+inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
+{  return (pid_t)(-1);  }
+
+#elif defined(__sun) && defined(__SVR4)
+
+typedef thread_t OS_systemwide_thread_id_t;
+
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
+{  return thr_self();   }
+
+inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
+{  return (thread_t)(-1);  }
+
+#else //fallback to fragile pthread-based solution
+
+class OS_systemwide_thread_id_t
 {
+   pid_t       pid;
+   pthread_t   tid;
+
+   public:
    OS_systemwide_thread_id_t()
       :  pid(), tid()
    {}
@@ -262,49 +369,25 @@ struct OS_systemwide_thread_id_t
       :  pid(x.pid), tid(x.tid)
    {}
 
-   OS_systemwide_thread_id_t(const volatile OS_systemwide_thread_id_t &x)
-      :  pid(x.pid), tid(x.tid)
-   {}
-
    OS_systemwide_thread_id_t & operator=(const OS_systemwide_thread_id_t &x)
    {  pid = x.pid;   tid = x.tid;   return *this;   }
 
-   OS_systemwide_thread_id_t & operator=(const volatile OS_systemwide_thread_id_t &x)
-   {  pid = x.pid;   tid = x.tid;   return *this;  }
-
-   void operator=(const OS_systemwide_thread_id_t &x) volatile
-   {  pid = x.pid;   tid = x.tid;   }
-
-   pid_t       pid;
-   pthread_t   tid;
+   friend bool operator == (const OS_systemwide_thread_id_t &id1, const OS_systemwide_thread_id_t &id2)
+   {  return id1.pid == id2.pid && (0 != pthread_equal(id1.tid, id2.tid));  }
 };
 
-inline void systemwide_thread_id_copy
-   (const volatile OS_systemwide_thread_id_t &from, volatile OS_systemwide_thread_id_t &to)
+//systemwide thread
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
 {
-   to.pid = from.pid;
-   to.tid = from.tid;
+   return OS_systemwide_thread_id_t(::getpid(), ::pthread_self());
 }
 
-//process
-inline OS_process_id_t get_current_process_id()
-{  return ::getpid();  }
-
-inline OS_process_id_t get_invalid_process_id()
-{  return pid_t(0);  }
-
-//thread
-inline OS_thread_id_t get_current_thread_id()
-{  return ::pthread_self();  }
-
-inline OS_thread_id_t get_invalid_thread_id()
+inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
 {
-   static pthread_t invalid_id;
-   return invalid_id;
+   return OS_systemwide_thread_id_t(get_invalid_process_id(), get_invalid_thread_id());
 }
 
-inline bool equal_thread_id(OS_thread_id_t id1, OS_thread_id_t id2)
-{  return 0 != pthread_equal(id1, id2);  }
+#endif
 
 inline void thread_yield()
 {  ::sched_yield();  }
@@ -461,22 +544,6 @@ inline void thread_sleep_ms(unsigned int ms)
    }
 }
 
-//systemwide thread
-inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
-{
-   return OS_systemwide_thread_id_t(::getpid(), ::pthread_self());
-}
-
-inline bool equal_systemwide_thread_id(const OS_systemwide_thread_id_t &id1, const OS_systemwide_thread_id_t &id2)
-{
-   return (0 != pthread_equal(id1.tid, id2.tid)) && (id1.pid == id2.pid);
-}
-
-inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
-{
-   return OS_systemwide_thread_id_t(get_invalid_process_id(), get_invalid_thread_id());
-}
-
 inline unsigned long long get_current_process_creation_time()
 { return 0u; }
 

include/boost/interprocess/sync/spin/recursive_mutex.hpp

@@ -76,7 +76,7 @@ class spin_recursive_mutex
    private:
    spin_mutex     m_mutex;
    unsigned int   m_nLockCount;
-   volatile ipcdetail::OS_systemwide_thread_id_t   m_nOwner;
+   volatile OS_systemwide_thread_id_t   m_nOwner;
    volatile boost::uint32_t m_s;
 };
 
@@ -87,11 +87,10 @@ inline spin_recursive_mutex::~spin_recursive_mutex(){}
 
 inline void spin_recursive_mutex::lock()
 {
-   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
-   const handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
-   handle_t old_id;
-   ipcdetail::systemwide_thread_id_copy(m_nOwner, old_id);
-   if(ipcdetail::equal_systemwide_thread_id(thr_id , old_id)){
+   const OS_systemwide_thread_id_t thr_id(ipcdetail::get_current_systemwide_thread_id());
+   OS_systemwide_thread_id_t old_id = const_cast<OS_systemwide_thread_id_t &>(m_nOwner);
+
+   if(thr_id == old_id){
       if((unsigned int)(m_nLockCount+1) == 0){
          //Overflow, throw an exception
          throw interprocess_exception("boost::interprocess::spin_recursive_mutex recursive lock overflow");
@@ -100,18 +99,17 @@ inline void spin_recursive_mutex::lock()
    }
    else{
       m_mutex.lock();
-      ipcdetail::systemwide_thread_id_copy(thr_id, m_nOwner);
+      const_cast<OS_systemwide_thread_id_t &>(m_nOwner) = thr_id;
       m_nLockCount = 1;
    }
 }
 
 inline bool spin_recursive_mutex::try_lock()
 {
-   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
-   handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
-   handle_t old_id;
-   ipcdetail::systemwide_thread_id_copy(m_nOwner, old_id);
-   if(ipcdetail::equal_systemwide_thread_id(thr_id , old_id)) {  // we own it
+   OS_systemwide_thread_id_t thr_id(ipcdetail::get_current_systemwide_thread_id());
+   OS_systemwide_thread_id_t old_id = const_cast<OS_systemwide_thread_id_t &>(m_nOwner);
+
+   if(thr_id == old_id) {  // we own it
       if((unsigned int)(m_nLockCount+1) == 0){
          //Overflow, throw an exception
          throw interprocess_exception("boost::interprocess::spin_recursive_mutex recursive lock overflow");
@@ -120,7 +118,7 @@ inline bool spin_recursive_mutex::try_lock()
       return true;
    }
    if(m_mutex.try_lock()){
-      ipcdetail::systemwide_thread_id_copy(thr_id, m_nOwner);
+      const_cast<OS_systemwide_thread_id_t &>(m_nOwner) = thr_id;
       m_nLockCount = 1;
       return true;
    }
@@ -130,11 +128,10 @@ inline bool spin_recursive_mutex::try_lock()
 template<class TimePoint>
 inline bool spin_recursive_mutex::timed_lock(const TimePoint &abs_time)
 {
-   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
-   const handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
-   handle_t old_id;
-   ipcdetail::systemwide_thread_id_copy(m_nOwner, old_id);
-   if(ipcdetail::equal_systemwide_thread_id(thr_id , old_id)) {  // we own it
+   OS_systemwide_thread_id_t thr_id(ipcdetail::get_current_systemwide_thread_id());
+   OS_systemwide_thread_id_t old_id = const_cast<OS_systemwide_thread_id_t &>(m_nOwner);
+
+   if(thr_id == old_id) {  // we own it
       if((unsigned int)(m_nLockCount+1) == 0){
          //Overflow, throw an exception
          throw interprocess_exception("boost::interprocess::spin_recursive_mutex recursive lock overflow");
@@ -144,7 +141,7 @@ inline bool spin_recursive_mutex::timed_lock(const TimePoint &abs_time)
    }
    //m_mutex supports abs_time so no need to check it
    if(m_mutex.timed_lock(abs_time)){
-      ipcdetail::systemwide_thread_id_copy(thr_id, m_nOwner);
+      const_cast<OS_systemwide_thread_id_t &>(m_nOwner) = thr_id;
       m_nLockCount = 1;
       return true;
    }
@@ -153,27 +150,21 @@ inline bool spin_recursive_mutex::timed_lock(const TimePoint &abs_time)
 
 inline void spin_recursive_mutex::unlock()
 {
-   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
-   handle_t old_id;
-   ipcdetail::systemwide_thread_id_copy(m_nOwner, old_id);
-   const handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
-   (void)old_id;
-   (void)thr_id;
-   BOOST_ASSERT(ipcdetail::equal_systemwide_thread_id(thr_id, old_id));
+   BOOST_ASSERT(ipcdetail::get_current_systemwide_thread_id() == const_cast<const OS_systemwide_thread_id_t &>(m_nOwner));
+
    --m_nLockCount;
    if(!m_nLockCount){
-      const handle_t new_id(ipcdetail::get_invalid_systemwide_thread_id());
-      ipcdetail::systemwide_thread_id_copy(new_id, m_nOwner);
+      const OS_systemwide_thread_id_t new_id(ipcdetail::get_invalid_systemwide_thread_id());
+      const_cast<OS_systemwide_thread_id_t &>(m_nOwner) = new_id;
       m_mutex.unlock();
    }
 }
 
 inline void spin_recursive_mutex::take_ownership()
 {
-   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
    this->m_nLockCount = 1;
-   const handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
-   ipcdetail::systemwide_thread_id_copy(thr_id, m_nOwner);
+   const OS_systemwide_thread_id_t thr_id(ipcdetail::get_current_systemwide_thread_id());
+   const_cast<OS_systemwide_thread_id_t &>(m_nOwner) = thr_id;
 }
 
 }  //namespace ipcdetail {