Worker: Introduce per-global-scope task scheduler

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

 /*
  * 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 19 matching lines @@
 #include <memory>
 
 #include "core/CoreExport.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/workers/ParentFrameTaskRunners.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerThreadLifecycleObserver.h"
 #include "platform/LifecycleNotifier.h"
 #include "platform/WaitableEvent.h"
 #include "platform/WebTaskRunner.h"
+#include "platform/scheduler/child/global_scope_scheduler.h"
 #include "public/platform/WebThread.h"
 #include "v8/include/v8.h"
 #include "wtf/Forward.h"
 #include "wtf/Functional.h"
 #include "wtf/PassRefPtr.h"
 
 namespace blink {
 
 class ConsoleMessageStorage;
 class InspectorTaskRunner;
@@ skipping 35 matching lines @@
 //
 // WorkerThread start and termination must be initiated on the main thread and
 // an actual task is executed on the worker thread.
 //
 // When termination starts, (debugger) tasks on WorkerThread are handled as
 // follows:
 //  - A running task may finish unless a forcible termination task interrupts.
 //    If the running task is for debugger, it's guaranteed to finish without
 //    any interruptions.
 //  - Queued tasks never run.
-//  - postTask() and appendDebuggerTask() reject posting new tasks.
 class CORE_EXPORT WorkerThread : public WebThread::TaskObserver {
  public:
   // Represents how this thread is terminated. Used for UMA. Append only.
   enum class ExitCode {
     NotTerminated,
     GracefullyTerminated,
     SyncForciblyTerminated,
     AsyncForciblyTerminated,
     LastEnum,
   };
@@ skipping 24 matching lines @@
 
   WorkerLoaderProxy* workerLoaderProxy() const {
     RELEASE_ASSERT(m_workerLoaderProxy);
     return m_workerLoaderProxy.get();
   }
 
   WorkerReportingProxy& workerReportingProxy() const {
     return m_workerReportingProxy;
   }
 
-  void postTask(const WebTraceLocation&, std::unique_ptr<WTF::Closure>);
-  void postTask(const WebTraceLocation&,
-                std::unique_ptr<WTF::CrossThreadClosure>);
   void appendDebuggerTask(std::unique_ptr<CrossThreadClosure>);
 
   // Runs only debugger tasks while paused in debugger.
   void startRunningDebuggerTasksOnPauseOnWorkerThread();
   void stopRunningDebuggerTasksOnPauseOnWorkerThread();
 
   // Can be called only on the worker thread, WorkerOrWorkletGlobalScope
   // and WorkerInspectorController are not thread safe.
   WorkerOrWorkletGlobalScope* globalScope();
   WorkerInspectorController* workerInspectorController();
@@ skipping 16 matching lines @@
   PlatformThreadId platformThreadId();
 
   bool isForciblyTerminated();
 
   void waitForShutdownForTesting() { m_shutdownEvent->wait(); }
 
   ParentFrameTaskRunners* getParentFrameTaskRunners() const {
     return m_parentFrameTaskRunners.get();
   }
 
+  scheduler::GlobalScopeScheduler* globalScopeScheduler() const {
+    return m_globalScopeScheduler.get();
+  }
+
  protected:
   WorkerThread(PassRefPtr<WorkerLoaderProxy>, WorkerReportingProxy&);
 
   // Factory method for creating a new worker context for the thread.
   // Called on the worker thread.
   virtual WorkerOrWorkletGlobalScope* createWorkerGlobalScope(
       std::unique_ptr<WorkerThreadStartupData>) = 0;
 
   // Returns true when this WorkerThread owns the associated
   // WorkerBackingThread exclusively. If this function returns true, the
@@ skipping 47 matching lines @@
   // thread. This task is expected to run when the shutdown sequence does not
   // start in a certain time period because of an inifite loop in the JS
   // execution context etc. When the shutdown sequence is started before this
   // task runs, the task is simply cancelled.
   void mayForciblyTerminateExecution();
 
   // Forcibly terminates the worker execution. This must be called with
   // |m_threadStateMutex| acquired.
   void forciblyTerminateExecution(const MutexLocker&, ExitCode);
 
-  // Returns true if termination or shutdown sequence has started. This is
-  // thread safe.
-  // Note that this returns false when the sequence has already started but it
-  // hasn't been notified to the calling thread.
-  bool isInShutdown();
-
+  void initializeSchedulerOnWorkerThread(WaitableEvent*);
   void initializeOnWorkerThread(std::unique_ptr<WorkerThreadStartupData>);
   void prepareForShutdownOnWorkerThread();
   void performShutdownOnWorkerThread();
-  template <WTF::FunctionThreadAffinity threadAffinity>
-  void performTaskOnWorkerThread(
-      std::unique_ptr<Function<void(), threadAffinity>> task);
   void performDebuggerTaskOnWorkerThread(std::unique_ptr<CrossThreadClosure>);
   void performDebuggerTaskDontWaitOnWorkerThread();
 
   // These must be called with |m_threadStateMutex| acquired.
   void setThreadState(const MutexLocker&, ThreadState);
   void setExitCode(const MutexLocker&, ExitCode);
   bool isThreadStateMutexLocked(const MutexLocker&);
 
   // This internally acquires |m_threadStateMutex|. If you already have the
   // lock or you're on the main thread, you should consider directly accessing
@@ skipping 19 matching lines @@
 
   ThreadState m_threadState = ThreadState::NotStarted;
   ExitCode m_exitCode = ExitCode::NotTerminated;
 
   long long m_forcibleTerminationDelayInMs;
 
   std::unique_ptr<InspectorTaskRunner> m_inspectorTaskRunner;
 
   RefPtr<WorkerLoaderProxy> m_workerLoaderProxy;
   WorkerReportingProxy& m_workerReportingProxy;
+
   CrossThreadPersistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
 
+  // Per-global-scope scheduler. Tasks managed by this scheduler are canceled
+  // when the global scope is closed.
+  std::unique_ptr<scheduler::GlobalScopeScheduler> m_globalScopeScheduler;

[Sami, 2017/04/10 16:58:10]

Would it make sense to call this a WorkerScheduler instead (and merge with the
existing class with that name)? "Global scope" sounds, well, global, and makes
me wonder why there isn't one of these on the main thread too.

[nhiroki, 2017/04/11 10:47:54]

Current WorkerScheduler is a per-worker-thread object, while
GlobalScopeScheduler is a per-global-scope object[*], so IMO keeping them
separate would be simpler. If this is just an naming issue, how about renaming
it to something else, for example, WorkerOrWorkletGlobalScopeScheduler?

[*] For worklets, a worker thread can host multiple global scopes. See the
figure in this doc:
https://docs.google.com/document/d/1a0qQwfquxsPLFRmVfaySHic02ll-TaR50J7Va91cL...

[Sami, 2017/04/11 11:52:02]

Ah, I see. So you can have multiple global scopes on a single worker thread?
WorkerGlobalScopeScheduler would make it obvious why there isn't one on the main
thread (not sure if it's accurate however), but I'd be happy with
GlobalScopeScheduler too if you prefer.

[nhiroki, 2017/04/12 08:54:45]

Yes!
Sounds good. I renamed it to WorkerGlobalScopeScheduler.

Under core/workers/, GlobalScopeScheduler would be understandable because it is
a directory for worker components. On the other hand, under platform/scheduler/,
it may be confusing because the directory is not specific to workers. Therefore,
WorkerGlobalScopeScheduler would be better.

+
+  // Default task runner of the underlying thread. Tasks posted to this task
+  // runner will run even after the global scope is closed. This must be used
+  // only for control tasks.
+  RefPtr<WebTaskRunner> m_threadControlTaskRunner;

[kinuko, 2017/04/10 06:30:06]

It feels a little confusing to have this and workerBackingThread() separately.
Could we clean up further / merge these two concepts?

[nhiroki, 2017/04/11 10:47:54]

For now, I cannot come up with an idea to clean it up further or merge them, so
reverted this. I'll revisit this later.

+
   // This lock protects |m_globalScope|, |m_requestedToTerminate|,
   // |m_threadState|, |m_runningDebuggerTask| and |m_exitCode|.
   Mutex m_threadStateMutex;
 
   CrossThreadPersistent<ConsoleMessageStorage> m_consoleMessageStorage;
   CrossThreadPersistent<WorkerOrWorkletGlobalScope> m_globalScope;
   CrossThreadPersistent<WorkerInspectorController> m_workerInspectorController;
 
   // Signaled when the thread completes termination on the worker thread.
   std::unique_ptr<WaitableEvent> m_shutdownEvent;
 
   // Used to cancel a scheduled forcible termination task. See
   // mayForciblyTerminateExecution() for details.
   TaskHandle m_forcibleTerminationTaskHandle;
 
   // Created on the main thread heap, but will be accessed cross-thread
   // when worker thread posts tasks.
   CrossThreadPersistent<WorkerThreadLifecycleContext>
       m_workerThreadLifecycleContext;
 };
 
 }  // namespace blink
 
 #endif  // WorkerThread_h