[WTF] Avoid MonotonicTime::now / WallTime::now calls if relative seco…

…nds are infinity

https://bugs.webkit.org/show_bug.cgi?id=256143
rdar://108706987

Reviewed by Mark Lam.

This is micro-optimization. If relative seconds from now is infinity, we should not call MonotonicTime::now() / WallTime::now()
to compute the result. They involve system calls, and it is common that relative seconds are infinity (for example, just waiting
Condition without timeout is infinity).

* Source/WTF/wtf/ApproximateTime.cpp:
(WTF::ApproximateTime::approximateWallTime const):
(WTF::ApproximateTime::approximateMonotonicTime const):
* Source/WTF/wtf/Condition.h:
* Source/WTF/wtf/GenericTimeMixin.h:
(WTF::GenericTimeMixin::timePointFromNow):
* Source/WTF/wtf/MessageQueue.h:
(WTF::MessageQueue<DataType>::waitForMessageFilteredWithTimeout):
* Source/WTF/wtf/MonotonicTime.cpp:
(WTF::MonotonicTime::approximateWallTime const):
* Source/WTF/wtf/ParkingLot.cpp:
(WTF::ParkingLot::parkConditionallyImpl):
* Source/WTF/wtf/WTFSemaphore.h:
* Source/WTF/wtf/WallTime.cpp:
(WTF::WallTime::approximateMonotonicTime const):
* Source/WTF/wtf/threads/BinarySemaphore.h:
* Source/WTF/wtf/win/RunLoopWin.cpp:
(WTF::RunLoop::TimerBase::timerFired):
(WTF::RunLoop::TimerBase::start):

Canonical link: https://commits.webkit.org/263538@main

Source/JavaScriptCore/runtime/WaiterListManager.cpp

@@ -55,7 +55,7 @@ WaiterListManager::WaitSyncResult WaiterListManager::waitSyncImpl(VM& vm, ValueT
 {
     Ref<Waiter> syncWaiter = vm.syncWaiter();
     Ref<WaiterList> list = findOrCreateList(ptr);
-    MonotonicTime time = MonotonicTime::now() + timeout;
+    MonotonicTime time = MonotonicTime::timePointFromNow(timeout);
 
     {
         Locker listLocker { list->lock };

Source/JavaScriptCore/runtime/Watchdog.cpp

@@ -70,7 +70,7 @@ bool Watchdog::shouldTerminate(JSGlobalObject* globalObject)
     // but it is a fact that only Windows is experiencing the issue.
     epsilon = Seconds::fromMilliseconds(20);
 #endif
-    if (MonotonicTime::now() + epsilon < m_deadline)
+    if (MonotonicTime::timePointFromNow(epsilon) < m_deadline)
         return false; // Just a stale timer firing. Nothing to do.
 
     // Set m_deadline to MonotonicTime::infinity() here so that we can reject all future

Source/WTF/wtf/ApproximateTime.cpp

@@ -34,11 +34,15 @@ namespace WTF {
 
 WallTime ApproximateTime::approximateWallTime() const
 {
+    if (std::isinf(*this))
+        return WallTime::fromRawSeconds(m_value);
     return *this - now() + WallTime::now();
 }
 
 MonotonicTime ApproximateTime::approximateMonotonicTime() const
 {
+    if (std::isinf(*this))
+        return MonotonicTime::fromRawSeconds(m_value);
     return *this - now() + MonotonicTime::now();
 }
 

Source/WTF/wtf/Condition.h

@@ -96,24 +96,24 @@ class Condition final {
     template<typename LockType, typename Functor>
     bool waitFor(LockType& lock, Seconds relativeTimeout, const Functor& predicate)
     {
-        return waitUntil(lock, MonotonicTime::now() + relativeTimeout, predicate);
+        return waitUntil(lock, MonotonicTime::timePointFromNow(relativeTimeout), predicate);
     }
 
     template<typename Functor>
     bool waitFor(Lock& lock, Seconds relativeTimeout, const Functor& predicate) WTF_REQUIRES_LOCK(lock)
     {
-        return waitUntil(lock, MonotonicTime::now() + relativeTimeout, predicate);
+        return waitUntil(lock, MonotonicTime::timePointFromNow(relativeTimeout), predicate);
     }
 
     template<typename LockType>
     bool waitFor(LockType& lock, Seconds relativeTimeout)
     {
-        return waitUntil(lock, MonotonicTime::now() + relativeTimeout);
+        return waitUntil(lock, MonotonicTime::timePointFromNow(relativeTimeout));
     }
 
     bool waitFor(Lock& lock, Seconds relativeTimeout) WTF_REQUIRES_LOCK(lock)
     {
-        return waitUntil(lock, MonotonicTime::now() + relativeTimeout);
+        return waitUntil(lock, MonotonicTime::timePointFromNow(relativeTimeout));
     }
 
     template<typename LockType>

Source/WTF/wtf/GenericTimeMixin.h

@@ -119,6 +119,13 @@ class GenericTimeMixin {
         return *static_cast<const DerivedTime*>(this);
     }
 
+    static constexpr DerivedTime timePointFromNow(Seconds relativeTimeFromNow)
+    {
+        if (std::isinf(relativeTimeFromNow))
+            return DerivedTime::fromRawSeconds(relativeTimeFromNow.value());
+        return DerivedTime::now() + relativeTimeFromNow;
+    }
+
 protected:
     // This is the epoch. So, x.secondsSinceEpoch() should be the same as x - DerivedTime().
     constexpr GenericTimeMixin() = default;

Source/WTF/wtf/MessageQueue.h

@@ -141,7 +141,7 @@ namespace WTF {
         Locker lock { m_lock };
         bool timedOut = false;
 
-        MonotonicTime absoluteTimeout = MonotonicTime::now() + relativeTimeout;
+        MonotonicTime absoluteTimeout = MonotonicTime::timePointFromNow(relativeTimeout);
         auto found = m_queue.end();
         while (!m_killed && !timedOut) {
             found = m_queue.findIf([&predicate](const std::unique_ptr<DataType>& ptr) -> bool {

Source/WTF/wtf/MonotonicTime.cpp

@@ -33,6 +33,8 @@ namespace WTF {
 
 WallTime MonotonicTime::approximateWallTime() const
 {
+    if (std::isinf(*this))
+        return WallTime::fromRawSeconds(m_value);
     return *this - now() + WallTime::now();
 }
 

Source/WTF/wtf/ParkingLot.cpp

@@ -592,9 +592,8 @@ NEVER_INLINE ParkingLot::ParkResult ParkingLot::parkConditionallyImpl(
     {
         MutexLocker locker(me->parkingLock);
         while (me->address && timeout.nowWithSameClock() < timeout) {
-            me->parkingCondition.timedWait(
-                me->parkingLock, timeout.approximateWallTime());
-
+            me->parkingCondition.timedWait(me->parkingLock, timeout.approximateWallTime());
+
             // It's possible for the OS to decide not to wait. If it does that then it will also
             // decide not to release the lock. If there's a bug in the time math, then this could
             // result in a deadlock. Flashing the lock means that at worst it's just a CPU-eating

Source/WTF/wtf/WTFSemaphore.h

@@ -61,7 +61,7 @@ class Semaphore final {
 
     bool waitFor(Seconds relativeTimeout)
     {
-        return waitUntil(MonotonicTime::now() + relativeTimeout);
+        return waitUntil(MonotonicTime::timePointFromNow(relativeTimeout));
     }
 
     void wait()

Source/WTF/wtf/WallTime.cpp

@@ -33,6 +33,8 @@ namespace WTF {
 
 MonotonicTime WallTime::approximateMonotonicTime() const
 {
+    if (std::isinf(*this))
+        return MonotonicTime::fromRawSeconds(m_value);
     return *this - now() + MonotonicTime::now();
 }
 

Source/WTF/wtf/posix/ThreadingPOSIX.cpp

@@ -606,6 +606,13 @@ void ThreadCondition::wait(Mutex& mutex)
 
 bool ThreadCondition::timedWait(Mutex& mutex, WallTime absoluteTime)
 {
+    if (std::isinf(absoluteTime)) {
+        if (absoluteTime == -WallTime::infinity())
+            return false;
+        wait(mutex);
+        return true;
+    }
+
     if (absoluteTime < WallTime::now())
         return false;
 

Source/WTF/wtf/threads/BinarySemaphore.h

@@ -43,7 +43,7 @@ class BinarySemaphore final {
 
     bool waitFor(Seconds relativeTimeout)
     {
-        return waitUntil(MonotonicTime::now() + relativeTimeout);
+        return waitUntil(MonotonicTime::timePointFromNow(relativeTimeout));
     }
 
     void wait()

Source/WTF/wtf/win/RunLoopWin.cpp

@@ -147,7 +147,7 @@ void RunLoop::TimerBase::timerFired()
             m_isActive = false;
             ::KillTimer(m_runLoop->m_runLoopMessageWindow, bitwise_cast<uintptr_t>(this));
         } else
-            m_nextFireDate = MonotonicTime::now() + m_interval;
+            m_nextFireDate = MonotonicTime::timePointFromNow(m_interval);
     }
 
     fired();
@@ -169,7 +169,7 @@ void RunLoop::TimerBase::start(Seconds interval, bool repeat)
     m_isRepeating = repeat;
     m_isActive = true;
     m_interval = interval;
-    m_nextFireDate = MonotonicTime::now() + m_interval;
+    m_nextFireDate = MonotonicTime::timePointFromNow(m_interval);
     ::SetTimer(m_runLoop->m_runLoopMessageWindow, bitwise_cast<uintptr_t>(this), interval.millisecondsAs<UINT>(), nullptr);
 }
 

Source/WTF/wtf/win/ThreadingWin.cpp

@@ -351,6 +351,12 @@ void Mutex::unlock()
 // Returns an interval in milliseconds suitable for passing to one of the Win32 wait functions (e.g., ::WaitForSingleObject).
 static DWORD absoluteTimeToWaitTimeoutInterval(WallTime absoluteTime)
 {
+    if (std::isinf(absoluteTime)) {
+        if (absoluteTime == -WallTime::infinity())
+            return 0;
+        return INFINITE;
+    }
+
     WallTime currentTime = WallTime::now();
 
     // Time is in the past - return immediately.

Source/WebCore/platform/graphics/cocoa/WebProcessGraphicsContextGLCocoa.mm

@@ -59,7 +59,7 @@
     bool waitFor(Seconds timeout) final
     {
         Locker locker { m_lock };
-        auto absoluteTime = MonotonicTime::now() + timeout;
+        auto absoluteTime = MonotonicTime::timePointFromNow(timeout);
         return m_condition.waitUntil(m_lock, absoluteTime, [&] {
             assertIsHeld(m_lock);
             return m_isSet;