Use GetCurrentThreadId instead of pthread_self in FastMalloc

         Speeds up SunSpider by 0.3%.

         Reviewed by Steve.

         * wtf/FastMalloc.cpp:
         (WTF::TCMalloc_ThreadCache::InitTSD):
         (WTF::TCMalloc_ThreadCache::CreateCacheIfNecessary):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@27296 268f45cc-cd09-0410-ab3c-d52691b4dbfc

diff --git a/JavaScriptCore/ChangeLog b/JavaScriptCore/ChangeLog
index 0b461e0f4f08d28841b4020a3deb94e1f92fa4f0..9bbeaeb9ee2869019e7d5d1646c62db0ec9d669e 100644 (file)
--- a/JavaScriptCore/ChangeLog
+++ b/JavaScriptCore/ChangeLog
@@ -1,3 +1,15 @@
+2007-10-30  Adam Roben  <aroben@apple.com>
+
+        Use GetCurrentThreadId instead of pthread_self in FastMalloc
+
+        Speeds up SunSpider by 0.3%.
+
+        Reviewed by Steve.
+
+        * wtf/FastMalloc.cpp:
+        (WTF::TCMalloc_ThreadCache::InitTSD):
+        (WTF::TCMalloc_ThreadCache::CreateCacheIfNecessary):
+
 2007-10-30  Adam Roben  <aroben@apple.com>
 
         Switch to a Win32 critical section implementation of spinlocks

diff --git a/JavaScriptCore/wtf/FastMalloc.cpp b/JavaScriptCore/wtf/FastMalloc.cpp
index c2d7f6e708bb66f90177fdbe202e6941dd8f26d8..12fa7774fea4619579fb775f4924228131b562c1 100644 (file)
--- a/JavaScriptCore/wtf/FastMalloc.cpp
+++ b/JavaScriptCore/wtf/FastMalloc.cpp
@@ -1145,9 +1145,14 @@ class TCMalloc_ThreadCache_FreeList {
 class TCMalloc_ThreadCache {
  private:
   typedef TCMalloc_ThreadCache_FreeList FreeList;
+#if COMPILER(MSVC)
+  typedef DWORD ThreadIdentifier;
+#else
+  typedef pthread_t ThreadIdentifier;
+#endif
 
   size_t        size_;                  // Combined size of data
-  pthread_t     tid_;                   // Which thread owns it
+  ThreadIdentifier tid_;                // Which thread owns it
   bool          setspecific_;           // Called pthread_setspecific?
   FreeList      list_[kNumClasses];     // Array indexed by size-class
 
@@ -1160,7 +1165,7 @@ class TCMalloc_ThreadCache {
   TCMalloc_ThreadCache* next_;
   TCMalloc_ThreadCache* prev_;
 
-  void Init(pthread_t tid);
+  void Init(ThreadIdentifier tid);
   void Cleanup();
 
   // Accessors (mostly just for printing stats)
@@ -1471,7 +1476,7 @@ inline bool TCMalloc_ThreadCache::SampleAllocation(size_t k) {
   }
 }
 
-void TCMalloc_ThreadCache::Init(pthread_t tid) {
+void TCMalloc_ThreadCache::Init(ThreadIdentifier tid) {
   size_ = 0;
   next_ = NULL;
   prev_ = NULL;
@@ -1656,18 +1661,26 @@ void TCMalloc_ThreadCache::InitTSD() {
 #endif
   tsd_inited = true;
     
+#if !COMPILER(MSVC)
   // We may have used a fake pthread_t for the main thread.  Fix it.
   pthread_t zero;
   memset(&zero, 0, sizeof(zero));
+#endif
 #ifndef WTF_CHANGES
   SpinLockHolder h(&pageheap_lock);
 #else
   ASSERT(pageheap_lock.IsLocked());
 #endif
   for (TCMalloc_ThreadCache* h = thread_heaps; h != NULL; h = h->next_) {
+#if COMPILER(MSVC)
+    if (h->tid_ == 0) {
+      h->tid_ = GetCurrentThreadId();
+    }
+#else
     if (pthread_equal(h->tid_, zero)) {
       h->tid_ = pthread_self();
     }
+#endif
   }
 }
 
@@ -1677,6 +1690,14 @@ TCMalloc_ThreadCache* TCMalloc_ThreadCache::CreateCacheIfNecessary() {
   {
     SpinLockHolder h(&pageheap_lock);
 
+#if COMPILER(MSVC)
+    DWORD me;
+    if (!tsd_inited) {
+      me = 0;
+    } else {
+      me = GetCurrentThreadId();
+    }
+#else
     // Early on in glibc's life, we cannot even call pthread_self()
     pthread_t me;
     if (!tsd_inited) {
@@ -1684,12 +1705,17 @@ TCMalloc_ThreadCache* TCMalloc_ThreadCache::CreateCacheIfNecessary() {
     } else {
       me = pthread_self();
     }
+#endif
 
     // This may be a recursive malloc call from pthread_setspecific()
     // In that case, the heap for this thread has already been created
     // and added to the linked list.  So we search for that first.
     for (TCMalloc_ThreadCache* h = thread_heaps; h != NULL; h = h->next_) {
+#if COMPILER(MSVC)
+      if (h->tid_ == me) {
+#else
       if (pthread_equal(h->tid_, me)) {
+#endif
         heap = h;
         break;
       }