[Blink-Worker] WorkerThread fires idleHandler only at the end of processing all tasks.

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 27 matching lines @@
 #include "core/workers/WorkerThreadStartupData.h"
 #include "platform/PlatformThreadData.h"
 #include "platform/Task.h"
 #include "platform/ThreadTimers.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebWaitableEvent.h"
 #include "public/platform/WebWorkerRunLoop.h"
-#include "wtf/Noncopyable.h"
+#include "wtf/Atomics.h"
 #include "wtf/text/WTFString.h"
 
 #include <utility>
 
 namespace blink {
 
 namespace {
 const int64 kShortIdleHandlerDelayMs = 1000;
 const int64 kLongIdleHandlerDelayMs = 10*1000;
 
@@ skipping 112 matching lines @@
             m_sharedTimerFunction();
     }
 
     WorkerThread* m_workerThread;
     SharedTimerFunction m_sharedTimerFunction;
     double m_nextFireTime;
     bool m_running;
     WorkerThreadCancelableTask* m_lastQueuedTask;
 };
 
-class WorkerThreadTask : public blink::WebThread::Task {
-    WTF_MAKE_NONCOPYABLE(WorkerThreadTask); WTF_MAKE_FAST_ALLOCATED;
-public:
-    static PassOwnPtr<WorkerThreadTask> create(WorkerThread& workerThread, PassOwnPtr<ExecutionContextTask> task, bool isInstrumented)
-    {
-        return adoptPtr(new WorkerThreadTask(workerThread, task, isInstrumented));
-    }
+// WorkerThreadTask made private to WorkerThread
 
-    virtual ~WorkerThreadTask() { }
+PassOwnPtr<WorkerThread::WorkerThreadTask> WorkerThread::WorkerThreadTask::create(WorkerThread& workerThread
+    , PassOwnPtr<ExecutionContextTask> task, bool isInstrumented)
+{
+    return adoptPtr(new WorkerThreadTask(workerThread, task, isInstrumented));
+}
 
-    virtual void run() OVERRIDE
-    {
-        WorkerGlobalScope* workerGlobalScope = m_workerThread.workerGlobalScope();
-        // Tasks could be put on the message loop after the cleanup task,
-        // ensure none of those are ran.
-        if (!workerGlobalScope)
-            return;
+void WorkerThread::WorkerThreadTask::run()
+{
+    WorkerGlobalScope* workerGlobalScope = m_workerThread.workerGlobalScope();
+    // Tasks could be put on the message loop after the cleanup task,
+    // ensure none of those are ran.
+    if (!workerGlobalScope)
+        return;
 
-        if (m_isInstrumented)
-            InspectorInstrumentation::willPerformExecutionContextTask(workerGlobalScope, m_task.get());
-        if ((!workerGlobalScope->isClosing() && !m_workerThread.terminated()) || m_task->isCleanupTask())
+    if (m_isInstrumented)
+        InspectorInstrumentation::willPerformExecutionContextTask(workerGlobalScope, m_task.get());
+    if ((!workerGlobalScope->isClosing() && !m_workerThread.terminated()) || m_task->isCleanupTask())
+        if (!m_isIdleHandlerTask || (m_isIdleHandlerTask && !m_workerThread.taskCount())) {
             m_task->performTask(workerGlobalScope);
-        if (m_isInstrumented)
-            InspectorInstrumentation::didPerformExecutionContextTask(workerGlobalScope);
-    }
+        }
+    if (m_isInstrumented)
+        InspectorInstrumentation::didPerformExecutionContextTask(workerGlobalScope);
 
-private:
-    WorkerThreadTask(WorkerThread& workerThread, PassOwnPtr<ExecutionContextTask> task, bool isInstrumented)
-        : m_workerThread(workerThread)
-        , m_task(task)
-        , m_isInstrumented(isInstrumented)
-    {
-        if (m_isInstrumented)
-            m_isInstrumented = !m_task->taskNameForInstrumentation().isEmpty();
-        if (m_isInstrumented)
-            InspectorInstrumentation::didPostExecutionContextTask(m_workerThread.workerGlobalScope(), m_task.get());
-    }
+    // If no more tasks are queued up after this, then queue up the idleHandler
+    // to trigger GC.
+    if (!m_isIdleHandlerTask && !m_workerThread.decrementAndReturnTaskCount()
+        && !m_workerThread.m_IdleHandlerTaskPosted)

[jochen (gone - plz use gerrit), 2014/10/14 13:46:03]

nit. put on previous line

+        m_workerThread.queueUpIdleHandlerNow(kLongIdleHandlerDelayMs);
+}
 
-    WorkerThread& m_workerThread;
-    OwnPtr<ExecutionContextTask> m_task;
-    bool m_isInstrumented;
-};
+WorkerThread::WorkerThreadTask::WorkerThreadTask(WorkerThread& workerThread
+    , PassOwnPtr<ExecutionContextTask> task, bool isInstrumented)
+    : m_workerThread(workerThread)
+    , m_task(task)
+    , m_isInstrumented(isInstrumented)
+    , m_isIdleHandlerTask(false)
+{
+    if (m_isInstrumented)
+        m_isInstrumented = !m_task->taskNameForInstrumentation().isEmpty();
+    if (m_isInstrumented)
+        InspectorInstrumentation::didPostExecutionContextTask(m_workerThread.workerGlobalScope(), m_task.get());
+}
 
 class RunDebuggerQueueTask FINAL : public ExecutionContextTask {
 public:
     static PassOwnPtr<RunDebuggerQueueTask> create(WorkerThread* thread)
     {
         return adoptPtr(new RunDebuggerQueueTask(thread));
     }
     virtual void performTask(ExecutionContext* context) OVERRIDE
     {
         ASSERT(context->isWorkerGlobalScope());
         m_thread->runDebuggerTask(WorkerThread::DontWaitForMessage);
     }
 
 private:
     explicit RunDebuggerQueueTask(WorkerThread* thread) : m_thread(thread) { }
 
     WorkerThread* m_thread;
 };
 
 WorkerThread::WorkerThread(WorkerLoaderProxy& workerLoaderProxy, WorkerReportingProxy& workerReportingProxy, PassOwnPtrWillBeRawPtr<WorkerThreadStartupData> startupData)
     : m_terminated(false)
     , m_workerLoaderProxy(workerLoaderProxy)
     , m_workerReportingProxy(workerReportingProxy)
     , m_startupData(startupData)
     , m_shutdownEvent(adoptPtr(blink::Platform::current()->createWaitableEvent()))
     , m_terminationEvent(adoptPtr(blink::Platform::current()->createWaitableEvent()))
+    , m_IdleHandlerTaskPosted(false)
+    , m_tasksCount(0)
 {
     MutexLocker lock(threadSetMutex());
     workerThreads().add(this);
 }
 
 WorkerThread::~WorkerThread()
 {
     MutexLocker lock(threadSetMutex());
     ASSERT(workerThreads().contains(this));
     workerThreads().remove(this);
@@ skipping 55 matching lines @@
     // Notify proxy that a new WorkerGlobalScope has been created and started.
     m_workerReportingProxy.workerGlobalScopeStarted(m_workerGlobalScope.get());
 
     WorkerScriptController* script = m_workerGlobalScope->script();
     if (!script->isExecutionForbidden())
         script->initializeContextIfNeeded();
     InspectorInstrumentation::willEvaluateWorkerScript(workerGlobalScope(), startMode);
     script->evaluate(ScriptSourceCode(sourceCode, scriptURL));
 
     postInitialize();
-
-    postDelayedTask(createSameThreadTask(&WorkerThread::idleHandler, this), kShortIdleHandlerDelayMs);
 }
 
 void WorkerThread::cleanup()
 {
 
     // This should be called before we start the shutdown procedure.
     workerReportingProxy().willDestroyWorkerGlobalScope();
 
     // The below assignment will destroy the context, which will in turn notify messaging proxy.
     // We cannot let any objects survive past thread exit, because no other thread will run GC or otherwise destroy them.
@@ skipping 116 matching lines @@
 
     for (HashSet<WorkerThread*>::iterator itr = threads.begin(); itr != threads.end(); ++itr)
         (*itr)->terminationEvent()->wait();
 }
 
 bool WorkerThread::isCurrentThread() const
 {
     return m_thread && m_thread->isCurrentThread();
 }
 
+void WorkerThread::queueUpIdleHandlerNow(long long delayMs)
+{
+    OwnPtr<WorkerThreadTask> idleHandlerTask = WorkerThreadTask::create(*this,

[jochen (gone - plz use gerrit), 2014/10/14 13:46:03]

nit, put on one line

[Mayur Kankanwadi, 2014/11/04 06:36:58]

Done.

+        createSameThreadTask(&WorkerThread::idleHandler, this), true);
+    idleHandlerTask.get()->setIsIdleHandlerTask(true);

[jochen (gone - plz use gerrit), 2014/10/14 13:46:03]

should work without get()

[Mayur Kankanwadi, 2014/11/04 06:36:58]

Done.

+    m_thread->postDelayedTask(idleHandlerTask.leakPtr(), delayMs);
+    m_IdleHandlerTaskPosted = true;
+}
+
 void WorkerThread::idleHandler()
 {
     ASSERT(m_workerGlobalScope.get());
     int64 delay = kLongIdleHandlerDelayMs;
 
+    // Some tasks may have been started in the mean time, so lets return back
+    // and wait for the next idleHandler to be fired.
+    if (m_tasksCount) {
+        m_IdleHandlerTaskPosted = false;

[jochen (gone - plz use gerrit), 2014/10/14 13:46:03]

nit. move this up outside the if() 

[Mayur Kankanwadi, 2014/11/04 06:36:58]

Done.

+        return;
+    }
     // Do a script engine idle notification if the next event is distant enough.
     const double kMinIdleTimespan = 0.3;
+    // This is set to true when idleNotification returns false.
+    // idleNotification returns false only when more GC is required. It returns
+    // true if no more GC is required and that is when callGCAgain will be set to false.
+    bool callGCAgain = false;
     if (m_sharedTimer->nextFireTime() == 0.0 || m_sharedTimer->nextFireTime() > currentTime() + kMinIdleTimespan) {
-        bool hasMoreWork = !m_workerGlobalScope->idleNotification();
-        if (hasMoreWork)
+        callGCAgain = !m_workerGlobalScope->idleNotification();
+        if (callGCAgain)
             delay = kShortIdleHandlerDelayMs;
     }
+    if (callGCAgain)
+        queueUpIdleHandlerNow(delay);

[jochen (gone - plz use gerrit), 2014/10/14 13:46:03]

should be 0

+    else
+        m_IdleHandlerTaskPosted = false;

[jochen (gone - plz use gerrit), 2014/10/14 13:46:03]

not needed anymore after the one above is mvoed

[Mayur Kankanwadi, 2014/11/04 06:36:58]

Done.

+}
 
-    postDelayedTask(createSameThreadTask(&WorkerThread::idleHandler, this), delay);
+int WorkerThread::decrementAndReturnTaskCount()
+{
+    atomicDecrement(&m_tasksCount);
+    return m_tasksCount;
 }
 
 void WorkerThread::postTask(PassOwnPtr<ExecutionContextTask> task)
 {
+    atomicIncrement(&m_tasksCount);
     m_thread->postTask(WorkerThreadTask::create(*this, task, true).leakPtr());
 }
 
 void WorkerThread::postDelayedTask(PassOwnPtr<ExecutionContextTask> task, long long delayMs)
 {
+    atomicIncrement(&m_tasksCount);
     m_thread->postDelayedTask(WorkerThreadTask::create(*this, task, true).leakPtr(), delayMs);
 }
 
 void WorkerThread::postDebuggerTask(PassOwnPtr<ExecutionContextTask> task)
 {
     m_debuggerMessageQueue.append(WorkerThreadTask::create(*this, task, false));
     postTask(RunDebuggerQueueTask::create(this));
 }
 
 MessageQueueWaitResult WorkerThread::runDebuggerTask(WaitMode waitMode)
@@ skipping 28 matching lines @@
     InspectorInstrumentation::didLeaveNestedRunLoop(m_workerGlobalScope.get());
 }
 
 void WorkerThread::setWorkerInspectorController(WorkerInspectorController* workerInspectorController)
 {
     MutexLocker locker(m_workerInspectorControllerMutex);
     m_workerInspectorController = workerInspectorController;
 }
 
 } // namespace blink