Changeset 63052 in vbox for trunk/src/VBox/Runtime

Timestamp:

Aug 5, 2016 3:25:39 PM (8 years ago)

Author:

vboxsync

Message:

IPRT/RTSemMutex: rewrite rtSemFallbackPthreadMutexTimedlock. Take
relative timeout directly since we need it for nanosleep anyway.
Handle interrupted sleep. Sleep in 1 sec increments.

Note that nothing in the code base seems to call RTSemMutexRequest()
with cMillies other than RT_INDEFINITE_WAIT, so this code is not
actully used at the moment.

Ok bird.

File:

• trunk/src/VBox/Runtime/r3/posix/semmutex-posix.cpp (modified) (3 diffs)

trunk/src/VBox/Runtime/r3/posix/semmutex-posix.cpp

@@ -69 +69 @@
 #if defined(RT_OS_DARWIN) || defined(RT_OS_NETBSD)
 /**
- * This function emulate pthread_mutex_timedlock on Mac OS X
+ * This function is a crude approximation of pthread_mutex_timedlock.
  */
-static int rtSemFallbackPthreadMutexTimedlock(pthread_mutex_t * mutex, const struct timespec * pTsAbsTimeout)
-{
-    int rc = 0;
-    struct timeval tv;
-    timespec ts = {0, 0};
-    do
-    {
+int rtSemFallbackPthreadMutexTimedlock(pthread_mutex_t *mutex, RTMSINTERVAL cMillies)
+{
+    struct timespec ts;
+    int rc;
+
+    rc = pthread_mutex_trylock(mutex);
+    if (rc != EBUSY)
+        return rc;
+
+    ts.tv_sec = cMillies / 1000;
+    ts.tv_nsec = (cMillies % 1000) * 1000000;
+
+    while (ts.tv_sec > 0 || ts.tv_nsec > 0)
+    {
+        struct timespec delta, remaining;
+
+        if (ts.tv_sec > 0)
+        {
+            delta.tv_sec = 1;
+            delta.tv_nsec = 0;
+            ts.tv_sec--;
+        }
+        else
+        {
+            delta.tv_sec = 0;
+            delta.tv_nsec = ts.tv_nsec;
+            ts.tv_nsec = 0;
+        }
+        
+        nanosleep(&delta, &remaining);
+
         rc = pthread_mutex_trylock(mutex);
-        if (rc == EBUSY)
-        {
-            gettimeofday(&tv, NULL);
-
-            ts.tv_sec = pTsAbsTimeout->tv_sec - tv.tv_sec;
-            ts.tv_nsec = pTsAbsTimeout->tv_nsec - tv.tv_sec;
-
-            if (ts.tv_nsec < 0)
+        if (rc != EBUSY)
+            return rc;
+
+        if (RT_UNLIKELY(remaining.tv_nsec > 0 || remaining.tv_sec > 0))
+        {
+            ts.tv_sec += remaining.tv_sec;
+            ts.tv_nsec += remaining.tv_nsec;
+            if (ts.tv_nsec >= 1000000000)
             {
-                ts.tv_sec--;
-                ts.tv_nsec += 1000000000;
+                ts.tv_nsec -= 1000000000;
+                ts.tv_sec++;
             }
-
-            if (   ts.tv_sec > 0
-                && ts.tv_nsec > 0)
-                nanosleep(&ts, &ts);
-        }
-        else
-            break;
-    } while (   rc != 0
-             || ts.tv_sec > 0);
-    return rc;
+        }
+    }
+
+    return ETIMEDOUT;
 }
 #endif
@@ -276 +294 @@
     else
     {
+        int rc;
+#if !defined(RT_OS_DARWIN) && !defined(RT_OS_NETBSD)
         struct timespec     ts = {0,0};
-#if defined(RT_OS_DARWIN) || defined(RT_OS_HAIKU)
-
+# if defined(RT_OS_HAIKU)
         struct timeval      tv = {0,0};
         gettimeofday(&tv, NULL);
         ts.tv_sec = tv.tv_sec;
         ts.tv_nsec = tv.tv_usec * 1000;
-#else
+# else
         clock_gettime(CLOCK_REALTIME, &ts);
-#endif
+# endif
         if (cMillies != 0)
         {
@@ -298 +317 @@
 
         /* take mutex */
-#if !defined(RT_OS_DARWIN) && !defined(RT_OS_NETBSD)
-        int rc = pthread_mutex_timedlock(&pThis->Mutex, &ts);
-#else
-        int rc = rtSemFallbackPthreadMutexTimedlock(&pThis->Mutex, &ts);
+        rc = pthread_mutex_timedlock(&pThis->Mutex, &ts);
+#else
+        /*
+         * When there's no pthread_mutex_timedlock() use a crude sleep
+         * and retry approximation.  Since the sleep interval is
+         * relative, we don't need to convert to the absolute time
+         * here only to convert back to relative in the fallback
+         * function.
+         */
+        rc = rtSemFallbackPthreadMutexTimedlock(&pThis->Mutex, cMillies);
 #endif
         RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_MUTEX);