Do V8 GC ASAP if system memory is pressured

third_party/WebKit/Source/core/workers/WorkerThread.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 36 matching lines @@
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/WeakPtr.h"
 #include "wtf/text/WTFString.h"
 #include <limits.h>
 
 namespace blink {
 
+std::set<v8::Isolate*>* WorkerThread::gIsolates = nullptr;
+
 class WorkerMicrotaskRunner : public WebThread::TaskObserver {
 public:
     explicit WorkerMicrotaskRunner(WorkerThread* workerThread)
         : m_workerThread(workerThread)
     {
     }
 
     void willProcessTask() override
     {
         // No tasks should get executed after we have closed.
@@ skipping 136 matching lines @@
             // Notify the main thread that it is safe to deallocate our resources.
             m_terminationEvent->signal();
             return;
         }
 
         m_microtaskRunner = adoptPtr(new WorkerMicrotaskRunner(this));
         initializeBackingThread();
         backingThread().addTaskObserver(m_microtaskRunner.get());
 
         m_isolate = initializeIsolate();
+        if (!gIsolates)
+            gIsolates = new std::set<v8::Isolate*>();
+        gIsolates->insert(m_isolate);

[kinuko, 2016/04/11 09:30:40]

For compositor worker (where single thread is shared by multiple workers)
initializeIsolate() returns the same isolate for multiple times, and
destroyIsolate() may not be actually destroying the isolate yet if there're
other compositor workers running on the same thread.

We're working on making the part slightly cleaner but for the time being.. maybe
destroyIsolate() could return a bool value that indicates if it actually
destroyed the isolate or not?

[hong.zheng, 2016/04/15 06:05:57]

use WorkerBackingThread instead

         // Optimize for memory usage instead of latency for the worker isolate.
         m_isolate->IsolateInBackgroundNotification();
         m_workerGlobalScope = createWorkerGlobalScope(startupData);
         m_workerGlobalScope->scriptLoaded(sourceCode.length(), cachedMetaData.get() ? cachedMetaData->size() : 0);
 
         didStartWorkerThread();
 
         // Notify proxy that a new WorkerGlobalScope has been created and started.
         m_workerReportingProxy.workerGlobalScopeStarted(m_workerGlobalScope.get());
 
@@ skipping 47 matching lines @@
     // If Oilpan is enabled, we detach of the context/global scope, with the final heap cleanup below sweeping it out.
     m_workerGlobalScope->notifyContextDestroyed();
 #if !ENABLE(OILPAN)
     ASSERT(m_workerGlobalScope->hasOneRef());
 #endif
     m_workerGlobalScope = nullptr;
 
     willDestroyIsolate();
     shutdownBackingThread();
     destroyIsolate();
+    gIsolates->erase(m_isolate);
     m_isolate = nullptr;
 
     m_microtaskRunner = nullptr;
 
     // Notify the proxy that the WorkerGlobalScope has been disposed of.
     // This can free this thread object, hence it must not be touched afterwards.
     workerReportingProxy().workerThreadTerminated();
 
     m_terminationEvent->signal();
 }
@@ skipping 204 matching lines @@
     // Keep waiting until execution is resumed.
     } while (task && m_pausedInDebugger);
     InspectorInstrumentation::didLeaveNestedRunLoop(m_workerGlobalScope.get());
 }
 
 void WorkerThread::stopRunningDebuggerTasksOnPause()
 {
     m_pausedInDebugger = false;
 }
 
+// static
+std::set<v8::Isolate*>* WorkerThread::workerThreadIsolates()
+{
+    return gIsolates;

[kinuko, 2016/04/11 09:30:40]

We seem to be accessing this set from multiple threads without locking?

[hong.zheng, 2016/04/15 06:05:57]

Done.

+}
+
 } // namespace blink