Add debug mode to shared mutex.

src/core/SkSharedMutex.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkSharedLock_DEFINED
 #define SkSharedLock_DEFINED
 
 #include "SkAtomics.h"
 #include "SkSemaphore.h"
 #include "SkTypes.h"
-    
-// This is a shared lock implementation similar to pthreads rwlocks. This implementation is
-// cribbed from Preshing's article:
+
+#ifdef SK_DEBUG
+    #include "SkMutex.h"
+    #include "SkTDArray.h"
+    #ifdef SK_BUILD_FOR_WIN
+        #include <windows.h>
+        typedef DWORD threadID_t;
+        static threadID_t getThreadID() { return GetCurrentThreadId(); }

[mtklein_C, 2015/09/17 19:51:42]

These standalone statics are typically get_thread_id()

[herb_g, 2015/09/17 21:39:41]

Done.

+    #else
+        #include <pthread.h>
+        typedef pthread_t threadID_t;
+        static threadID_t getThreadID() { return pthread_self(); }

[mtklein_C, 2015/09/17 19:51:42]

static int64_t get_thread_id() { return (int64_t)pthread_self(); }
static int64_t get_thread_id() { return (int64_t)GetCurrentThreadId(); }d

?

[herb_g, 2015/09/17 21:39:41]

Done.

+  #endif
+#endif  // SK_DEBUG
+
+// There are two shared lock implementations one debug the other is high performance. They implement
+// an interface similar to pthread's rwlocks.
+// This is a shared lock implementation similar to pthreads rwlocks. The high performance
+// implementation is cribbed from Preshing's article:
 // http://preshing.com/20150316/semaphores-are-surprisingly-versatile/
 //
 // This lock does not obey strict queue ordering. It will always alternate between readers and
 // a single writer.
 class SkSharedMutex {
 public:
     SkSharedMutex();
     ~SkSharedMutex();
     // Acquire lock for exclusive use.
     void acquire();
 
     // Release lock for exclusive use.
     void release();
 
     // Fail if exclusive is not held.
-#ifdef SK_DEBUG
     void assertHeld() const;

[mtklein_C, 2015/09/17 19:51:42]

undo these bits?

[herb_g, 2015/09/17 21:39:41]

Done.

-#else
-    void assertHeld() const {}
-#endif
 
     // Acquire lock for shared use.
     void acquireShared();
 
     // Release lock for shared use.
     void releaseShared();
 
     // Fail if shared lock not held.
-#ifdef SK_DEBUG
     void assertHeldShared() const;
-#else
-    void assertHeldShared() const {}
-#endif
 
 private:
+#ifdef SK_DEBUG
+    class ThreadID {
+    public:
+        ThreadID() : fThreadID(getThreadID()) { }
+        bool operator==(const ThreadID& that) const { return fThreadID == that.fThreadID; }
+        int64_t toInt() const { return (int64_t)fThreadID; }
+    private:
+        threadID_t fThreadID;
+    };
+
+    class ThreadIDSet {
+    public:
+        // Returns true if threadID is in the set.
+        bool find(ThreadID threadID) const {
+            for (auto& t : fThreadIDs) {
+                if (t == threadID) return true;
+            }
+            return false;
+        }
+
+        // Returns true if did not already exist.
+        bool tryAdd(ThreadID threadID) {
+            for (auto& t : fThreadIDs) {
+                if (t == threadID) return false;
+            }
+            fThreadIDs.append(1, &threadID);
+            return true;
+        }
+        // Returns true if already exists in Set.
+        bool tryRemove(ThreadID threadID) {
+            for (int i = 0; i < fThreadIDs.count(); ++i) {
+                if (fThreadIDs[i] == threadID) {
+                    fThreadIDs.remove(i);
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        void swap(ThreadIDSet& other) {
+            fThreadIDs.swap(other.fThreadIDs);
+        }
+
+        int count() const {
+            return fThreadIDs.count();
+        }
+
+    private:
+        SkTDArray<ThreadID> fThreadIDs;
+    };
+
+    ThreadIDSet      fCurrentShared;
+    ThreadIDSet      fWaitingExclusive;
+    ThreadIDSet      fWaitingShared;
+    int              fSharedQueueSelect{0};
+    mutable SkMutex  fMu;
+    SkSemaphore      fSharedQueue[2];
+    SkSemaphore      fExclusiveQueue;
+#else
     SkAtomic<int32_t> fQueueCounts;
-    SkSemaphore fSharedQueue;
-    SkSemaphore fExclusiveQueue;
+    SkSemaphore       fSharedQueue;
+    SkSemaphore       fExclusiveQueue;
+#endif  // SK_DEBUG
 };
 
-
 #endif // SkSharedLock_DEFINED