Changeset 25366 in webkit for trunk/JavaScriptCore/wtf/FastMalloc.cpp

Timestamp:

Sep 4, 2007, 10:15:06 PM (18 years ago)

Author:

mjs

Message:

Back out accidentally committed change.

• JavaScriptCore.xcodeproj/project.pbxproj:
• kjs/collector.cpp: (KJS::Collector::registerThread):
• wtf/FastMalloc.cpp: (WTF::fastMallocSetIsMultiThreaded): (WTF::TCMalloc_ThreadCache::GetCache): (WTF::TCMalloc_ThreadCache::GetCacheIfPresent): (WTF::TCMalloc_ThreadCache::CreateCacheIfNecessary): (WTF::do_malloc):
• wtf/FastMallocInternal.h: Added.

File:

• trunk/JavaScriptCore/wtf/FastMalloc.cpp (modified) (6 diffs)

trunk/JavaScriptCore/wtf/FastMalloc.cpp

@@ -161 +161 @@
 }
 
+void fastMallocSetIsMultiThreaded() 
+{
+}
+
 } // namespace WTF
 
@@ -1547 +1551 @@
 }
 
+#ifdef WTF_CHANGES
+bool isMultiThreaded;
+TCMalloc_ThreadCache *mainThreadCache;
+
+void fastMallocSetIsMultiThreaded()
+{
+    // We lock when writing mainThreadCache but not when reading it. It's OK if
+    // the main thread reads a stale, non-NULL value for mainThreadCache because
+    // mainThreadCache is the same as the main thread's thread-specific cache.
+    // Other threads can't read a stale, non-NULL value for mainThreadCache because
+    // clients must call this function before allocating on other threads, so they'll 
+    // have synchronized before reading mainThreadCache.
+    
+    // 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();
@@ -1554 +1590 @@
     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);
@@ -1562 +1607 @@
 // already cleaned up the cache for this thread.
 inline TCMalloc_ThreadCache* TCMalloc_ThreadCache::GetCacheIfPresent() {
+  if (mainThreadCache)
+      return mainThreadCache;
   if (!tsd_inited) return NULL;
   return reinterpret_cast<TCMalloc_ThreadCache*>
@@ -1663 +1710 @@
       thread_heap_count++;
       RecomputeThreadCacheSize(); 
+      if (!isMultiThreaded)
+        mainThreadCache = heap;
     }
   }
@@ -1993 +2042 @@
 
 #ifdef WTF_CHANGES
+    ASSERT(isMultiThreaded || pthread_main_np());
     ASSERT(!isForbidden());
 #endif