Changeset 8645 in vbox for trunk/src/VBox

Timestamp:

May 7, 2008 11:01:00 AM (17 years ago)

Author:

vboxsync

Message:

Added lock counts to the threads.

Location:

trunk/src/VBox/Runtime

Files:

• common/misc/thread.cpp (modified) (7 diffs)
• generic/critsect-generic.cpp (modified) (3 diffs)
• include/internal/thread.h (modified) (3 diffs)

trunk/src/VBox/Runtime/common/misc/thread.cpp

@@ -199 +199 @@
 #ifdef IN_RING3
 
-inline void rtThreadLockRW(void)
+DECLINLINE(void) rtThreadLockRW(void)
 {
     if (g_ThreadRWSem == NIL_RTSEMRW)
@@ -208 +208 @@
 
 
-inline void rtThreadLockRD(void)
+DECLINLINE(void) rtThreadLockRD(void)
 {
     if (g_ThreadRWSem == NIL_RTSEMRW)
@@ -217 +217 @@
 
 
-inline void rtThreadUnLockRW(void)
+DECLINLINE(void) rtThreadUnLockRW(void)
 {
     int rc = RTSemRWReleaseWrite(g_ThreadRWSem);
@@ -224 +224 @@
 
 
-inline void rtThreadUnLockRD(void)
+DECLINLINE(void) rtThreadUnLockRD(void)
 {
     int rc = RTSemRWReleaseRead(g_ThreadRWSem);
@@ -244 +244 @@
     /*
      * Allocate and insert the thread.
+     * (It is vital that rtThreadNativeAdopt updates the TLS before
+     * we try inserting the thread because of locking.)
      */
     int rc = VERR_NO_MEMORY;
@@ -1054 +1056 @@
 
 /**
+ * Gets the number of write locks and critical sections the specified
+ * thread owns.
+ *
+ * This number does not include any nested lock/critect entries.
+ *
+ * Note that it probably will return 0 for non-strict builds since
+ * release builds doesn't do unnecessary diagnostic counting like this.
+ *
+ * @returns Number of locks on success (0+) and VERR_INVALID_HANDLER on failure
+ * @param   Thread          The thread we're inquiring about.
+ */
+RTDECL(int32_t) RTThreadGetWriteLockCount(RTTHREAD Thread)
+{
+    PRTTHREADINT pThread = rtThreadGet(Thread);
+    if (!pThread)
+        return VERR_INVALID_HANDLE;
+    int32_t cWriteLocks = ASMAtomicReadS32(&pThread->cWriteLocks);
+    rtThreadRelease(pThread);
+    return cWriteLocks;
+}
+
+
+/**
+ * Works the THREADINT::cWriteLocks member, mostly internal.
+ *
+ * @param   Thread      The current thread.
+ */
+RTDECL(void) RTThreadWriteLockInc(RTTHREAD Thread)
+{
+    PRTTHREADINT pThread = rtThreadGet(Thread);
+    Assert(pThread);
+    ASMAtomicIncS32(&pThread->cWriteLocks);
+    rtThreadRelease(pThread);
+}
+
+
+/**
+ * Works the THREADINT::cWriteLocks member, mostly internal.
+ *
+ * @param   Thread      The current thread.
+ */
+RTDECL(void) RTThreadWriteLockDec(RTTHREAD Thread)
+{
+    PRTTHREADINT pThread = rtThreadGet(Thread);
+    Assert(pThread);
+    ASMAtomicDecS32(&pThread->cWriteLocks);
+    rtThreadRelease(pThread);
+}
+
+
+/**
+ * Gets the number of read locks the specified thread owns.
+ *
+ * Note that nesting read lock entry will be included in the
+ * total sum. And that it probably will return 0 for non-strict
+ * builds since release builds doesn't do unnecessary diagnostic
+ * counting like this.
+ *
+ * @returns Number of read locks on success (0+) and VERR_INVALID_HANDLER on failure
+ * @param   Thread          The thread we're inquiring about.
+ */
+RTDECL(int32_t) RTThreadGetReadLockCount(RTTHREAD Thread)
+{
+    PRTTHREADINT pThread = rtThreadGet(Thread);
+    if (!pThread)
+        return VERR_INVALID_HANDLE;
+    int32_t cReadLocks = ASMAtomicReadS32(&pThread->cReadLocks);
+    rtThreadRelease(pThread);
+    return cReadLocks;
+}
+
+
+/**
+ * Works the THREADINT::cReadLocks member.
+ *
+ * @param   Thread      The current thread.
+ */
+RTDECL(void) RTThreadReadLockInc(RTTHREAD Thread)
+{
+    PRTTHREADINT pThread = rtThreadGet(Thread);
+    Assert(pThread);
+    ASMAtomicIncS32(&pThread->cReadLocks);
+    rtThreadRelease(pThread);
+}
+
+
+/**
+ * Works the THREADINT::cReadLocks member.
+ *
+ * @param   Thread      The current thread.
+ */
+RTDECL(void) RTThreadReadLockDec(RTTHREAD Thread)
+{
+    PRTTHREADINT pThread = rtThreadGet(Thread);
+    Assert(pThread);
+    ASMAtomicDecS32(&pThread->cReadLocks);
+    rtThreadRelease(pThread);
+}
+
+
+
+
+
+/**
  * Recalculates scheduling attributes for the the default process
  * priority using the specified priority type for the calling thread.
@@ -1062 +1168 @@
  *
  * @returns iprt status code.
+ * @remarks Will only work for strict builds.
  */
 int rtThreadDoCalcDefaultPriority(RTTHREADTYPE enmType)

trunk/src/VBox/Runtime/generic/critsect-generic.cpp

@@ -46 +46 @@
  *          in order to get the RT thread structure there and this tree is
  *          protected by a critsect atm.
+ * @todo the L4 exclusion is no longer true, we've been using TLS for storing this for quite a while now.
  */
 #if !defined(RTCRITSECT_STRICT) && defined(RT_STRICT) && !defined(RT_OS_L4)
@@ -353 +354 @@
     pCritSect->Strict.uEnterId     = uId;
     ASMAtomicXchgSize(&pCritSect->Strict.ThreadOwner, (RTUINTPTR)ThreadSelf); /* screw gcc and its pedantic warnings. */
+    RTThreadWriteLockInc(ThreadSelf);
 #endif
 
@@ -389 +391 @@
          */
 #ifdef RTCRITSECT_STRICT
+        RTThreadWriteLockDec(pCritSect->Strict.ThreadOwner);
         ASMAtomicXchgSize(&pCritSect->Strict.ThreadOwner, NIL_RTTHREAD);
 #endif

trunk/src/VBox/Runtime/include/internal/thread.h

@@ -66 +66 @@
     /** Waiting on a event multiple wakeup semaphore. */
     RTTHREADSTATE_EVENTMULTI,
+    /** Waiting on a read write semaphore, read (shared) access. */
+    RTTHREADSTATE_RW_READ,
+    /** Waiting on a read write semaphore, write (exclusive) access. */
+    RTTHREADSTATE_RW_WRITE,
     /** The thread is sleeping. */
     RTTHREADSTATE_SLEEP,
@@ -78 +82 @@
                                         ||  (enmState) == RTTHREADSTATE_EVENT \
                                         ||  (enmState) == RTTHREADSTATE_EVENTMULTI \
+                                        ||  (enmState) == RTTHREADSTATE_RW_READ \
+                                        ||  (enmState) == RTTHREADSTATE_RW_WRITE \
                                         ||  (enmState) == RTTHREADSTATE_SLEEP \
                                        )
@@ -140 +146 @@
     /** Where we're blocking. */
     RTUINTPTR volatile      uBlockId;
+    /** Number of registered write locks, mutexes and critsects that this thread owns. */
+    int32_t volatile        cWriteLocks;
+    /** Number of registered read locks that this thread owns, nesting included. */
+    int32_t volatile        cReadLocks;
 #endif /* IN_RING3 */
 #ifdef IPRT_WITH_GENERIC_TLS