Changeset 21593 in vbox for trunk/src/VBox/Runtime/r0drv/generic/semspinmutex-r0drv-generic.c

Timestamp:

Jul 14, 2009 10:32:38 PM (15 years ago)

Author:

vboxsync

Message:

RTSemSpinMutexRequest: Some adjustments.

File:

• trunk/src/VBox/Runtime/r0drv/generic/semspinmutex-r0drv-generic.c (modified) (5 diffs)

trunk/src/VBox/Runtime/r0drv/generic/semspinmutex-r0drv-generic.c

@@ -150 +150 @@
 static int rtSemSpinMutexEnter(RTSEMSPINMUTEXSTATE *pState, RTSEMSPINMUTEXINTERNAL *pThis)
 {
+    int rc = VINF_SUCCESS;
+
     /** @todo Later #1: When entering in interrupt context and we're not able to
      *        wake up threads from it, we could try switch the lock into pure
@@ -187 +189 @@
     {
         if (!(pThis->fFlags & RTSEMSPINMUTEX_FLAGS_IRQ_SAFE))
-            return VERR_SEM_BAD_CONTEXT;
+            rc = VINF_SEM_BAD_CONTEXT; /* Try, but owner might be interrupted. */
         pState->fSpin = true;
     }
@@ -212 +214 @@
         pState->fSavedFlags = 0;
 
-    return VINF_SUCCESS;
+    return rc;
 }
 
@@ -270 +272 @@
     {
         /* Busy, too bad. Check for attempts at nested access. */
-        int rc = VERR_SEM_BUSY;
+        rc = VERR_SEM_BUSY;
         if (RT_UNLIKELY(pThis->hOwner == hSelf))
         {
@@ -329 +331 @@
 
         /*
+         * Return if we're in interrupt context and the semaphore isn't
+         * configure to be interrupt safe.
+         */
+        if (rc == VINF_SEM_BAD_CONTEXT)
+        {
+            rtSemSpinMutexLeave(&State);
+            return VERR_SEM_BAD_CONTEXT;
+        }
+
+        /*
          * Ok, we have to wait.
          */
-        for (cSpins = 0;; cSpins++)
+        if (State.fSpin)
         {
-            ASMAtomicCmpXchgHandle(&pThis->hOwner, hSelf, NIL_RTNATIVETHREAD, fRc);
-            if (fRc)
-                break;
-
-            if (RT_UNLIKELY(pThis->u32Magic != RTSEMSPINMUTEX_MAGIC))
+            for (cSpins = 0; ; cSpins++)
             {
-                rtSemSpinMutexLeave(&State);
-                return VERR_SEM_DESTROYED;
+                ASMAtomicCmpXchgHandle(&pThis->hOwner, hSelf, NIL_RTNATIVETHREAD, fRc);
+                if (fRc)
+                    break;
+                ASMNopPause();
+                if (RT_UNLIKELY(pThis->u32Magic != RTSEMSPINMUTEX_MAGIC))
+                {
+                    rtSemSpinMutexLeave(&State);
+                    return VERR_SEM_DESTROYED;
+                }
+
+                /*
+                 * "Yield" once in a while. This may lower our IRQL/PIL which
+                 * may preempting us, and it will certainly stop the hammering
+                 * of hOwner for a little while.
+                 */
+                if ((cSpins & 0x7f) == 0x1f)
+                {
+                    rtSemSpinMutexLeave(&State);
+                    rtSemSpinMutexEnter(&State, pThis);
+                    Assert(State.fSpin);
+                }
             }
-
-            if (    State.fSpin
-                ||  (cSpins & 15) != 15 /* spin a bit everytime we wake up. */)
+        }
+        else
+        {
+            for (cSpins = 0;; cSpins++)
+            {
+                ASMAtomicCmpXchgHandle(&pThis->hOwner, hSelf, NIL_RTNATIVETHREAD, fRc);
+                if (fRc)
+                    break;
                 ASMNopPause();
-            else
-            {
-                rtSemSpinMutexLeave(&State);
-
-                rc = RTSemEventWait(pThis->hEventSem, RT_INDEFINITE_WAIT);
-                ASMCompilerBarrier();
-                if (RT_SUCCESS(rc))
-                    AssertReturn(pThis->u32Magic == RTSEMSPINMUTEX_MAGIC, VERR_SEM_DESTROYED);
-                else if (rc == VERR_INTERRUPTED)
-                    AssertRC(rc);       /* shouldn't happen */
-                else
+                if (RT_UNLIKELY(pThis->u32Magic != RTSEMSPINMUTEX_MAGIC))
                 {
-                    AssertRC(rc);
-                    return rc;
+                    rtSemSpinMutexLeave(&State);
+                    return VERR_SEM_DESTROYED;
                 }
 
-                rc = rtSemSpinMutexEnter(&State, pThis);
-                AssertRCReturn(rc, rc);
+                if ((cSpins & 15) == 15) /* spin a bit before going sleep (again). */
+                {
+                    rtSemSpinMutexLeave(&State);
+
+                    rc = RTSemEventWait(pThis->hEventSem, RT_INDEFINITE_WAIT);
+                    ASMCompilerBarrier();
+                    if (RT_SUCCESS(rc))
+                        AssertReturn(pThis->u32Magic == RTSEMSPINMUTEX_MAGIC, VERR_SEM_DESTROYED);
+                    else if (rc == VERR_INTERRUPTED)
+                        AssertRC(rc);       /* shouldn't happen */
+                    else
+                    {
+                        AssertRC(rc);
+                        return rc;
+                    }
+
+                    rc = rtSemSpinMutexEnter(&State, pThis);
+                    AssertRCReturn(rc, rc);
+                    Assert(!State.fSpin);
+                }
             }
         }