From d8ec57451ff4cdd54230cd17a4a7e398e804ebbc Mon Sep 17 00:00:00 2001
From: Benoit Jacob <benoitjacob@google.com>
Date: Wed, 29 Jan 2020 12:57:02 -0800
Subject: [PATCH] Rename ruy::WaitUntil to ruy::Wait, because it is most
 closely related to std::condition_variable::wait, rather than to
 std::condition_variable::wait_until, so this could have been confusing.  For
 us the "until" means "until the predicate returns true" while in the standard
 library, the _until suffix means "until some delay has elapsed".

PiperOrigin-RevId: 292200429
Change-Id: I1e446b95677724ebac137cedd1348a6b27e392d7
---
 tensorflow/lite/experimental/ruy/blocking_counter.cc |  2 +-
 tensorflow/lite/experimental/ruy/thread_pool.cc      |  2 +-
 tensorflow/lite/experimental/ruy/wait.cc             | 11 +++++------
 tensorflow/lite/experimental/ruy/wait.h              | 11 +++++------
 tensorflow/lite/experimental/ruy/wait_test.cc        |  2 +-
 5 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/tensorflow/lite/experimental/ruy/blocking_counter.cc b/tensorflow/lite/experimental/ruy/blocking_counter.cc
index 97b096d0e4f..eba4ae4a2f4 100644
--- a/tensorflow/lite/experimental/ruy/blocking_counter.cc
+++ b/tensorflow/lite/experimental/ruy/blocking_counter.cc
@@ -43,7 +43,7 @@ void BlockingCounter::Wait() {
   const auto& condition = [this]() {
     return count_.load(std::memory_order_acquire) == 0;
   };
-  WaitUntil(condition, &count_cond_, &count_mutex_);
+  ruy::Wait(condition, &count_cond_, &count_mutex_);
 }
 
 }  // namespace ruy
diff --git a/tensorflow/lite/experimental/ruy/thread_pool.cc b/tensorflow/lite/experimental/ruy/thread_pool.cc
index d771429ffe2..0e7130f8734 100644
--- a/tensorflow/lite/experimental/ruy/thread_pool.cc
+++ b/tensorflow/lite/experimental/ruy/thread_pool.cc
@@ -116,7 +116,7 @@ class Thread {
       const auto& condition = [this]() {
         return state_.load(std::memory_order_acquire) != State::Ready;
       };
-      WaitUntil(condition, &state_cond_, &state_mutex_);
+      Wait(condition, &state_cond_, &state_mutex_);
 
       // Act on new state.
       switch (state_.load(std::memory_order_acquire)) {
diff --git a/tensorflow/lite/experimental/ruy/wait.cc b/tensorflow/lite/experimental/ruy/wait.cc
index 310f53d9ca5..04a5848fb44 100644
--- a/tensorflow/lite/experimental/ruy/wait.cc
+++ b/tensorflow/lite/experimental/ruy/wait.cc
@@ -19,9 +19,8 @@ limitations under the License.
 
 namespace ruy {
 
-void WaitUntil(const std::function<bool()>& condition,
-               const Duration& spin_duration, std::condition_variable* condvar,
-               std::mutex* mutex) {
+void Wait(const std::function<bool()>& condition, const Duration& spin_duration,
+          std::condition_variable* condvar, std::mutex* mutex) {
   // First, trivial case where the `condition` is already true;
   if (condition()) {
     return;
@@ -40,8 +39,8 @@ void WaitUntil(const std::function<bool()>& condition,
   condvar->wait(lock, condition);
 }
 
-void WaitUntil(const std::function<bool()>& condition,
-               std::condition_variable* condvar, std::mutex* mutex) {
+void Wait(const std::function<bool()>& condition,
+          std::condition_variable* condvar, std::mutex* mutex) {
   // This value was empirically derived with some microbenchmark, we don't have
   // high confidence in it.
   //
@@ -64,7 +63,7 @@ void WaitUntil(const std::function<bool()>& condition,
   // may be a little longer. There may also not be another GEMM for a long time,
   // in which case we'll end up passively waiting below.
   const Duration spin_duration = DurationFromMilliseconds(2);
-  WaitUntil(condition, spin_duration, condvar, mutex);
+  Wait(condition, spin_duration, condvar, mutex);
 }
 
 }  // namespace ruy
diff --git a/tensorflow/lite/experimental/ruy/wait.h b/tensorflow/lite/experimental/ruy/wait.h
index ae38836626f..0d06a4c2748 100644
--- a/tensorflow/lite/experimental/ruy/wait.h
+++ b/tensorflow/lite/experimental/ruy/wait.h
@@ -59,15 +59,14 @@ namespace ruy {
 // inline storage, avoiding a heap allocation. However, we can't effectively
 // guard that assumption, and that's not a big concern anyway because the
 // latency of a small heap allocation is probably low compared to the intrinsic
-// latency of what this WaitUntil function does.
-void WaitUntil(const std::function<bool()>& condition,
-               const Duration& spin_duration, std::condition_variable* condvar,
-               std::mutex* mutex);
+// latency of what this Wait function does.
+void Wait(const std::function<bool()>& condition, const Duration& spin_duration,
+          std::condition_variable* condvar, std::mutex* mutex);
 
 // Convenience overload using a default `spin_duration`.
 // TODO(benoitjacob): let this be controlled from the ruy API.
-void WaitUntil(const std::function<bool()>& condition,
-               std::condition_variable* condvar, std::mutex* mutex);
+void Wait(const std::function<bool()>& condition,
+          std::condition_variable* condvar, std::mutex* mutex);
 
 }  // namespace ruy
 
diff --git a/tensorflow/lite/experimental/ruy/wait_test.cc b/tensorflow/lite/experimental/ruy/wait_test.cc
index 4185ac70eaf..71e9d1d5b35 100644
--- a/tensorflow/lite/experimental/ruy/wait_test.cc
+++ b/tensorflow/lite/experimental/ruy/wait_test.cc
@@ -80,7 +80,7 @@ void WaitTest(const Duration& spin_duration, const Duration& delay) {
     const auto& condition = [&value, &end_value]() {
       return value.load() == end_value.load();
     };
-    ruy::WaitUntil(condition, spin_duration, &condvar, &mutex);
+    ruy::Wait(condition, spin_duration, &condvar, &mutex);
     EXPECT_EQ(value.load(), end_value.load());
   }
   end_value.store(-1);