[futex] Avoid accumulation errors in futex wait timeout

src/futex-emulation.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/futex-emulation.h"
 
 #include <limits>
 
 #include "src/base/macros.h"
 #include "src/base/platform/time.h"
@@ skipping 83 matching lines @@
         static_cast<double>(std::numeric_limits<int64_t>::max())) {
       // 2**63 nanoseconds is 292 years. Let's just treat anything greater as
       // infinite.
       use_timeout = false;
     } else {
       rel_timeout = base::TimeDelta::FromNanoseconds(
           static_cast<int64_t>(rel_timeout_ns));
     }
   }
 
-  base::TimeDelta rel_time_left = rel_timeout;
+  base::Time start_time = base::Time::NowFromSystemTime();
+  base::Time timeout_time = start_time + rel_timeout;
 
   wait_list_.Pointer()->AddNode(node);
 
   Object* result;
 
   while (true) {
-    base::TimeDelta time_to_wait = (use_timeout && rel_time_left < kMaxWaitTime)
-                                       ? rel_time_left
-                                       : kMaxWaitTime;
+    base::Time current_time = base::Time::NowFromSystemTime();
+    if (use_timeout && current_time > timeout_time) {
+      result = Smi::FromInt(Result::kTimedOut);
+      break;
+    }
 
-    base::Time start_time = base::Time::NowFromSystemTime();
+    base::TimeDelta time_until_timeout = timeout_time - current_time;
+    base::TimeDelta time_to_wait =
+        (use_timeout && time_until_timeout < kMaxWaitTime) ? time_until_timeout
+                                                           : kMaxWaitTime;
+
     bool wait_for_result = node->cond_.WaitFor(mutex_.Pointer(), time_to_wait);
     USE(wait_for_result);
 
     if (!node->waiting_) {
       result = Smi::FromInt(Result::kOk);
       break;
     }
 
-    // Spurious wakeup or timeout.
-    base::Time end_time = base::Time::NowFromSystemTime();
-    base::TimeDelta waited_for = end_time - start_time;
-    rel_time_left -= waited_for;
-
-    if (use_timeout && rel_time_left < base::TimeDelta::FromMicroseconds(0)) {
-      result = Smi::FromInt(Result::kTimedOut);
-      break;
-    }
-
-    // Potentially handle interrupts before continuing to wait.
+    // Spurious wakeup or timeout. Potentially handle interrupts before
+    // continuing to wait.
     Object* interrupt_object = isolate->stack_guard()->HandleInterrupts();
     if (interrupt_object->IsException()) {
       result = interrupt_object;
       break;
     }
   }
 
   wait_list_.Pointer()->RemoveNode(node);
 
   return result;
@@ skipping 79 matching lines @@
     }
 
     node = node->next_;
   }
 
   return Smi::FromInt(waiters);
 }
 
 }  // namespace internal
 }  // namespace v8