Unify ThreadID.

src/core/SkSharedMutex.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkSharedMutex.h"
 
 #include "SkAtomics.h"
 #include "SkTypes.h"
-#include "../private/SkSemaphore.h"
+#include "SkSemaphore.h"
 
 #if defined(THREAD_SANITIZER)
 
 /* Report that a lock has been created at address "lock". */
 #define ANNOTATE_RWLOCK_CREATE(lock) \
     AnnotateRWLockCreate(__FILE__, __LINE__, lock)
 
 /* Report that the lock at address "lock" is about to be destroyed. */
 #define ANNOTATE_RWLOCK_DESTROY(lock) \
     AnnotateRWLockDestroy(__FILE__, __LINE__, lock)
@@ skipping 38 matching lines @@
 
 #define ANNOTATE_RWLOCK_CREATE(lock)
 #define ANNOTATE_RWLOCK_DESTROY(lock)
 #define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)
 #define ANNOTATE_RWLOCK_RELEASED(lock, is_w)
 
 #endif
 
 #ifdef SK_DEBUG
 
+    #include "SkThreadID.h"
     #include "SkTDArray.h"
-    #ifdef SK_BUILD_FOR_WIN
-        #include <windows.h>
-        static int64_t get_thread_id() { return GetCurrentThreadId(); }
-    #else
-        #include <pthread.h>
-        static int64_t get_thread_id() { return (int64_t)pthread_self(); }
-    #endif
-
-    typedef int64_t ThreadID;
 
     class SkSharedMutex::ThreadIDSet {
     public:
         // Returns true if threadID is in the set.
-        bool find(ThreadID threadID) const {
+        bool find(SkThreadID threadID) const {
             for (auto& t : fThreadIDs) {
                 if (t == threadID) return true;
             }
             return false;
         }
 
         // Returns true if did not already exist.
-        bool tryAdd(ThreadID threadID) {
+        bool tryAdd(SkThreadID 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) {
+        bool tryRemove(SkThreadID 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;
+        SkTDArray<SkThreadID> fThreadIDs;
     };
 
     SkSharedMutex::SkSharedMutex()
         : fCurrentShared(new ThreadIDSet)
         , fWaitingExclusive(new ThreadIDSet)
         , fWaitingShared(new ThreadIDSet){
         ANNOTATE_RWLOCK_CREATE(this);
     }
 
     SkSharedMutex::~SkSharedMutex() {  ANNOTATE_RWLOCK_DESTROY(this); }
 
     void SkSharedMutex::acquire() {
-        ThreadID threadID(get_thread_id());
+        SkThreadID threadID(SkGetThreadID());
         int currentSharedCount;
         int waitingExclusiveCount;
         {
             SkAutoMutexAcquire l(&fMu);
 
             if (!fWaitingExclusive->tryAdd(threadID)) {
                 SkDEBUGFAILF("Thread %lx already has an exclusive lock\n", threadID);
             }
 
             currentSharedCount = fCurrentShared->count();
             waitingExclusiveCount = fWaitingExclusive->count();
         }
 
         if (currentSharedCount > 0 || waitingExclusiveCount > 1) {
             fExclusiveQueue.wait();
         }
 
         ANNOTATE_RWLOCK_ACQUIRED(this, 1);
     }
 
     // Implementation Detail:
     // The shared threads need two seperate queues to keep the threads that were added after the
     // exclusive lock separate from the threads added before.
     void SkSharedMutex::release() {
         ANNOTATE_RWLOCK_RELEASED(this, 1);
-        ThreadID threadID(get_thread_id());
+        SkThreadID threadID(SkGetThreadID());
         int sharedWaitingCount;
         int exclusiveWaitingCount;
         int sharedQueueSelect;
         {
             SkAutoMutexAcquire l(&fMu);
             SkASSERT(0 == fCurrentShared->count());
             if (!fWaitingExclusive->tryRemove(threadID)) {
                 SkDEBUGFAILF("Thread %lx did not have the lock held.\n", threadID);
             }
             exclusiveWaitingCount = fWaitingExclusive->count();
             sharedWaitingCount = fWaitingShared->count();
             fWaitingShared.swap(fCurrentShared);
             sharedQueueSelect = fSharedQueueSelect;
             if (sharedWaitingCount > 0) {
                 fSharedQueueSelect = 1 - fSharedQueueSelect;
             }
         }
 
         if (sharedWaitingCount > 0) {
             fSharedQueue[sharedQueueSelect].signal(sharedWaitingCount);
         } else if (exclusiveWaitingCount > 0) {
             fExclusiveQueue.signal();
         }
     }
 
     void SkSharedMutex::assertHeld() const {
-        ThreadID threadID(get_thread_id());
+        SkThreadID threadID(SkGetThreadID());
         SkAutoMutexAcquire l(&fMu);
         SkASSERT(0 == fCurrentShared->count());
         SkASSERT(fWaitingExclusive->find(threadID));
     }
 
     void SkSharedMutex::acquireShared() {
-        ThreadID threadID(get_thread_id());
+        SkThreadID threadID(SkGetThreadID());
         int exclusiveWaitingCount;
         int sharedQueueSelect;
         {
             SkAutoMutexAcquire l(&fMu);
             exclusiveWaitingCount = fWaitingExclusive->count();
             if (exclusiveWaitingCount > 0) {
                 if (!fWaitingShared->tryAdd(threadID)) {
                     SkDEBUGFAILF("Thread %lx was already waiting!\n", threadID);
                 }
             } else {
                 if (!fCurrentShared->tryAdd(threadID)) {
                     SkDEBUGFAILF("Thread %lx already holds a shared lock!\n", threadID);
                 }
             }
             sharedQueueSelect = fSharedQueueSelect;
         }
 
         if (exclusiveWaitingCount > 0) {
             fSharedQueue[sharedQueueSelect].wait();
         }
 
         ANNOTATE_RWLOCK_ACQUIRED(this, 0);
     }
 
     void SkSharedMutex::releaseShared() {
         ANNOTATE_RWLOCK_RELEASED(this, 0);
-        ThreadID threadID(get_thread_id());
+        SkThreadID threadID(SkGetThreadID());
 
         int currentSharedCount;
         int waitingExclusiveCount;
         {
             SkAutoMutexAcquire l(&fMu);
             if (!fCurrentShared->tryRemove(threadID)) {
                 SkDEBUGFAILF("Thread %lx does not hold a shared lock.\n", threadID);
             }
             currentSharedCount = fCurrentShared->count();
             waitingExclusiveCount = fWaitingExclusive->count();
         }
 
         if (0 == currentSharedCount && waitingExclusiveCount > 0) {
             fExclusiveQueue.signal();
         }
     }
 
     void SkSharedMutex::assertHeldShared() const {
-        ThreadID threadID(get_thread_id());
+        SkThreadID threadID(SkGetThreadID());
         SkAutoMutexAcquire l(&fMu);
         SkASSERT(fCurrentShared->find(threadID));
     }
 
 #else
 
     // The fQueueCounts fields holds many counts in an int32_t in order to make managing them atomic.
     // These three counts must be the same size, so each gets 10 bits. The 10 bits represent
     // the log of the count which is 1024.
     //
@@ skipping 99 matching lines @@
 
         // If shared count is going to zero (because the old count == 1) and there are exclusive
         // waiters, then run a single exclusive waiter.
         if (((oldQueueCounts & kSharedMask) >> kSharedOffset) == 1
             && (oldQueueCounts & kWaitingExclusiveMask) > 0) {
             fExclusiveQueue.signal();
         }
     }
 
 #endif