Changeset 19245 in webkit for trunk/JavaScriptCore/wtf

Timestamp:

Jan 29, 2007, 9:07:25 PM (18 years ago)

Author:

ggaren

Message:

JavaScriptCore:

Reviewed by Maciej Stachowiak.

Fixed <rdar://problem/4485644> REGRESSION: JavaScriptCore has init routines

The TCMalloc module now initializes, if needed, inside GetCache() and
fastMallocSetIsMultiThreaded(). We leverage the same synchronization
technique used for enabling / disabling the single-threaded optimization
to synchronize initialization of the library without requiring a lock
for every malloc.

1,251 runs of tcmalloc_unittest, 2 runs of a custom, massively multi-threaded
tcmalloc_unittest, and my custom version of the PLT show no regressions.
Super-accurate JS iBench reports a .24% regression, which is right at the
limit of its error range, so I'm declaring victory.

• wtf/FastMalloc.cpp: (WTF::fastMallocSetIsMultiThreaded): Initialize, if needed. (InitModule() checks the "if needed" part.) (WTF::TCMalloc_ThreadCache::GetCache): Restored original TCMalloc code inside #ifdef, for posterity. Added new initialization logic. (WTF::TCMalloc_ThreadCache::InitModule): Call InitTSD(), since we don't have a static initializer to call it for us, now. This means that fastMalloc is not usable as a general libc allocator, but it never was, and if it were the general libc allocator, we wouldn't be here in the first place, so whatever. (WTF::TCMalloc_ThreadCache::InitTSD): Don't try to take the pageheap_lock, since InitModule already has it.

WebKitTools:

Reviewed by Maciej Stachowiak.

Fixed <rdar://problem/4485644> REGRESSION: JavaScriptCore has init routines

No more mollycoddling for you, FastMalloc.o!

• Scripts/check-for-global-initializers:

Location:

trunk/JavaScriptCore/wtf

Files:

• FastMalloc.cpp (modified) (5 diffs)
• TCSpinLock.h (modified) (1 diff)

trunk/JavaScriptCore/wtf/FastMalloc.cpp

@@ -1392 +1392 @@
 }
 
+#ifdef WTF_CHANGES
 bool isMultiThreaded;
 TCMalloc_ThreadCache *mainThreadCache;
 
-void fastMallocSetIsMultiThreaded() 
+void fastMallocSetIsMultiThreaded()
 {
     // We lock when writing mainThreadCache but not when reading it. It's OK if
@@ -1403 +1404 @@
     // clients must call this function before allocating on other threads, so they'll 
     // have synchronized before reading mainThreadCache.
-
-    // mainThreadCache is only set when isMultiThreaded is false, to save a 
-    // branch in some cases.
-
-    SpinLockHolder lock(&pageheap_lock);
-    isMultiThreaded = true;
-    mainThreadCache = 0;
-}
+    
+    // A similar principle applies to isMultiThreaded. It's OK for the main thread
+    // in GetCache() to read a stale, false value for isMultiThreaded because 
+    // doing so will just cause it to make an unnecessary call to InitModule(),
+    // which will synchronize it.
+
+    // To save a branch in some cases, mainThreadCache is only set when 
+    // isMultiThreaded is false.
+
+    {
+        SpinLockHolder lock(&pageheap_lock);
+        isMultiThreaded = true;
+        mainThreadCache = 0;
+    }
+
+    TCMalloc_ThreadCache::InitModule();
+}
+#endif
 
 ALWAYS_INLINE TCMalloc_ThreadCache* TCMalloc_ThreadCache::GetCache() {
   void* ptr = NULL;
+#ifndef WTF_CHANGES
   if (!tsd_inited) {
     InitModule();
   } else {
-      if (mainThreadCache)
-          ptr = mainThreadCache;
-      else
-          ptr = pthread_getspecific(heap_key);
-  }
+    ptr = pthread_getspecific(heap_key);
+  }
+#else
+  if (mainThreadCache) // fast path for single-threaded mode
+    return mainThreadCache;
+
+  if (isMultiThreaded) // fast path for multi-threaded mode -- heap_key already initialized
+    ptr = pthread_getspecific(heap_key);
+  else // slow path for possible first-time init
+    InitModule();
+#endif
   if (ptr == NULL) ptr = CreateCacheIfNecessary();
   return reinterpret_cast<TCMalloc_ThreadCache*>(ptr);
@@ -1458 +1476 @@
   SpinLockHolder h(&pageheap_lock);
   if (!phinited) {
+#ifdef WTF_CHANGES
+    InitTSD();
+#endif
     InitSizeClasses();
     threadheap_allocator.Init();
@@ -1481 +1502 @@
   pthread_t zero;
   memset(&zero, 0, sizeof(zero));
+#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 (h->tid_ == zero) {
@@ -2053 +2078 @@
 };
 
+#ifndef WTF_CHANGES
 static TCMallocGuard module_enter_exit_hook;
-
+#endif
 
 //-------------------------------------------------------------------

trunk/JavaScriptCore/wtf/TCSpinLock.h

@@ -95 +95 @@
 #endif
   }
+
+#ifdef WTF_CHANGES  
+  inline bool IsLocked() {
+    return private_lockword_ != 0;
+  }
+#endif
 };