Changeset 139218 in webkit

Timestamp:

Jan 9, 2013 12:08:32 PM (11 years ago)

Author:

Antti Koivisto

Message:

Source/WebCore: Release FastMalloc thread caches on memory warning
​https://bugs.webkit.org/show_bug.cgi?id=106471

Reviewed by Geoff Garen.

FastMalloc keeps some memory in per-thread caches (currently 2MB each). We currently flush these caches on memory warning
for the main thread only. We should do it for other WebKit threads that use FastMalloc too.

Call WTF::releaseFastMallocFreeMemory in a bunch of WebCore support threads on memory warning. Unfortunately we don't have
an uniform way of doing threads so this requires bunch of thread type specific code.

Looks to be ~1% progression in membuster3 final and maximum numbers.

• platform/mac/MemoryPressureHandlerMac.mm:

(WebCore::MemoryPressureHandler::releaseMemory):

• storage/StorageTask.cpp:

(WebCore::StorageTask::performTask):

• storage/StorageTask.h:

(WebCore::StorageTask::createReleaseFastMallocFreeMemory):

• storage/StorageThread.cpp:

(WebCore::storageThreads):
(WebCore):
(WebCore::StorageThread::StorageThread):
(WebCore::StorageThread::~StorageThread):
(WebCore::StorageThread::releaseFastMallocFreeMemoryInAllThread):

• storage/StorageThread.h:

(StorageThread):

• workers/WorkerThread.cpp:

(WebCore::threadSetMutex):
(WebCore::workerThreads):
(WebCore::WorkerThread::workerThreadCount):
(WebCore::WorkerThread::WorkerThread):
(WebCore::WorkerThread::~WorkerThread):
(WebCore::WorkerThread::releaseFastMallocFreeMemoryInAllThread):
(WebCore):

• workers/WorkerThread.h:

(WorkerThread):

Source/WTF: Release FastMalloc thread caches on memory warning
​https://bugs.webkit.org/show_bug.cgi?id=106471

Reviewed by Geoff Garen.

Use TCMalloc_ThreadCache::Cleanup() instead of calling Scavenge() twice. This releases all the memory
and looks nicer too.

• wtf/FastMalloc.cpp:

(WTF::releaseFastMallocFreeMemory):

Location:

trunk/Source

Files:

• JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def (modified) (1 diff)
• WTF/ChangeLog (modified) (1 diff)
• WTF/wtf/FastMalloc.cpp (modified) (1 diff)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/mac/MemoryPressureHandlerMac.mm (modified) (2 diffs)
• WebCore/storage/StorageTask.cpp (modified) (1 diff)
• WebCore/storage/StorageTask.h (modified) (2 diffs)
• WebCore/storage/StorageThread.cpp (modified) (4 diffs)
• WebCore/storage/StorageThread.h (modified) (1 diff)
• WebCore/workers/WorkerThread.cpp (modified) (4 diffs)
• WebCore/workers/WorkerThread.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def

@@ -209 +209 @@
     ?fastMallocSize@WTF@@YAIPBX@Z
     ?fastMallocStatistics@WTF@@YA?AUFastMallocStatistics@1@XZ
+    ?releaseFastMallocFreeMemory@WTF@@YAXXZ
     ?fastRealloc@WTF@@YAPAXPAXI@Z
     ?fastStrDup@WTF@@YAPADPBD@Z

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2013-01-09  Antti Koivisto  <antti@apple.com>
+
+        Release FastMalloc thread caches on memory warning
+        https://bugs.webkit.org/show_bug.cgi?id=106471
+        
+        Reviewed by Geoff Garen.
+
+        Use TCMalloc_ThreadCache::Cleanup() instead of calling Scavenge() twice. This releases all the memory
+        and looks nicer too.
+
+        * wtf/FastMalloc.cpp:
+        (WTF::releaseFastMallocFreeMemory):
+
 2013-01-09  Carlos Garcia Campos  <cgarcia@igalia.com>
 

trunk/Source/WTF/wtf/FastMalloc.cpp

@@ -4383 +4383 @@
 {
     // Flush free pages in the current thread cache back to the page heap.
-    // Low watermark mechanism in Scavenge() prevents full return on the first pass.
-    // The second pass flushes everything.
-    if (TCMalloc_ThreadCache* threadCache = TCMalloc_ThreadCache::GetCacheIfPresent()) {
-        threadCache->Scavenge();
-        threadCache->Scavenge();
-    }
+    if (TCMalloc_ThreadCache* threadCache = TCMalloc_ThreadCache::GetCacheIfPresent())
+        threadCache->Cleanup();
 
     SpinLockHolder h(&pageheap_lock);
     pageheap->ReleaseFreePages();
 }
-    
+
 FastMallocStatistics fastMallocStatistics()
 {

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-01-09  Antti Koivisto  <antti@apple.com>
+
+        Release FastMalloc thread caches on memory warning
+        https://bugs.webkit.org/show_bug.cgi?id=106471
+
+        Reviewed by Geoff Garen.
+        
+        FastMalloc keeps some memory in per-thread caches (currently 2MB each). We currently flush these caches on memory warning 
+        for the main thread only. We should do it for other WebKit threads that use FastMalloc too.
+
+        Call WTF::releaseFastMallocFreeMemory in a bunch of WebCore support threads on memory warning. Unfortunately we don't have 
+        an uniform way of doing threads so this requires bunch of thread type specific code.
+        
+        Looks to be ~1% progression in membuster3 final and maximum numbers.
+
+        * platform/mac/MemoryPressureHandlerMac.mm:
+        (WebCore::MemoryPressureHandler::releaseMemory):
+        * storage/StorageTask.cpp:
+        (WebCore::StorageTask::performTask):
+        * storage/StorageTask.h:
+        (WebCore::StorageTask::createReleaseFastMallocFreeMemory):
+        * storage/StorageThread.cpp:
+        (WebCore::storageThreads):
+        (WebCore):
+        (WebCore::StorageThread::StorageThread):
+        (WebCore::StorageThread::~StorageThread):
+        (WebCore::StorageThread::releaseFastMallocFreeMemoryInAllThread):
+        * storage/StorageThread.h:
+        (StorageThread):
+        * workers/WorkerThread.cpp:
+        (WebCore::threadSetMutex):
+        (WebCore::workerThreads):
+        (WebCore::WorkerThread::workerThreadCount):
+        (WebCore::WorkerThread::WorkerThread):
+        (WebCore::WorkerThread::~WorkerThread):
+        (WebCore::WorkerThread::releaseFastMallocFreeMemoryInAllThread):
+        (WebCore):
+        * workers/WorkerThread.h:
+        (WorkerThread):
+
 2013-01-09  Tony Gentilcore  <tonyg@chromium.org>
 

trunk/Source/WebCore/platform/mac/MemoryPressureHandlerMac.mm

@@ -33 +33 @@
 #import <WebCore/PageCache.h>
 #import <WebCore/LayerPool.h>
+#import <WebCore/ScrollingThread.h>
+#import <WebCore/StorageThread.h>
+#import <WebCore/WorkerThread.h>
 #import <wtf/CurrentTime.h>
 #import <wtf/FastMalloc.h>
+#import <wtf/Functional.h>
 
 #if !PLATFORM(IOS) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
@@ -161 +165 @@
     gcController().discardAllCompiledCode();
 
+    // FastMalloc has lock-free thread specific caches that can only be cleared from the thread itself.
+    StorageThread::releaseFastMallocFreeMemoryInAllThreads();
+#if ENABLE(WORKERS)
+    WorkerThread::releaseFastMallocFreeMemoryInAllThreads();
+#endif
+#if ENABLE(THREADED_SCROLLING)
+    ScrollingThread::dispatch(bind(WTF::releaseFastMallocFreeMemory));
+#endif
     WTF::releaseFastMallocFreeMemory();
 }

trunk/Source/WebCore/storage/StorageTask.cpp

@@ -106 +106 @@
             m_area->deleteEmptyDatabase();
             break;
+        case ReleaseFastMallocFreeMemory:
+            WTF::releaseFastMallocFreeMemory();
+            break;
         case TerminateThread:
             m_thread->performTerminate();

trunk/Source/WebCore/storage/StorageTask.h

@@ -39 +39 @@
         WTF_MAKE_NONCOPYABLE(StorageTask); WTF_MAKE_FAST_ALLOCATED;
     public:
-        enum Type { AreaImport, AreaSync, DeleteEmptyDatabase, SetOriginDetails, ImportOrigins, DeleteAllOrigins, DeleteOrigin, TerminateThread };
+        enum Type { AreaImport, AreaSync, DeleteEmptyDatabase, SetOriginDetails, ImportOrigins, DeleteAllOrigins, DeleteOrigin, ReleaseFastMallocFreeMemory, TerminateThread };
 
         ~StorageTask();
@@ -50 +50 @@
         static PassOwnPtr<StorageTask> createDeleteOrigin(const String& originIdentifier) { return adoptPtr(new StorageTask(DeleteOrigin, originIdentifier)); }
         static PassOwnPtr<StorageTask> createDeleteAllOrigins() { return adoptPtr(new StorageTask(DeleteAllOrigins)); }
+        static PassOwnPtr<StorageTask> createReleaseFastMallocFreeMemory() { return adoptPtr(new StorageTask(ReleaseFastMallocFreeMemory)); }
         static PassOwnPtr<StorageTask> createTerminate(StorageThread* thread) { return adoptPtr(new StorageTask(TerminateThread, thread)); }
 

trunk/Source/WebCore/storage/StorageThread.cpp

@@ -30 +30 @@
 #include "StorageTask.h"
 #include "StorageAreaSync.h"
+#include <wtf/HashSet.h>
 #include <wtf/MainThread.h>
 
 namespace WebCore {
+
+static HashSet<StorageThread*>& storageThreads()
+{
+    ASSERT(isMainThread());
+    DEFINE_STATIC_LOCAL(HashSet<StorageThread*>, threads, ());
+    return threads;
+}
 
 PassOwnPtr<StorageThread> StorageThread::create()
@@ -42 +50 @@
     : m_threadID(0)
 {
+    ASSERT(isMainThread());
+    storageThreads().add(this);
 }
 
@@ -48 +58 @@
     ASSERT(isMainThread());
     ASSERT(!m_threadID);
+    storageThreads().remove(this);
 }
 
@@ -101 +112 @@
 }
 
+void StorageThread::releaseFastMallocFreeMemoryInAllThreads()
+{
+    HashSet<StorageThread*>& threads = storageThreads();
+    HashSet<StorageThread*>::iterator end = threads.end();
+    for (HashSet<StorageThread*>::iterator it = threads.begin(); it != end; ++it)
+        (*it)->scheduleTask(StorageTask::createReleaseFastMallocFreeMemory());
 }
+
+}

trunk/Source/WebCore/storage/StorageThread.h

@@ -51 +51 @@
         void performTerminate();
 
+        static void releaseFastMallocFreeMemoryInAllThreads();
+
     private:
         StorageThread();

trunk/Source/WebCore/workers/WorkerThread.cpp

@@ -54 +54 @@
 namespace WebCore {
 
-static Mutex& threadCountMutex()
+static Mutex& threadSetMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
@@ -60 +60 @@
 }
 
-unsigned WorkerThread::m_threadCount = 0;
+static HashSet<WorkerThread*>& workerThreads()
+{
+    DEFINE_STATIC_LOCAL(HashSet<WorkerThread*>, threads, ());
+    return threads;
+}
 
 unsigned WorkerThread::workerThreadCount()
 {
-    MutexLocker lock(threadCountMutex());
-    return m_threadCount;
+    MutexLocker lock(threadSetMutex());
+    return workerThreads().size();
 }
 
@@ -115 +119 @@
 #endif
 {
-    MutexLocker lock(threadCountMutex());
-    m_threadCount++;
+    MutexLocker lock(threadSetMutex());
+    workerThreads().add(this);
 }
 
 WorkerThread::~WorkerThread()
 {
-    MutexLocker lock(threadCountMutex());
-    ASSERT(m_threadCount > 0);
-    m_threadCount--;
+    MutexLocker lock(threadSetMutex());
+    ASSERT(workerThreads().contains(this));
+    workerThreads().remove(this);
 }
 
@@ -273 +277 @@
 }
 
+class ReleaseFastMallocFreeMemoryTask : public ScriptExecutionContext::Task {
+    virtual void performTask(ScriptExecutionContext*) OVERRIDE { WTF::releaseFastMallocFreeMemory(); }
+};
+
+void WorkerThread::releaseFastMallocFreeMemoryInAllThreads()
+{
+    MutexLocker lock(threadSetMutex());
+    HashSet<WorkerThread*>& threads = workerThreads();
+    HashSet<WorkerThread*>::iterator end = threads.end();
+    for (HashSet<WorkerThread*>::iterator it = threads.begin(); it != end; ++it)
+        (*it)->runLoop().postTask(adoptPtr(new ReleaseFastMallocFreeMemoryTask));
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/workers/WorkerThread.h

@@ -64 +64 @@
         // Number of active worker threads.
         static unsigned workerThreadCount();
+        static void releaseFastMallocFreeMemoryInAllThreads();
 
 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
@@ -99 +100 @@
         NotificationClient* m_notificationClient;
 #endif
-
-        // Track the number of WorkerThread instances for use in layout tests.
-        static unsigned m_threadCount;
     };