Changeset 188329 in webkit


Ignore:
Timestamp:
Aug 11, 2015, 10:56:20 PM (10 years ago)
Author:
mark.lam@apple.com
Message:

Implementation JavaScript watchdog using WTF::WorkQueue.
​https://bugs.webkit.org/show_bug.cgi?id=147107

Reviewed by Geoffrey Garen.

Source/JavaScriptCore:

How the Watchdog works?
======================

  1. When do we start the Watchdog? ============================= The watchdog should only be started if both the following conditions are true:
    1. A time limit has been set.
    2. We have entered the VM.


  1. CPU time vs Wall Clock time =========================== Why do we need 2 time deadlines: m_cpuDeadline and m_wallClockDeadline?

The watchdog uses WorkQueue dispatchAfter() to queue a timer to measure the watchdog time
limit. WorkQueue timers measure time in monotonic wall clock time. m_wallClockDeadline
indicates the wall clock time point when the WorkQueue timer is expected to fire.

The time limit for which we allow JS code to run should be measured in CPU time, which can
differ from wall clock time. m_cpuDeadline indicates the CPU time point when the watchdog
should fire.

Note: the timer firing is not the same thing as the watchdog firing. When the timer fires,
we need to check if m_cpuDeadline has been reached.

If m_cpuDeadline has been reached, the watchdog is considered to have fired.

If not, then we have a remaining amount of CPU time, Tremainder, that we should allow JS
code to continue to run for. Hence, we need to start a new timer to fire again after
Tremainder microseconds.


See Watchdog::didFireSlow().

  1. Spurious wake ups ================= Because the WorkQueue timer cannot be cancelled, the watchdog needs to ignore stale timers. It does this by checking the m_wallClockDeadline. A wakeup that occurs right after m_wallClockDeadline expires is considered to be the wakeup for the active timer. All other wake ups are considered to be spurious and will be ignored.


See Watchdog::didFireSlow().


  1. Minimizing Timer creation cost ============================== Conceptually, we could start a new timer every time we start the watchdog. But we can do better than this.


In practice, the time limit of a watchdog tends to be long, and the amount of time a watchdog
stays active tends to be short for well-behaved JS code. The user also tends to re-use the same
time limit. Consider the following example:


|

t0 t1 t2 t3 t0 + L t2 + L

|<--- T1 --------------------->|

|<--- T2 --------------------->|

|<-- Td ->| |<-- Td ->|

  1. The user initializes the watchdog with time limit L.
  2. At t0, we enter the VM to execute JS code, and starts the watchdog timer, T1. The timer is set to expire at t0 + L.
  3. At t1, we exit the VM.
  4. At t2, we enter the VM again, and would like to start a new watchdog timer, T2.


However, we can note that the expiration time for T2 would be after the expiration time
of T1. Specifically, T2 would have expired at Td after T1 expires.


Hence, we can just wait for T1 to expire, and then start a new timer T2' at time t0 + L
for a period or Td instead.

Note that didFireSlow() already compensates for time differences between wall clock and CPU time,
as well as handle spurious wake ups (see note 2 and 3 above). As a result, didFireSlow() will
automatically take care of starting a new timer for the difference Td in the example above.
Instead of starting the new timer T2 and time t2, we just verify that if the active timer, T1's
expiration is less than T2s, then we are already covered by T1 and there's no need to start T2.

The benefit:

  1. we minimize the number of timer instances we have queued in the workqueue at the same time (ideally only 1 or 0), and use less peak memory usage.
  1. we minimize the frequency of instantiating timer instances. By waiting for the current active timer to expire first, on average, we get to start one timer per time limit (which is infrequent because time limits tend to be long) instead of one timer per VM entry (which tends to be frequent).

See Watchdog::startTimer().

  • API/JSContextRef.cpp:

(createWatchdogIfNeeded):
(JSContextGroupClearExecutionTimeLimit):

  • No need to create the watchdog (if not already created) just to clear it. If the watchdog is not created yet, then it is effectively cleared.
  • API/tests/ExecutionTimeLimitTest.cpp:

(currentCPUTimeAsJSFunctionCallback):
(testExecutionTimeLimit):
(currentCPUTime): Deleted.

  • API/tests/testapi.c:

(main):

  • JavaScriptCore.vcxproj/testapi/testapi.vcxproj:
  • JavaScriptCore.vcxproj/testapi/testapi.vcxproj.filters:
  • Enable watchdog tests for all platforms.
  • CMakeLists.txt:
  • JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
  • JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • Remove now unneeded WatchdogMac.cpp and WatchdogNone.cpp.
  • PlatformEfl.cmake:
  • dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::parseBlock):

  • dfg/DFGSpeculativeJIT32_64.cpp:
  • dfg/DFGSpeculativeJIT64.cpp:
  • interpreter/Interpreter.cpp:

(JSC::Interpreter::execute):
(JSC::Interpreter::executeCall):
(JSC::Interpreter::executeConstruct):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_loop_hint):
(JSC::JIT::emitSlow_op_loop_hint):

  • jit/JITOperations.cpp:
  • llint/LLIntOffsetsExtractor.cpp:
  • llint/LLIntSlowPaths.cpp:
  • runtime/VM.cpp:
  • #include Watchdog.h in these files directly instead of doing it via VM.h. These saves us from having to recompile the world when we change Watchdog.h.
  • runtime/VM.h:
  • See comment in Watchdog::startTimer() below for why the Watchdog needs to be thread-safe ref counted.
  • runtime/VMEntryScope.cpp:

(JSC::VMEntryScope::VMEntryScope):
(JSC::VMEntryScope::~VMEntryScope):

  • We have done away with the WatchdogScope and arming/disarming of the watchdog. Instead, the VMEntryScope will inform the watchdog of when we have entered and exited the VM.
  • runtime/Watchdog.cpp:

(JSC::currentWallClockTime):
(JSC::Watchdog::Watchdog):
(JSC::Watchdog::hasStartedTimer):
(JSC::Watchdog::setTimeLimit):
(JSC::Watchdog::didFireSlow):
(JSC::Watchdog::hasTimeLimit):
(JSC::Watchdog::fire):
(JSC::Watchdog::enteredVM):
(JSC::Watchdog::exitedVM):

(JSC::Watchdog::startTimer):

  • The Watchdog is now thread-safe ref counted because the WorkQueue may access it (from a different thread) even after the VM shuts down. We need to keep it alive until the WorkQueue callback completes.

In Watchdog::startTimer(), we'll ref the Watchdog to keep it alive for each
WorkQueue callback we dispatch. The callback will deref the Watchdog after it
is done with it. This ensures that the Watchdog is kept alive until all
WorkQueue callbacks are done.

(JSC::Watchdog::stopTimer):
(JSC::Watchdog::~Watchdog): Deleted.
(JSC::Watchdog::didFire): Deleted.
(JSC::Watchdog::isEnabled): Deleted.
(JSC::Watchdog::arm): Deleted.
(JSC::Watchdog::disarm): Deleted.
(JSC::Watchdog::startCountdownIfNeeded): Deleted.
(JSC::Watchdog::startCountdown): Deleted.
(JSC::Watchdog::stopCountdown): Deleted.

  • runtime/Watchdog.h:

(JSC::Watchdog::didFire):
(JSC::Watchdog::timerDidFireAddress):
(JSC::Watchdog::isArmed): Deleted.
(JSC::Watchdog::Scope::Scope): Deleted.
(JSC::Watchdog::Scope::~Scope): Deleted.

  • runtime/WatchdogMac.cpp:

(JSC::Watchdog::initTimer): Deleted.
(JSC::Watchdog::destroyTimer): Deleted.
(JSC::Watchdog::startTimer): Deleted.
(JSC::Watchdog::stopTimer): Deleted.

  • runtime/WatchdogNone.cpp:

(JSC::Watchdog::initTimer): Deleted.
(JSC::Watchdog::destroyTimer): Deleted.
(JSC::Watchdog::startTimer): Deleted.
(JSC::Watchdog::stopTimer): Deleted.

Source/WebCore:

No new tests because we're not introducing any behavior change to WebCore here.
We're only #include'ing Watchdog.h directly instead of going through VM.h.

  • ForwardingHeaders/runtime/Watchdog.h: Added.
  • PlatformEfl.cmake:
  • WebCore.vcxproj/WebCore.vcxproj:
  • WebCore.vcxproj/WebCore.vcxproj.filters:
  • bindings/js/JSEventListener.cpp:
  • bindings/js/WorkerScriptController.cpp:
Location:
trunk/Source
Files:
1 added
32 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/API/JSContextRef.cpp

    r187279 r188329  
    3838#include "SourceProvider.h"
    3939#include "StackVisitor.h"
     40#include "Watchdog.h"
    4041#include <wtf/text/StringBuilder.h>
    4142#include <wtf/text/StringHash.h>
    … …  
    9596{
    9697    if (!vm.watchdog) {
    97         vm.watchdog = std::make_unique<Watchdog>();
     98        vm.watchdog = adoptRef(new Watchdog());
    9899
    99100        // The LLINT peeks into the Watchdog object directly. In order to do that,
    … …  
    121122    VM& vm = *toJS(group);
    122123    JSLockHolder locker(&vm);
    123     createWatchdogIfNeeded(vm);
    124     Watchdog& watchdog = *vm.watchdog;
    125     watchdog.setTimeLimit(vm, std::chrono::microseconds::max());
     124    if (vm.watchdog)
     125        vm.watchdog->setTimeLimit(vm, Watchdog::noTimeLimit);
    126126}
    127127

  • trunk/Source/JavaScriptCore/API/tests/ExecutionTimeLimitTest.cpp

    r181914 r188329  
    2727#include "ExecutionTimeLimitTest.h"
    2828
    29 #if OS(DARWIN)
    30 
    3129#include "JSContextRefPrivate.h"
    3230#include "JavaScriptCore.h"
    33 
    34 #include <mach/mach.h>
    35 #include <mach/mach_time.h>
    36 #include <stdio.h>
    37 #include <sys/time.h>
     31#include <chrono>
     32#include <wtf/CurrentTime.h>
     33
     34using namespace std::chrono;
    3835
    3936static JSGlobalContextRef context = nullptr;
    40 
    41 static double currentCPUTime()
    42 {
    43     mach_msg_type_number_t infoCount = THREAD_BASIC_INFO_COUNT;
    44     thread_basic_info_data_t info;
    45    
    46     /* Get thread information */
    47     mach_port_t threadPort = mach_thread_self();
    48     thread_info(threadPort, THREAD_BASIC_INFO, (thread_info_t)(&info), &infoCount);
    49     mach_port_deallocate(mach_task_self(), threadPort);
    50    
    51     double time = info.user_time.seconds + info.user_time.microseconds / 1000000.;
    52     time += info.system_time.seconds + info.system_time.microseconds / 1000000.;
    53    
    54     return time;
    55 }
    5637
    5738static JSValueRef currentCPUTimeAsJSFunctionCallback(JSContextRef ctx, JSObjectRef functionObject, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
    … …  
    6445   
    6546    ASSERT(JSContextGetGlobalContext(ctx) == context);
    66     return JSValueMakeNumber(ctx, currentCPUTime());
     47    return JSValueMakeNumber(ctx, currentCPUTime().count() / 1000000.);
    6748}
    6849
    … …  
    121102        const char* loopForeverScript = "var startTime = currentCPUTime(); while (true) { if (currentCPUTime() - startTime > .150) break; } ";
    122103        JSStringRef script = JSStringCreateWithUTF8CString(loopForeverScript);
    123         double startTime;
    124         double endTime;
    125104        exception = nullptr;
    126105        shouldTerminateCallbackWasCalled = false;
    127         startTime = currentCPUTime();
    128         v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
    129         endTime = currentCPUTime();
    130        
    131         if (((endTime - startTime) < .150f) && shouldTerminateCallbackWasCalled)
     106        auto startTime = currentCPUTime();
     107        v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
     108        auto endTime = currentCPUTime();
     109       
     110        if (((endTime - startTime) < milliseconds(150)) && shouldTerminateCallbackWasCalled)
    132111            printf("PASS: script timed out as expected.\n");
    133112        else {
    134             if (!((endTime - startTime) < .150f))
     113            if (!((endTime - startTime) < milliseconds(150)))
    135114                printf("FAIL: script did not time out as expected.\n");
    136115            if (!shouldTerminateCallbackWasCalled)
    … …  
    150129        const char* loopForeverScript = "var startTime = currentCPUTime(); try { while (true) { if (currentCPUTime() - startTime > .150) break; } } catch(e) { }";
    151130        JSStringRef script = JSStringCreateWithUTF8CString(loopForeverScript);
    152         double startTime;
    153         double endTime;
    154131        exception = nullptr;
    155132        shouldTerminateCallbackWasCalled = false;
    156         startTime = currentCPUTime();
    157         v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
    158         endTime = currentCPUTime();
    159        
    160         if (((endTime - startTime) >= .150f) || !shouldTerminateCallbackWasCalled) {
    161             if (!((endTime - startTime) < .150f))
     133        auto startTime = currentCPUTime();
     134        v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
     135        auto endTime = currentCPUTime();
     136       
     137        if (((endTime - startTime) >= milliseconds(150)) || !shouldTerminateCallbackWasCalled) {
     138            if (!((endTime - startTime) < milliseconds(150)))
    162139                printf("FAIL: script did not time out as expected.\n");
    163140            if (!shouldTerminateCallbackWasCalled)
    … …  
    179156        const char* loopForeverScript = "var startTime = currentCPUTime(); while (true) { if (currentCPUTime() - startTime > .150) break; } ";
    180157        JSStringRef script = JSStringCreateWithUTF8CString(loopForeverScript);
    181         double startTime;
    182         double endTime;
    183         exception = nullptr;
    184         startTime = currentCPUTime();
    185         v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
    186         endTime = currentCPUTime();
    187        
    188         if (((endTime - startTime) < .150f) && shouldTerminateCallbackWasCalled)
     158        exception = nullptr;
     159        auto startTime = currentCPUTime();
     160        v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
     161        auto endTime = currentCPUTime();
     162       
     163        if (((endTime - startTime) < milliseconds(150)) && shouldTerminateCallbackWasCalled)
    189164            printf("PASS: script timed out as expected when no callback is specified.\n");
    190165        else {
    191             if (!((endTime - startTime) < .150f))
     166            if (!((endTime - startTime) < milliseconds(150)))
    192167                printf("FAIL: script did not time out as expected when no callback is specified.\n");
    193168            failed = true;
    … …  
    205180        const char* loopForeverScript = "var startTime = currentCPUTime(); while (true) { if (currentCPUTime() - startTime > .150) break; } ";
    206181        JSStringRef script = JSStringCreateWithUTF8CString(loopForeverScript);
    207         double startTime;
    208         double endTime;
    209         exception = nullptr;
    210         startTime = currentCPUTime();
    211         v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
    212         endTime = currentCPUTime();
    213        
    214         if (((endTime - startTime) >= .150f) && cancelTerminateCallbackWasCalled && !exception)
     182        exception = nullptr;
     183        auto startTime = currentCPUTime();
     184        v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
     185        auto endTime = currentCPUTime();
     186       
     187        if (((endTime - startTime) >= milliseconds(150)) && cancelTerminateCallbackWasCalled && !exception)
    215188            printf("PASS: script timeout was cancelled as expected.\n");
    216189        else {
    217             if (((endTime - startTime) < .150) || exception)
     190            if (((endTime - startTime) < milliseconds(150)) || exception)
    218191                printf("FAIL: script timeout was not cancelled.\n");
    219192            if (!cancelTerminateCallbackWasCalled)
    … …  
    233206        const char* loopForeverScript = "var startTime = currentCPUTime(); while (true) { if (currentCPUTime() - startTime > .500) break; } ";
    234207        JSStringRef script = JSStringCreateWithUTF8CString(loopForeverScript);
    235         double startTime;
    236         double endTime;
    237         double deltaTime;
    238         exception = nullptr;
    239         startTime = currentCPUTime();
    240         v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
    241         endTime = currentCPUTime();
    242         deltaTime = endTime - startTime;
    243        
    244         if ((deltaTime >= .300f) && (deltaTime < .500f) && (extendTerminateCallbackCalled == 2) && exception)
     208        exception = nullptr;
     209        auto startTime = currentCPUTime();
     210        v = JSEvaluateScript(context, script, nullptr, nullptr, 1, &exception);
     211        auto endTime = currentCPUTime();
     212        auto deltaTime = endTime - startTime;
     213       
     214        if ((deltaTime >= milliseconds(300)) && (deltaTime < milliseconds(500)) && (extendTerminateCallbackCalled == 2) && exception)
    245215            printf("PASS: script timeout was extended as expected.\n");
    246216        else {
    247             if (deltaTime < .200f)
     217            if (deltaTime < milliseconds(200))
    248218                printf("FAIL: script timeout was not extended as expected.\n");
    249             else if (deltaTime >= .500f)
     219            else if (deltaTime >= milliseconds(500))
    250220                printf("FAIL: script did not timeout.\n");
    251221           
    … …  
    265235    return failed;
    266236}
    267 
    268 #endif // OS(DARWIN)

  • trunk/Source/JavaScriptCore/API/tests/testapi.c

    r186966 r188329  
    4444#include "GlobalContextWithFinalizerTest.h"
    4545
    46 #if OS(DARWIN)
    4746#include "ExecutionTimeLimitTest.h"
    48 #endif
    4947
    5048#if JSC_OBJC_API_ENABLED
    … …  
    18941892    }
    18951893
    1896 #if OS(DARWIN)
    18971894    failed = testExecutionTimeLimit() || failed;
    1898 #endif /* OS(DARWIN) */
    18991895    failed = testGlobalContextWithFinalizer() || failed;
    19001896

  • trunk/Source/JavaScriptCore/CMakeLists.txt

    r188242 r188329  
    618618    runtime/VarOffset.cpp
    619619    runtime/Watchdog.cpp
    620     runtime/WatchdogNone.cpp
    621620    runtime/WeakMapConstructor.cpp
    622621    runtime/WeakMapData.cpp

  • trunk/Source/JavaScriptCore/ChangeLog

    r188323 r188329  
     12015-08-11  Mark Lam  <mark.lam@apple.com>
     2
     3        Implementation JavaScript watchdog using WTF::WorkQueue.
     4        https://bugs.webkit.org/show_bug.cgi?id=147107
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        How the Watchdog works?
     9        ======================
     10
     11        1. When do we start the Watchdog?
     12           =============================
     13           The watchdog should only be started if both the following conditions are true:
     14           1. A time limit has been set.
     15           2. We have entered the VM.
     16 
     17        2. CPU time vs Wall Clock time
     18           ===========================
     19           Why do we need 2 time deadlines: m_cpuDeadline and m_wallClockDeadline?
     20
     21           The watchdog uses WorkQueue dispatchAfter() to queue a timer to measure the watchdog time
     22           limit. WorkQueue timers measure time in monotonic wall clock time. m_wallClockDeadline
     23           indicates the wall clock time point when the WorkQueue timer is expected to fire.
     24
     25           The time limit for which we allow JS code to run should be measured in CPU time, which can
     26           differ from wall clock time.  m_cpuDeadline indicates the CPU time point when the watchdog
     27           should fire.
     28
     29           Note: the timer firing is not the same thing as the watchdog firing.  When the timer fires,
     30           we need to check if m_cpuDeadline has been reached.
     31
     32           If m_cpuDeadline has been reached, the watchdog is considered to have fired.
     33
     34           If not, then we have a remaining amount of CPU time, Tremainder, that we should allow JS
     35           code to continue to run for.  Hence, we need to start a new timer to fire again after
     36           Tremainder microseconds.
     37   
     38           See Watchdog::didFireSlow().
     39
     40        3. Spurious wake ups
     41           =================
     42           Because the WorkQueue timer cannot be cancelled, the watchdog needs to ignore stale timers.
     43           It does this by checking the m_wallClockDeadline.  A wakeup that occurs right after
     44           m_wallClockDeadline expires is considered to be the wakeup for the active timer.  All other
     45           wake ups are considered to be spurious and will be ignored.
     46 
     47           See Watchdog::didFireSlow().
     48 
     49        4. Minimizing Timer creation cost
     50           ==============================
     51           Conceptually, we could start a new timer every time we start the watchdog. But we can do better
     52           than this.
     53 
     54           In practice, the time limit of a watchdog tends to be long, and the amount of time a watchdog
     55           stays active tends to be short for well-behaved JS code. The user also tends to re-use the same
     56           time limit. Consider the following example:
     57 
     58               |---|-----|---|----------------|---------|
     59               t0  t1    t2  t3            t0 + L    t2 + L
     60
     61               |<--- T1 --------------------->|
     62                         |<--- T2 --------------------->|
     63               |<-- Td ->|                    |<-- Td ->|
     64
     65           1. The user initializes the watchdog with time limit L.
     66           2. At t0, we enter the VM to execute JS code, and starts the watchdog timer, T1.
     67              The timer is set to expire at t0 + L.
     68           3. At t1, we exit the VM.
     69           4. At t2, we enter the VM again, and would like to start a new watchdog timer, T2.
     70         
     71              However, we can note that the expiration time for T2 would be after the expiration time
     72              of T1. Specifically, T2 would have expired at Td after T1 expires.
     73         
     74              Hence, we can just wait for T1 to expire, and then start a new timer T2' at time t0 + L
     75              for a period or Td instead.
     76
     77           Note that didFireSlow() already compensates for time differences between wall clock and CPU time,
     78           as well as handle spurious wake ups (see note 2 and 3 above).  As a result, didFireSlow() will
     79           automatically take care of starting a new timer for the difference Td in the example above.
     80           Instead of starting the new timer T2 and time t2, we just verify that if the active timer, T1's
     81           expiration is less than T2s, then we are already covered by T1 and there's no need to start T2.
     82
     83           The benefit:
     84
     85           1. we minimize the number of timer instances we have queued in the workqueue at the same time
     86              (ideally only 1 or 0), and use less peak memory usage.
     87
     88           2. we minimize the frequency of instantiating timer instances. By waiting for the current
     89              active timer to expire first, on average, we get to start one timer per time limit
     90              (which is infrequent because time limits tend to be long) instead of one timer per
     91              VM entry (which tends to be frequent).
     92
     93           See Watchdog::startTimer().
     94
     95        * API/JSContextRef.cpp:
     96        (createWatchdogIfNeeded):
     97        (JSContextGroupClearExecutionTimeLimit):
     98        - No need to create the watchdog (if not already created) just to clear it.
     99          If the watchdog is not created yet, then it is effectively cleared.
     100
     101        * API/tests/ExecutionTimeLimitTest.cpp:
     102        (currentCPUTimeAsJSFunctionCallback):
     103        (testExecutionTimeLimit):
     104        (currentCPUTime): Deleted.
     105        * API/tests/testapi.c:
     106        (main):
     107        * JavaScriptCore.vcxproj/testapi/testapi.vcxproj:
     108        * JavaScriptCore.vcxproj/testapi/testapi.vcxproj.filters:
     109        - Enable watchdog tests for all platforms.
     110
     111        * CMakeLists.txt:
     112        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
     113        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
     114        * JavaScriptCore.xcodeproj/project.pbxproj:
     115        - Remove now unneeded WatchdogMac.cpp and WatchdogNone.cpp.
     116
     117        * PlatformEfl.cmake:
     118
     119        * dfg/DFGByteCodeParser.cpp:
     120        (JSC::DFG::ByteCodeParser::parseBlock):
     121        * dfg/DFGSpeculativeJIT32_64.cpp:
     122        * dfg/DFGSpeculativeJIT64.cpp:
     123        * interpreter/Interpreter.cpp:
     124        (JSC::Interpreter::execute):
     125        (JSC::Interpreter::executeCall):
     126        (JSC::Interpreter::executeConstruct):
     127        * jit/JITOpcodes.cpp:
     128        (JSC::JIT::emit_op_loop_hint):
     129        (JSC::JIT::emitSlow_op_loop_hint):
     130        * jit/JITOperations.cpp:
     131        * llint/LLIntOffsetsExtractor.cpp:
     132        * llint/LLIntSlowPaths.cpp:
     133        * runtime/VM.cpp:
     134        - #include Watchdog.h in these files directly instead of doing it via VM.h.
     135          These saves us from having to recompile the world when we change Watchdog.h.
     136
     137        * runtime/VM.h:
     138        - See comment in Watchdog::startTimer() below for why the Watchdog needs to be
     139          thread-safe ref counted.
     140
     141        * runtime/VMEntryScope.cpp:
     142        (JSC::VMEntryScope::VMEntryScope):
     143        (JSC::VMEntryScope::~VMEntryScope):
     144        - We have done away with the WatchdogScope and arming/disarming of the watchdog.
     145          Instead, the VMEntryScope will inform the watchdog of when we have entered and
     146          exited the VM.
     147
     148        * runtime/Watchdog.cpp:
     149        (JSC::currentWallClockTime):
     150        (JSC::Watchdog::Watchdog):
     151        (JSC::Watchdog::hasStartedTimer):
     152        (JSC::Watchdog::setTimeLimit):
     153        (JSC::Watchdog::didFireSlow):
     154        (JSC::Watchdog::hasTimeLimit):
     155        (JSC::Watchdog::fire):
     156        (JSC::Watchdog::enteredVM):
     157        (JSC::Watchdog::exitedVM):
     158
     159        (JSC::Watchdog::startTimer):
     160        - The Watchdog is now thread-safe ref counted because the WorkQueue may access it
     161          (from a different thread) even after the VM shuts down.  We need to keep it
     162          alive until the WorkQueue callback completes.
     163
     164          In Watchdog::startTimer(), we'll ref the Watchdog to keep it alive for each
     165          WorkQueue callback we dispatch.  The callback will deref the Watchdog after it
     166          is done with it.  This ensures that the Watchdog is kept alive until all
     167          WorkQueue callbacks are done.
     168
     169        (JSC::Watchdog::stopTimer):
     170        (JSC::Watchdog::~Watchdog): Deleted.
     171        (JSC::Watchdog::didFire): Deleted.
     172        (JSC::Watchdog::isEnabled): Deleted.
     173        (JSC::Watchdog::arm): Deleted.
     174        (JSC::Watchdog::disarm): Deleted.
     175        (JSC::Watchdog::startCountdownIfNeeded): Deleted.
     176        (JSC::Watchdog::startCountdown): Deleted.
     177        (JSC::Watchdog::stopCountdown): Deleted.
     178        * runtime/Watchdog.h:
     179        (JSC::Watchdog::didFire):
     180        (JSC::Watchdog::timerDidFireAddress):
     181        (JSC::Watchdog::isArmed): Deleted.
     182        (JSC::Watchdog::Scope::Scope): Deleted.
     183        (JSC::Watchdog::Scope::~Scope): Deleted.
     184        * runtime/WatchdogMac.cpp:
     185        (JSC::Watchdog::initTimer): Deleted.
     186        (JSC::Watchdog::destroyTimer): Deleted.
     187        (JSC::Watchdog::startTimer): Deleted.
     188        (JSC::Watchdog::stopTimer): Deleted.
     189        * runtime/WatchdogNone.cpp:
     190        (JSC::Watchdog::initTimer): Deleted.
     191        (JSC::Watchdog::destroyTimer): Deleted.
     192        (JSC::Watchdog::startTimer): Deleted.
     193        (JSC::Watchdog::stopTimer): Deleted.
     194
    11952015-08-11  Filip Pizlo  <fpizlo@apple.com>
    2196

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj

    r188291 r188329  
    871871    <ClCompile Include="..\runtime\VarOffset.cpp" />
    872872    <ClCompile Include="..\runtime\Watchdog.cpp" />
    873     <ClCompile Include="..\runtime\WatchdogNone.cpp" />
    874873    <ClCompile Include="..\runtime\WeakMapConstructor.cpp" />
    875874    <ClCompile Include="..\runtime\WeakMapData.cpp" />

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters

    r188268 r188329  
    937937      <Filter>runtime</Filter>
    938938    </ClCompile>
    939     <ClCompile Include="..\runtime\WatchdogNone.cpp">
    940       <Filter>runtime</Filter>
    941     </ClCompile>
    942939    <ClCompile Include="..\tools\CodeProfile.cpp">
    943940      <Filter>tools</Filter>

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/testapi/testapi.vcxproj

    r188291 r188329  
    298298    <ClCompile Include="..\..\API\tests\CustomGlobalObjectClassTest.c" />
    299299    <ClInclude Include="..\..\API\tests\CustomGlobalObjectClassTest.h" />
     300    <ClCompile Include="..\..\API\tests\ExecutionTimeLimitTest.cpp" />
     301    <ClInclude Include="..\..\API\tests\ExecutionTimeLimitTest.h" />
    300302    <ClCompile Include="..\..\API\tests\GlobalContextWithFinalizerTest.cpp" />
    301303    <ClInclude Include="..\..\API\tests\GlobalContextWithFinalizerTest.h" />

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/testapi/testapi.vcxproj.filters

    r181806 r188329  
    1313    <ClCompile Include="..\..\API\tests\CustomGlobalObjectClassTest.c" />
    1414    <ClInclude Include="..\..\API\tests\CustomGlobalObjectClassTest.h" />
     15    <ClCompile Include="..\..\API\tests\ExecutionTimeLimitTest.cpp" />
     16    <ClInclude Include="..\..\API\tests\ExecutionTimeLimitTest.h" />
    1517    <ClCompile Include="..\..\API\tests\GlobalContextWithFinalizerTest.cpp" />
    1618    <ClInclude Include="..\..\API\tests\GlobalContextWithFinalizerTest.h" />

  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r188242 r188329  
    17291729                FED94F2E171E3E2300BE77A4 /* Watchdog.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FED94F2B171E3E2300BE77A4 /* Watchdog.cpp */; };
    17301730                FED94F2F171E3E2300BE77A4 /* Watchdog.h in Headers */ = {isa = PBXBuildFile; fileRef = FED94F2C171E3E2300BE77A4 /* Watchdog.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1731                 FED94F30171E3E2300BE77A4 /* WatchdogMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FED94F2D171E3E2300BE77A4 /* WatchdogMac.cpp */; };
    17321731                FEF040511AAE662D00BD28B0 /* CompareAndSwapTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEF040501AAE662D00BD28B0 /* CompareAndSwapTest.cpp */; };
    17331732                FEF6835E174343CC00A32E25 /* JITStubsARM.h in Headers */ = {isa = PBXBuildFile; fileRef = FEF6835A174343CC00A32E25 /* JITStubsARM.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    35883587                FED94F2B171E3E2300BE77A4 /* Watchdog.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Watchdog.cpp; sourceTree = "<group>"; };
    35893588                FED94F2C171E3E2300BE77A4 /* Watchdog.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Watchdog.h; sourceTree = "<group>"; };
    3590                 FED94F2D171E3E2300BE77A4 /* WatchdogMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WatchdogMac.cpp; sourceTree = "<group>"; };
    35913589                FEF040501AAE662D00BD28B0 /* CompareAndSwapTest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CompareAndSwapTest.cpp; path = API/tests/CompareAndSwapTest.cpp; sourceTree = "<group>"; };
    35923590                FEF040521AAEC4ED00BD28B0 /* CompareAndSwapTest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CompareAndSwapTest.h; path = API/tests/CompareAndSwapTest.h; sourceTree = "<group>"; };
    … …  
    49214919                                FED94F2B171E3E2300BE77A4 /* Watchdog.cpp */,
    49224920                                FED94F2C171E3E2300BE77A4 /* Watchdog.h */,
    4923                                 FED94F2D171E3E2300BE77A4 /* WatchdogMac.cpp */,
    49244921                                14BFCE6810CDB1FC00364CCE /* WeakGCMap.h */,
    49254922                                AD86A93D1AA4D87C002FE77F /* WeakGCMapInlines.h */,
    … …  
    78347831                                FE5932A7183C5A2600A1ECCC /* VMEntryScope.cpp in Sources */,
    78357832                                FED94F2E171E3E2300BE77A4 /* Watchdog.cpp in Sources */,
    7836                                 FED94F30171E3E2300BE77A4 /* WatchdogMac.cpp in Sources */,
    78377833                                7B98D1361B60CD5F0023B1A4 /* JSWASMModule.cpp in Sources */,
    78387834                                0F919D2515853CE0004A4E7D /* Watchpoint.cpp in Sources */,

  • trunk/Source/JavaScriptCore/PlatformEfl.cmake

    r181681 r188329  
    33    ${EINA_INCLUDE_DIRS}
    44    ${EO_INCLUDE_DIRS}
     5    "${WTF_DIR}/wtf/efl"
    56)
    67add_definitions(-DSTATICALLY_LINKED_WITH_WTF)

  • trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp

    r188299 r188329  
    4646#include "StackAlignment.h"
    4747#include "StringConstructor.h"
     48#include "Watchdog.h"
    4849#include <wtf/CommaPrinter.h>
    4950#include <wtf/HashMap.h>
    … …  
    40314032            addToGraph(LoopHint);
    40324033           
    4033             if (m_vm->watchdog && m_vm->watchdog->isEnabled())
     4034            if (m_vm->watchdog && m_vm->watchdog->hasTimeLimit())
    40344035                addToGraph(CheckWatchdogTimer);
    40354036           

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp

    r188299 r188329  
    4545#include "SetupVarargsFrame.h"
    4646#include "TypeProfilerLog.h"
     47#include "Watchdog.h"
    4748
    4849namespace JSC { namespace DFG {

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

    r188299 r188329  
    4545#include "SpillRegistersMode.h"
    4646#include "TypeProfilerLog.h"
     47#include "Watchdog.h"
    4748
    4849namespace JSC { namespace DFG {

  • trunk/Source/JavaScriptCore/interpreter/Interpreter.cpp

    r188136 r188329  
    7272#include "VMEntryScope.h"
    7373#include "VirtualRegister.h"
     74#include "Watchdog.h"
    7475
    7576#include <limits.h>
    … …  
    881882    {
    882883        SamplingTool::CallRecord callRecord(m_sampler.get());
    883         Watchdog::Scope watchdogScope(vm.watchdog.get());
    884 
    885884        result = program->generatedJITCode()->execute(&vm, &protoCallFrame);
    886885    }
    … …  
    943942    {
    944943        SamplingTool::CallRecord callRecord(m_sampler.get(), !isJSCall);
    945         Watchdog::Scope watchdogScope(vm.watchdog.get());
    946944
    947945        // Execute the code:
    … …  
    10141012    {
    10151013        SamplingTool::CallRecord callRecord(m_sampler.get(), !isJSConstruct);
    1016         Watchdog::Scope watchdogScope(vm.watchdog.get());
    10171014
    10181015        // Execute the code.
    … …  
    10831080    {
    10841081        SamplingTool::CallRecord callRecord(m_sampler.get());
    1085         Watchdog::Scope watchdogScope(vm.watchdog.get());
    1086 
    10871082        result = closure.functionExecutable->generatedJITCodeForCall()->execute(&vm, closure.protoCallFrame);
    10881083    }
    … …  
    11741169    {
    11751170        SamplingTool::CallRecord callRecord(m_sampler.get());
    1176         Watchdog::Scope watchdogScope(vm.watchdog.get());
    1177 
    11781171        result = eval->generatedJITCode()->execute(&vm, &protoCallFrame);
    11791172    }

  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r188299 r188329  
    4646#include "TypeProfilerLog.h"
    4747#include "VirtualRegister.h"
     48#include "Watchdog.h"
    4849
    4950namespace JSC {
    … …  
    906907
    907908    // Emit the watchdog timer check:
    908     if (m_vm->watchdog && m_vm->watchdog->isEnabled())
     909    if (m_vm->watchdog && m_vm->watchdog->hasTimeLimit())
    909910        addSlowCase(branchTest8(NonZero, AbsoluteAddress(m_vm->watchdog->timerDidFireAddress())));
    910911}
    … …  
    932933
    933934    // Emit the slow path of the watchdog timer check:
    934     if (m_vm->watchdog && m_vm->watchdog->isEnabled()) {
     935    if (m_vm->watchdog && m_vm->watchdog->hasTimeLimit()) {
    935936        linkSlowCase(iter);
    936937        callOperation(operationHandleWatchdogTimer);

  • trunk/Source/JavaScriptCore/jit/JITOperations.cpp

    r188299 r188329  
    5858#include "TestRunnerUtils.h"
    5959#include "TypeProfilerLog.h"
     60#include "Watchdog.h"
    6061#include <wtf/InlineASM.h>
    6162

  • trunk/Source/JavaScriptCore/llint/LLIntOffsetsExtractor.cpp

    r185259 r188329  
    5656#include "VMEntryRecord.h"
    5757#include "ValueProfile.h"
     58#include "Watchdog.h"
    5859#include <wtf/text/StringImpl.h>
    5960

  • trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

    r188136 r188329  
    5454#include "ProtoCallFrame.h"
    5555#include "StructureRareDataInlines.h"
     56#include "Watchdog.h"
    5657#include <wtf/StringPrintStream.h>
    5758

  • trunk/Source/JavaScriptCore/runtime/VM.cpp

    r187969 r188329  
    8686#include "TypeProfilerLog.h"
    8787#include "UnlinkedCodeBlock.h"
     88#include "Watchdog.h"
    8889#include "WeakGCMapInlines.h"
    8990#include "WeakMapData.h"

  • trunk/Source/JavaScriptCore/runtime/VM.h

    r187780 r188329  
    5151#include "TypedArrayController.h"
    5252#include "VMEntryRecord.h"
    53 #include "Watchdog.h"
    5453#include "Watchpoint.h"
    5554#include "WeakRandom.h"
    … …  
    108107class VirtualRegister;
    109108class VMEntryScope;
     109class Watchdog;
    110110class Watchpoint;
    111111class WatchpointSet;
    … …  
    260260    VMEntryFrame* topVMEntryFrame;
    261261    ExecState* topCallFrame;
    262     std::unique_ptr<Watchdog> watchdog;
     262    RefPtr<Watchdog> watchdog;
    263263
    264264    Strong<Structure> structureStructure;

  • trunk/Source/JavaScriptCore/runtime/VMEntryScope.cpp

    r185487 r188329  
    11/*
    2  * Copyright (C) 2013, 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013-2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3030#include "Options.h"
    3131#include "VM.h"
     32#include "Watchdog.h"
    3233#include <wtf/StackBounds.h>
    3334
    … …  
    4950        // observe time xone changes.
    5051        vm.resetDateCache();
     52
     53        if (vm.watchdog)
     54            vm.watchdog->enteredVM();
    5155    }
    5256
    … …  
    6468        return;
    6569
     70    if (m_vm.watchdog)
     71        m_vm.watchdog->exitedVM();
     72
    6673    m_vm.entryScope = nullptr;
    6774

  • trunk/Source/JavaScriptCore/runtime/Watchdog.cpp

    r188147 r188329  
    11/*
    2  * Copyright (C) 2013 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013, 2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3333namespace JSC {
    3434
    35 #define NO_LIMIT std::chrono::microseconds::max()
     35const std::chrono::microseconds Watchdog::noTimeLimit = std::chrono::microseconds::max();
     36
     37static std::chrono::microseconds currentWallClockTime()
     38{
     39    auto steadyTimeSinceEpoch = std::chrono::steady_clock::now().time_since_epoch();
     40    return std::chrono::duration_cast<std::chrono::microseconds>(steadyTimeSinceEpoch);
     41}
    3642
    3743Watchdog::Watchdog()
    3844    : m_timerDidFire(false)
    3945    , m_didFire(false)
    40     , m_timeoutPeriod(NO_LIMIT)
    41     , m_startCPUTime(0)
    42     , m_elapsedCPUTime(0)
    43     , m_reentryCount(0)
    44     , m_isStopped(true)
     46    , m_timeLimit(noTimeLimit)
     47    , m_cpuDeadline(noTimeLimit)
     48    , m_wallClockDeadline(noTimeLimit)
    4549    , m_callback(0)
    4650    , m_callbackData1(0)
    4751    , m_callbackData2(0)
    48 {
    49     initTimer();
    50 }
    51 
    52 Watchdog::~Watchdog()
    53 {
    54     ASSERT(!isArmed());
    55     stopCountdown();
    56     destroyTimer();
     52    , m_timerQueue(WorkQueue::create("jsc.watchdog.queue", WorkQueue::Type::Serial, WorkQueue::QOS::Utility))
     53{
     54    m_timerHandler = [this] {
     55        this->m_timerDidFire = true;
     56        this->deref();
     57    };
     58}
     59
     60inline bool Watchdog::hasStartedTimer()
     61{
     62    return m_cpuDeadline != noTimeLimit;
    5763}
    5864
    … …  
    6066    ShouldTerminateCallback callback, void* data1, void* data2)
    6167{
    62     bool wasEnabled = isEnabled();
    63 
    64     if (!m_isStopped)
    65         stopCountdown();
     68    bool hadTimeLimit = hasTimeLimit();
    6669
    6770    m_didFire = false; // Reset the watchdog.
    6871
    69     m_timeoutPeriod = limit;
     72    m_timeLimit = limit;
    7073    m_callback = callback;
    7174    m_callbackData1 = data1;
    7275    m_callbackData2 = data2;
    7376
    74     // If this is the first time that timeout is being enabled, then any
     77    // If this is the first time that time limit is being enabled, then any
    7578    // previously JIT compiled code will not have the needed polling checks.
    7679    // Hence, we need to flush all the pre-existing compiled code.
    7780    //
    78     // However, if the timeout is already enabled, and we're just changing the
    79     // timeout value, then any existing JITted code will have the appropriate
     81    // However, if the time limit is already enabled, and we're just changing the
     82    // time limit value, then any existing JITted code will have the appropriate
    8083    // polling checks. Hence, there is no need to re-do this flushing.
    81     if (!wasEnabled) {
     84    if (!hadTimeLimit) {
    8285        // And if we've previously compiled any functions, we need to revert
    8386        // them because they don't have the needed polling checks yet.
    … …  
    8588    }
    8689
    87     startCountdownIfNeeded();
    88 }
    89 
    90 bool Watchdog::didFire(ExecState* exec)
    91 {
    92     if (m_didFire)
    93         return true;
    94 
    95     if (!m_timerDidFire)
    96         return false;
     90    if (m_hasEnteredVM && hasTimeLimit())
     91        startTimer(m_timeLimit);
     92}
     93
     94bool Watchdog::didFireSlow(ExecState* exec)
     95{
     96    ASSERT(m_timerDidFire);
    9797    m_timerDidFire = false;
    98     stopCountdown();
    99 
    100     auto currentTime = currentCPUTime();
    101     auto deltaCPUTime = currentTime - m_startCPUTime;
    102     auto totalElapsedCPUTime = m_elapsedCPUTime + deltaCPUTime;
    103     if (totalElapsedCPUTime > m_timeoutPeriod) {
     98
     99    // A legitimate timer is the timer which woke up watchdog and can caused didFireSlow() to be
     100    // called after m_wallClockDeadline has expired. All other timers are considered to be stale,
     101    // and their wake ups are considered to be spurious and should be ignored.
     102    //
     103    // didFireSlow() will race against m_timerHandler to clear and set m_timerDidFire respectively.
     104    // We need to deal with a variety of scenarios where we can have stale timers and legitimate
     105    // timers firing in close proximity to each other.
     106    //
     107    // Consider the following scenarios:
     108    //
     109    // 1. A stale timer fires long before m_wallClockDeadline expires.
     110    //
     111    //    In this case, the m_wallClockDeadline check below will fail and the stale timer will be
     112    //    ignored as spurious. We just need to make sure that we clear m_timerDidFire before we
     113    //    check m_wallClockDeadline and return below.
     114    //
     115    // 2. A stale timer fires just before m_wallClockDeadline expires.
     116    //    Before the watchdog can gets to the clearing m_timerDidFire above, the legit timer also fires.
     117    //
     118    //    In this case, m_timerDidFire was set twice by the 2 timers, but we only clear need to clear
     119    //    it once. The m_wallClockDeadline below will pass and this invocation of didFireSlow() will
     120    //    be treated as the response to the legit timer. The spurious timer is effectively ignored.
     121    //
     122    // 3. A state timer fires just before m_wallClockDeadline expires.
     123    //    Right after the watchdog clears m_timerDidFire above, the legit timer also fires.
     124    //
     125    //    The fact that the legit timer fails means that the m_wallClockDeadline check will pass.
     126    //    As long as we clear m_timerDidFire before we do the check, we are safe. This is the same
     127    //    scenario as 2 above.
     128    //
     129    // 4. A stale timer fires just before m_wallClockDeadline expires.
     130    //    Right after we do the m_wallClockDeadline check below, the legit timer fires.
     131    //
     132    //    The fact that the legit timer fires after the m_wallClockDeadline check means that
     133    //    the m_wallClockDeadline check will have failed. This is the same scenario as 1 above.
     134    //
     135    // 5. A legit timer fires.
     136    //    A stale timer also fires before we clear m_timerDidFire above.
     137    //
     138    //    This is the same scenario as 2 above.
     139    //
     140    // 6. A legit timer fires.
     141    //    A stale timer fires right after we clear m_timerDidFire above.
     142    //
     143    //    In this case, the m_wallClockDeadline check will pass, and we fire the watchdog
     144    //    though m_timerDidFire remains set. This just means that didFireSlow() will be called again due
     145    //    to m_timerDidFire being set. The subsequent invocation of didFireSlow() will end up handling
     146    //    the stale timer and ignoring it. This is the same scenario as 1 above.
     147    //
     148    // 7. A legit timer fires.
     149    //    A stale timer fires right after we do the m_wallClockDeadline check.
     150    //
     151    //    This is the same as 6, which means it's the same as 1 above.
     152    //
     153    // In all these cases, we just need to ensure that we clear m_timerDidFire before we do the
     154    // m_wallClockDeadline check below. Hence, a storeLoad fence is needed to ensure that these 2
     155    // operations do not get re-ordered.
     156
     157    WTF::storeLoadFence();
     158
     159    if (currentWallClockTime() < m_wallClockDeadline)
     160        return false; // Just a stale timer firing. Nothing to do.
     161
     162    m_wallClockDeadline = noTimeLimit;
     163
     164    if (currentCPUTime() >= m_cpuDeadline) {
    104165        // Case 1: the allowed CPU time has elapsed.
    105166
    … …  
    113174        }
    114175
    115         // The m_callback may have set a new limit. So, we may need to restart
    116         // the countdown.
    117         startCountdownIfNeeded();
     176        // If we get here, then the callback above did not want to terminate execution. As a
     177        // result, the callback may have done one of the following:
     178        //   1. cleared the time limit (i.e. watchdog is disabled),
     179        //   2. set a new time limit via Watchdog::setTimeLimit(), or
     180        //   3. did nothing (i.e. allow another cycle of the current time limit).
     181        //
     182        // In the case of 1, we don't have to do anything.
     183        // In the case of 2, Watchdog::setTimeLimit() would already have started the timer.
     184        // In the case of 3, we need to re-start the timer here.
     185
     186        ASSERT(m_hasEnteredVM);
     187        if (hasTimeLimit() && !hasStartedTimer())
     188            startTimer(m_timeLimit);
    118189
    119190    } else {
    120191        // Case 2: the allowed CPU time has NOT elapsed.
    121 
    122         // Tell the timer to alarm us again when it thinks we've reached the
    123         // end of the allowed time.
    124         auto remainingCPUTime = m_timeoutPeriod - totalElapsedCPUTime;
    125         m_elapsedCPUTime = totalElapsedCPUTime;
    126         m_startCPUTime = currentTime;
    127         startCountdown(remainingCPUTime);
     192        auto remainingCPUTime = m_cpuDeadline - currentCPUTime();
     193        startTimer(remainingCPUTime);
    128194    }
    129195
    … …  
    131197}
    132198
    133 bool Watchdog::isEnabled()
    134 {
    135     return (m_timeoutPeriod != NO_LIMIT);
     199bool Watchdog::hasTimeLimit()
     200{
     201    return (m_timeLimit != noTimeLimit);
    136202}
    137203
    … …  
    141207}
    142208
    143 void Watchdog::arm()
    144 {
    145     m_reentryCount++;
    146     if (m_reentryCount == 1)
    147         startCountdownIfNeeded();
    148 }
    149 
    150 void Watchdog::disarm()
    151 {
    152     ASSERT(m_reentryCount > 0);
    153     if (m_reentryCount == 1)
    154         stopCountdown();
    155     m_reentryCount--;
    156 }
    157 
    158 void Watchdog::startCountdownIfNeeded()
    159 {
    160     if (!m_isStopped)
    161         return; // Already started.
    162 
    163     if (!isArmed())
    164         return; // Not executing JS script. No need to start.
    165 
    166     if (isEnabled()) {
    167         m_elapsedCPUTime = std::chrono::microseconds::zero();
    168         m_startCPUTime = currentCPUTime();
    169         startCountdown(m_timeoutPeriod);
     209void Watchdog::enteredVM()
     210{
     211    m_hasEnteredVM = true;
     212    if (hasTimeLimit())
     213        startTimer(m_timeLimit);
     214}
     215
     216void Watchdog::exitedVM()
     217{
     218    ASSERT(m_hasEnteredVM);
     219    stopTimer();
     220    m_hasEnteredVM = false;
     221}
     222
     223void Watchdog::startTimer(std::chrono::microseconds timeLimit)
     224{
     225    ASSERT(m_hasEnteredVM);
     226    ASSERT(hasTimeLimit());
     227
     228    m_cpuDeadline = currentCPUTime() + timeLimit;
     229    auto wallClockTime = currentWallClockTime();
     230    auto wallClockDeadline = wallClockTime + timeLimit;
     231
     232    if ((wallClockTime < m_wallClockDeadline)
     233        && (m_wallClockDeadline <= wallClockDeadline)) {
     234        return; // Wait for the current active timer to expire before starting a new one.
    170235    }
    171 }
    172 
    173 void Watchdog::startCountdown(std::chrono::microseconds limit)
    174 {
    175     ASSERT(m_isStopped);
    176     m_isStopped = false;
    177     startTimer(limit);
    178 }
    179 
    180 void Watchdog::stopCountdown()
    181 {
    182     if (m_isStopped)
    183         return;
    184     stopTimer();
    185     m_isStopped = true;
     236
     237    // Else, the current active timer won't fire soon enough. So, start a new timer.
     238    this->ref(); // m_timerHandler will deref to match later.
     239    m_wallClockDeadline = wallClockDeadline;
     240    m_timerDidFire = false;
     241
     242    // We clear m_timerDidFire because we're starting a new timer. However, we need to make sure
     243    // that the clearing occurs before the timer thread is started. Thereafter, only didFireSlow()
     244    // should clear m_timerDidFire (unless we start yet another timer). Hence, we need a storeStore
     245    // fence here to ensure these operations do not get re-ordered.
     246    WTF::storeStoreFence();
     247
     248    m_timerQueue->dispatchAfter(std::chrono::nanoseconds(timeLimit), m_timerHandler);
     249}
     250
     251void Watchdog::stopTimer()
     252{
     253    m_cpuDeadline = noTimeLimit;
    186254}
    187255

  • trunk/Source/JavaScriptCore/runtime/Watchdog.h

    r188147 r188329  
    11/*
    2  * Copyright (C) 2013 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013, 2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2727#define Watchdog_h
    2828
    29 #if OS(DARWIN)
    30 #include <dispatch/dispatch.h>   
    31 #endif
     29#include <mutex>
     30#include <wtf/Ref.h>
     31#include <wtf/ThreadSafeRefCounted.h>
     32#include <wtf/WorkQueue.h>
    3233
    3334namespace JSC {
    … …  
    3637class VM;
    3738
    38 class Watchdog {
     39class Watchdog : public WTF::ThreadSafeRefCounted<Watchdog> {
    3940    WTF_MAKE_FAST_ALLOCATED;
    4041public:
    … …  
    4243
    4344    Watchdog();
    44     ~Watchdog();
    4545
    4646    typedef bool (*ShouldTerminateCallback)(ExecState*, void* data1, void* data2);
    … …  
    4949    // This version of didFire() will check the elapsed CPU time and call the
    5050    // callback (if needed) to determine if the watchdog should fire.
    51     bool didFire(ExecState*);
     51    bool didFire(ExecState* exec)
     52    {
     53        if (m_didFire)
     54            return true;
     55        if (!m_timerDidFire)
     56            return false;
     57        return didFireSlow(exec);
     58    }
    5259
    53     bool isEnabled();
     60    bool hasTimeLimit();
     61    void enteredVM();
     62    void exitedVM();
    5463
    5564    // This version of didFire() is a more efficient version for when we want
    … …  
    6170    void* timerDidFireAddress() { return &m_timerDidFire; }
    6271
     72    static const std::chrono::microseconds noTimeLimit;
     73
    6374private:
    64     void arm();
    65     void disarm();
    66     void startCountdownIfNeeded();
    67     void startCountdown(std::chrono::microseconds limit);
    68     void stopCountdown();
    69     bool isArmed() { return !!m_reentryCount; }
    70 
    71     // Platform specific timer implementation:
    72     void initTimer();
    73     void destroyTimer();
    74     void startTimer(std::chrono::microseconds limit);
     75    void startTimer(std::chrono::microseconds timeLimit);
    7576    void stopTimer();
    7677
    77     // m_timerDidFire (above) indicates whether the timer fired. The Watchdog
     78    inline bool hasStartedTimer();
     79
     80    bool didFireSlow(ExecState*);
     81
     82    // m_timerDidFire indicates whether the timer fired. The Watchdog
    7883    // still needs to check if the allowed CPU time has elapsed. If so, then
    7984    // the Watchdog fires and m_didFire will be set.
    … …  
    8388    bool m_didFire;
    8489
    85     std::chrono::microseconds m_timeoutPeriod;
    86     std::chrono::microseconds m_startCPUTime;
    87     std::chrono::microseconds m_elapsedCPUTime;
     90    std::chrono::microseconds m_timeLimit;
    8891
    89     int m_reentryCount;
    90     bool m_isStopped;
     92    std::chrono::microseconds m_cpuDeadline;
     93    std::chrono::microseconds m_wallClockDeadline;
     94
     95    bool m_hasEnteredVM { false };
    9196
    9297    ShouldTerminateCallback m_callback;
    … …  
    9499    void* m_callbackData2;
    95100
    96 #if OS(DARWIN) && !PLATFORM(EFL) && !PLATFORM(GTK)
    97     dispatch_queue_t m_queue;
    98     dispatch_source_t m_timer;
    99 #endif
     101    Ref<WorkQueue> m_timerQueue;
     102    std::function<void ()> m_timerHandler;
    100103
    101     friend class Watchdog::Scope;
    102104    friend class LLIntOffsetsExtractor;
    103 };
    104 
    105 class Watchdog::Scope {
    106 public:
    107     Scope(Watchdog* watchdog)
    108         : m_watchdog(watchdog)
    109     {
    110         if (!watchdog)
    111             return;
    112         m_watchdog->arm();
    113     }
    114    
    115     ~Scope()
    116     {
    117         if (!m_watchdog)
    118             return;
    119         m_watchdog->disarm();
    120     }
    121 
    122 private:
    123     Watchdog* m_watchdog;
    124105};
    125106

  • trunk/Source/JavaScriptCore/runtime/WatchdogMac.cpp

    r176973 r188329  
    1 /*
    2  * Copyright (C) 2013 Apple Inc. All rights reserved.
    3  *
    4  * Redistribution and use in source and binary forms, with or without
    5  * modification, are permitted provided that the following conditions
    6  * are met:
    7  * 1. Redistributions of source code must retain the above copyright
    8  *    notice, this list of conditions and the following disclaimer.
    9  * 2. Redistributions in binary form must reproduce the above copyright
    10  *    notice, this list of conditions and the following disclaimer in the
    11  *    documentation and/or other materials provided with the distribution.
    12  *
    13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    24  */
    25 
    26 #include "config.h"
    27 #include "Watchdog.h"
    28 
    29 namespace JSC {
    30 
    31 void Watchdog::initTimer()
    32 {
    33     m_queue = 0;
    34     m_timer = 0;
    35 }
    36 
    37 void Watchdog::destroyTimer()
    38 {
    39     ASSERT(!m_timer);
    40     if (m_queue)
    41         dispatch_release(m_queue);
    42 }
    43 
    44 void Watchdog::startTimer(std::chrono::microseconds limit)
    45 {
    46     ASSERT(!m_timer);
    47     if (!m_queue)
    48         m_queue = dispatch_queue_create("jsc.watchdog.queue", 0);
    49     m_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, m_queue);
    50 
    51     dispatch_source_set_timer(m_timer,
    52         dispatch_time(DISPATCH_TIME_NOW, std::chrono::nanoseconds(limit).count()),
    53         DISPATCH_TIME_FOREVER, 0);
    54 
    55     dispatch_source_set_event_handler(m_timer, ^{
    56         m_timerDidFire = true;
    57     });
    58 
    59     dispatch_resume(m_timer);
    60 }
    61 
    62 void Watchdog::stopTimer()
    63 {
    64     ASSERT(m_queue);
    65     dispatch_sync(m_queue, ^{
    66         dispatch_source_cancel(m_timer);
    67     });
    68     dispatch_release(m_timer);
    69     m_timer = 0;
    70 }
    71 
    72 } // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/WatchdogNone.cpp

    r176973 r188329  
    1 /*
    2  * Copyright (C) 2013 Apple Inc. All rights reserved.
    3  *
    4  * Redistribution and use in source and binary forms, with or without
    5  * modification, are permitted provided that the following conditions
    6  * are met:
    7  * 1. Redistributions of source code must retain the above copyright
    8  *    notice, this list of conditions and the following disclaimer.
    9  * 2. Redistributions in binary form must reproduce the above copyright
    10  *    notice, this list of conditions and the following disclaimer in the
    11  *    documentation and/or other materials provided with the distribution.
    12  *
    13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    24  */
    25 
    26 #include "config.h"
    27 #include "Watchdog.h"
    28 
    29 namespace JSC {
    30 
    31 // This is a stub for platforms that have not implemented this functionality.
    32 // In this case, the platform timer here never fires.
    33 
    34 void Watchdog::initTimer()
    35 {
    36 }
    37 
    38 void Watchdog::destroyTimer()
    39 {
    40 }
    41 
    42 void Watchdog::startTimer(std::chrono::microseconds)
    43 {
    44 }
    45 
    46 void Watchdog::stopTimer()
    47 {
    48 }
    49 
    50 } // namespace JSC

  • trunk/Source/WebCore/ChangeLog

    r188324 r188329  
     12015-08-11  Mark Lam  <mark.lam@apple.com>
     2
     3        Implementation JavaScript watchdog using WTF::WorkQueue.
     4        https://bugs.webkit.org/show_bug.cgi?id=147107
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        No new tests because we're not introducing any behavior change to WebCore here.
     9        We're only #include'ing Watchdog.h directly instead of going through VM.h.
     10
     11        * ForwardingHeaders/runtime/Watchdog.h: Added.
     12        * PlatformEfl.cmake:
     13        * WebCore.vcxproj/WebCore.vcxproj:
     14        * WebCore.vcxproj/WebCore.vcxproj.filters:
     15        * bindings/js/JSEventListener.cpp:
     16        * bindings/js/WorkerScriptController.cpp:
     17
    1182015-08-11  Simon Fraser  <simon.fraser@apple.com>
    219

  • trunk/Source/WebCore/PlatformEfl.cmake

    r188126 r188329  
    2525    "${WEBCORE_DIR}/platform/text/efl"
    2626    "${WEBCORE_DIR}/plugins/efl"
     27    "${WTF_DIR}/wtf/efl"
    2728)
    2829

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

    r188291 r188329  
    2043720437    <ClInclude Include="..\ForwardingHeaders\runtime\StructureChain.h" />
    2043820438    <ClInclude Include="..\ForwardingHeaders\runtime\SymbolTable.h" />
     20439    <ClInclude Include="..\ForwardingHeaders\runtime\Watchdog.h" />
    2043920440    <ClInclude Include="..\ForwardingHeaders\runtime\WeakGCMap.h" />
    2044020441    <ClInclude Include="..\ForwardingHeaders\runtime\WriteBarrier.h" />

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters

    r188127 r188329  
    1219912199      <Filter>ForwardingHeaders\runtime</Filter>
    1220012200    </ClInclude>
     12201    <ClInclude Include="..\ForwardingHeaders\runtime\Watchdog.h">
     12202      <Filter>ForwardingHeaders\runtime</Filter>
     12203    </ClInclude>
    1220112204    <ClInclude Include="..\ForwardingHeaders\runtime\WeakGCMap.h">
    1220212205      <Filter>ForwardingHeaders\runtime</Filter>

  • trunk/Source/WebCore/bindings/js/JSEventListener.cpp

    r185608 r188329  
    3535#include <runtime/JSLock.h>
    3636#include <runtime/VMEntryScope.h>
     37#include <runtime/Watchdog.h>
    3738#include <wtf/Ref.h>
    3839#include <wtf/RefCountedLeakCounter.h>

  • trunk/Source/WebCore/bindings/js/WorkerScriptController.cpp

    r188002 r188329  
    4545#include <runtime/Error.h>
    4646#include <runtime/JSLock.h>
     47#include <runtime/Watchdog.h>
    4748
    4849using namespace JSC;
Note: See TracChangeset for help on using the changeset viewer.