Changeset 240441 in webkit


Ignore:
Timestamp:
Jan 24, 2019 10:30:24 AM (5 years ago)
Author:
youenn@apple.com
Message:

Use MonotonicTime in WorkerRunLoop
​https://bugs.webkit.org/show_bug.cgi?id=193417

Reviewed by Saam Barati.

Source/WebCore:

Condition is based on MonotonicTime so MessageQueue should also be based on MonotonicTime.
Ditto for WorkerRunLoop.
No easy way to test the change which should not be easily observable.

  • workers/WorkerRunLoop.cpp:

(WebCore::WorkerRunLoop::runInMode):

Source/WTF:

  • wtf/MessageQueue.h:

(WTF::MessageQueue<DataType>::waitForMessage):
(WTF::MessageQueue<DataType>::waitForMessageFilteredWithTimeout):

Location:
trunk/Source
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r240437 r240441  
     12019-01-24  Youenn Fablet  <youenn@apple.com>
     2
     3        Use MonotonicTime in WorkerRunLoop
     4        https://bugs.webkit.org/show_bug.cgi?id=193417
     5
     6        Reviewed by Saam Barati.
     7
     8        * wtf/MessageQueue.h:
     9        (WTF::MessageQueue<DataType>::waitForMessage):
     10        (WTF::MessageQueue<DataType>::waitForMessageFilteredWithTimeout):
     11
    1122019-01-24  Ross Kirsling  <ross.kirsling@sony.com>
    213

  • trunk/Source/WTF/wtf/MessageQueue.h

    r237099 r240441  
    3535#include <wtf/Deque.h>
    3636#include <wtf/Lock.h>
     37#include <wtf/MonotonicTime.h>
    3738#include <wtf/Noncopyable.h>
    38 #include <wtf/WallTime.h>
    3939
    4040namespace WTF {
    … …  
    6666        std::unique_ptr<DataType> tryGetMessageIgnoringKilled();
    6767        template<typename Predicate>
    68         std::unique_ptr<DataType> waitForMessageFilteredWithTimeout(MessageQueueWaitResult&, Predicate&&, WallTime absoluteTime);
     68        std::unique_ptr<DataType> waitForMessageFilteredWithTimeout(MessageQueueWaitResult&, Predicate&&, Seconds relativeTimeout);
    6969
    7070        template<typename Predicate>
    … …  
    129129    {
    130130        MessageQueueWaitResult exitReason;
    131         std::unique_ptr<DataType> result = waitForMessageFilteredWithTimeout(exitReason, [](const DataType&) { return true; }, WallTime::infinity());
     131        std::unique_ptr<DataType> result = waitForMessageFilteredWithTimeout(exitReason, [](const DataType&) { return true; }, Seconds::infinity());
    132132        ASSERT(exitReason == MessageQueueTerminated || exitReason == MessageQueueMessageReceived);
    133133        return result;
    … …  
    136136    template<typename DataType>
    137137    template<typename Predicate>
    138     inline auto MessageQueue<DataType>::waitForMessageFilteredWithTimeout(MessageQueueWaitResult& result, Predicate&& predicate, WallTime absoluteTime) -> std::unique_ptr<DataType>
     138    inline auto MessageQueue<DataType>::waitForMessageFilteredWithTimeout(MessageQueueWaitResult& result, Predicate&& predicate, Seconds relativeTimeout) -> std::unique_ptr<DataType>
    139139    {
    140140        LockHolder lock(m_mutex);
    141141        bool timedOut = false;
    142142
     143        MonotonicTime absoluteTimeout = MonotonicTime::now() + relativeTimeout;
    143144        auto found = m_queue.end();
    144145        while (!m_killed && !timedOut) {
    … …  
    150151                break;
    151152
    152             timedOut = !m_condition.waitUntil(m_mutex, absoluteTime);
    153         }
    154 
    155         ASSERT(!timedOut || absoluteTime != WallTime::infinity());
     153            timedOut = !m_condition.waitUntil(m_mutex, absoluteTimeout);
     154        }
     155
     156        ASSERT(!timedOut || absoluteTimeout != MonotonicTime::infinity());
    156157
    157158        if (m_killed) {

  • trunk/Source/WebCore/ChangeLog

    r240437 r240441  
     12019-01-24  Youenn Fablet  <youenn@apple.com>
     2
     3        Use MonotonicTime in WorkerRunLoop
     4        https://bugs.webkit.org/show_bug.cgi?id=193417
     5
     6        Reviewed by Saam Barati.
     7
     8        Condition is based on MonotonicTime so MessageQueue should also be based on MonotonicTime.
     9        Ditto for WorkerRunLoop.
     10        No easy way to test the change which should not be easily observable.
     11
     12        * workers/WorkerRunLoop.cpp:
     13        (WebCore::WorkerRunLoop::runInMode):
     14
    1152019-01-24  Ross Kirsling  <ross.kirsling@sony.com>
    216

  • trunk/Source/WebCore/workers/WorkerRunLoop.cpp

    r240042 r240441  
    5050public:
    5151    // SharedTimer interface.
    52     void setFiredFunction(WTF::Function<void()>&& function) override { m_sharedTimerFunction = WTFMove(function); }
    53     void setFireInterval(Seconds interval) override { m_nextFireTime = interval + WallTime::now(); }
    54     void stop() override { m_nextFireTime = WallTime(); }
     52    void setFiredFunction(WTF::Function<void()>&& function) final { m_sharedTimerFunction = WTFMove(function); }
     53    void setFireInterval(Seconds interval) final { m_nextFireTime = MonotonicTime::now() + interval; }
     54    void stop() final { m_nextFireTime = MonotonicTime { }; }
    5555
    5656    bool isActive() { return m_sharedTimerFunction && m_nextFireTime; }
    57     WallTime fireTime() { return m_nextFireTime; }
     57    Seconds fireTimeDelay() { return std::max(0_s, m_nextFireTime - MonotonicTime::now()); }
    5858    void fire() { m_sharedTimerFunction(); }
    5959
    6060private:
    6161    WTF::Function<void()> m_sharedTimerFunction;
    62     WallTime m_nextFireTime;
     62    MonotonicTime m_nextFireTime;
    6363};
    6464
    … …  
    177177#endif
    178178
    179     WallTime deadline = WallTime::infinity();
     179    Seconds timeoutDelay = Seconds::infinity();
    180180
    181181#if USE(CF)
    182182    CFAbsoluteTime nextCFRunLoopTimerFireDate = CFRunLoopGetNextTimerFireDate(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
    183183    double timeUntilNextCFRunLoopTimerInSeconds = nextCFRunLoopTimerFireDate - CFAbsoluteTimeGetCurrent();
    184     deadline = WallTime::now() + std::max(0_s, Seconds(timeUntilNextCFRunLoopTimerInSeconds));
    185 #endif
    186 
    187     WallTime absoluteTime;
    188     if (waitMode == WaitForMessage) {
    189         if (predicate.isDefaultMode() && m_sharedTimer->isActive())
    190             absoluteTime = std::min(deadline, m_sharedTimer->fireTime());
    191         else
    192             absoluteTime = deadline;
    193     }
     184    timeoutDelay = std::max(0_s, Seconds(timeUntilNextCFRunLoopTimerInSeconds));
     185#endif
     186
     187    if (waitMode == WaitForMessage && predicate.isDefaultMode() && m_sharedTimer->isActive())
     188        timeoutDelay = std::min(timeoutDelay, m_sharedTimer->fireTimeDelay());
    194189
    195190    if (WorkerScriptController* script = context->script()) {
    … …  
    198193    }
    199194    MessageQueueWaitResult result;
    200     auto task = m_messageQueue.waitForMessageFilteredWithTimeout(result, predicate, absoluteTime);
     195    auto task = m_messageQueue.waitForMessageFilteredWithTimeout(result, predicate, timeoutDelay);
    201196    if (WorkerScriptController* script = context->script()) {
    202197        script->acquireHeapAccess();
Note: See TracChangeset for help on using the changeset viewer.