This is an automated email from the ASF dual-hosted git repository. alexey pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/kudu.git commit 643bf32bb82e6f08c02cae94d0dab5cac9d61216 Author: Alexey Serbin AuthorDate: Wed Dec 18 00:25:35 2019 -0800 [monotime] deprecating MonoTime::GetDeltaSince() I find that MonoTime t0 = ...; MonoTime t1 = ...; MonoDelta delta = t1 - t0; is easier to write, read, and understand than MonoTime t0 = ...; MonoTime t1 = ...; MonoDelta delta = t1.GetDeltaSince(t0); So, I replaced usage of the MonoTime::GetDeltaSince() with the operator and marked the former method as deprecated. This patch doesn't contain any functional modifications. Change-Id: I9611c8a20e02b117757842bc3b46b8faf82d9700 Reviewed-on: http://gerrit.cloudera.org:8080/14932 Reviewed-by: Adar Dembo Reviewed-by: Yingchun Lai <405403881@qq.com> Tested-by: Alexey Serbin --- src/kudu/rpc/result_tracker.cc | 3 +-- src/kudu/rpc/rpc-test-base.h | 2 +- src/kudu/tserver/tablet_copy_service-test.cc | 2 +- src/kudu/tserver/tablet_service.cc | 4 +--- src/kudu/util/monotime-test.cc | 14 +++++--------- src/kudu/util/monotime.cc | 12 ++++++------ src/kudu/util/monotime.h | 12 +++++++++--- 7 files changed, 24 insertions(+), 25 deletions(-) diff --git a/src/kudu/rpc/result_tracker.cc b/src/kudu/rpc/result_tracker.cc index d26ff87..f8f5c46 100644 --- a/src/kudu/rpc/result_tracker.cc +++ b/src/kudu/rpc/result_tracker.cc @@ -556,8 +556,7 @@ void ResultTracker::ClientState::GCCompletionRecords( } string ResultTracker::ClientState::ToString() const { - auto since_last_heard = - MonoTime::Now().GetDeltaSince(last_heard_from); + auto since_last_heard = MonoTime::Now() - last_heard_from; string result = Substitute("Client State[Last heard from: $0s ago, " "$1 CompletionRecords:", since_last_heard.ToString(), diff --git a/src/kudu/rpc/rpc-test-base.h b/src/kudu/rpc/rpc-test-base.h index 2fb742e..e26bc9d 100644 --- a/src/kudu/rpc/rpc-test-base.h +++ b/src/kudu/rpc/rpc-test-base.h @@ -212,7 +212,7 @@ class GenericCalculatorService : public ServiceIf { LOG(INFO) << "got call: " << pb_util::SecureShortDebugString(req); SleepFor(MonoDelta::FromMicroseconds(req.sleep_micros())); - MonoDelta duration(MonoTime::Now().GetDeltaSince(incoming->GetTimeReceived())); + MonoDelta duration(MonoTime::Now() - incoming->GetTimeReceived()); CHECK_GE(duration.ToMicroseconds(), req.sleep_micros()); SleepResponsePB resp; incoming->RespondSuccess(resp); diff --git a/src/kudu/tserver/tablet_copy_service-test.cc b/src/kudu/tserver/tablet_copy_service-test.cc index 1dc0db6..25f076c 100644 --- a/src/kudu/tserver/tablet_copy_service-test.cc +++ b/src/kudu/tserver/tablet_copy_service-test.cc @@ -510,7 +510,7 @@ TEST_F(TabletCopyServiceTest, TestSessionTimeout) { break; } SleepFor(MonoDelta::FromMilliseconds(1)); // 1 ms - } while (MonoTime::Now().GetDeltaSince(start_time).ToSeconds() < 10); + } while ((MonoTime::Now() - start_time).ToSeconds() < 10); ASSERT_FALSE(resp.session_is_active()) << "Tablet Copy session did not time out!"; } diff --git a/src/kudu/tserver/tablet_service.cc b/src/kudu/tserver/tablet_service.cc index 2839d42..97a4cdd 100644 --- a/src/kudu/tserver/tablet_service.cc +++ b/src/kudu/tserver/tablet_service.cc @@ -31,7 +31,6 @@ #include #include -#include #include #include "kudu/clock/clock.h" @@ -91,7 +90,6 @@ #include "kudu/tserver/tserver_admin.pb.h" #include "kudu/tserver/tserver_service.pb.h" #include "kudu/util/auto_release_pool.h" -#include "kudu/util/bitset.h" #include "kudu/util/crc.h" #include "kudu/util/debug/trace_event.h" #include "kudu/util/faststring.h" @@ -2713,7 +2711,7 @@ namespace { // Helper to clamp a client deadline for a scan to the max supported by the server. MonoTime ClampScanDeadlineForWait(const MonoTime& deadline, bool* was_clamped) { MonoTime now = MonoTime::Now(); - if (deadline.GetDeltaSince(now).ToMilliseconds() > FLAGS_scanner_max_wait_ms) { + if ((deadline - now).ToMilliseconds() > FLAGS_scanner_max_wait_ms) { *was_clamped = true; return now + MonoDelta::FromMilliseconds(FLAGS_scanner_max_wait_ms); } diff --git a/src/kudu/util/monotime-test.cc b/src/kudu/util/monotime-test.cc index 755dac5..0fba667 100644 --- a/src/kudu/util/monotime-test.cc +++ b/src/kudu/util/monotime-test.cc @@ -106,7 +106,7 @@ TEST(TestMonoTime, TestTimeSpec) { ts.tv_sec = 1; ts.tv_nsec = 1; MonoTime one_sec_one_nano_actual(ts); - ASSERT_EQ(0, one_sec_one_nano_expected.GetDeltaSince(one_sec_one_nano_actual).ToNanoseconds()); + ASSERT_EQ(0, (one_sec_one_nano_expected - one_sec_one_nano_actual).ToNanoseconds()); MonoDelta zero_sec_two_nanos(MonoDelta::FromNanoseconds(2L)); zero_sec_two_nanos.ToTimeSpec(&ts); @@ -127,11 +127,9 @@ TEST(TestMonoTime, TestDeltas) { alarm(360); const MonoDelta max_delta(MonoDelta::FromSeconds(0.1)); MonoTime prev(MonoTime::Now()); - MonoTime next; MonoDelta cur_delta; do { - next = MonoTime::Now(); - cur_delta = next.GetDeltaSince(prev); + cur_delta = MonoTime::Now() - prev; } while (cur_delta.LessThan(max_delta)); alarm(0); } @@ -153,11 +151,9 @@ static void DoTestMonoTimePerf() { const MonoDelta max_delta(MonoDelta::FromMilliseconds(500)); uint64_t num_calls = 0; MonoTime prev(MonoTime::Now()); - MonoTime next; MonoDelta cur_delta; do { - next = MonoTime::Now(); - cur_delta = next.GetDeltaSince(prev); + cur_delta = MonoTime::Now() - prev; num_calls++; } while (cur_delta.LessThan(max_delta)); LOG(INFO) << "DoTestMonoTimePerf():" @@ -170,7 +166,7 @@ TEST(TestMonoTime, TestSleepFor) { MonoDelta sleep = MonoDelta::FromMilliseconds(100); SleepFor(sleep); MonoTime end = MonoTime::Now(); - MonoDelta actualSleep = end.GetDeltaSince(start); + MonoDelta actualSleep = end - start; ASSERT_GE(actualSleep.ToNanoseconds(), sleep.ToNanoseconds()); } @@ -186,7 +182,7 @@ TEST(TestMonoTime, TestSleepForOverflow) { MonoDelta sleep = MonoDelta::FromNanoseconds(1L << 32); SleepFor(sleep); MonoTime end = MonoTime::Now(); - MonoDelta actualSleep = end.GetDeltaSince(start); + MonoDelta actualSleep = end - start; ASSERT_GE(actualSleep.ToNanoseconds(), sleep.ToNanoseconds()); } diff --git a/src/kudu/util/monotime.cc b/src/kudu/util/monotime.cc index 89c795d..b6ffa65 100644 --- a/src/kudu/util/monotime.cc +++ b/src/kudu/util/monotime.cc @@ -201,11 +201,7 @@ bool MonoTime::Initialized() const { } MonoDelta MonoTime::GetDeltaSince(const MonoTime &rhs) const { - DCHECK(Initialized()); - DCHECK(rhs.Initialized()); - int64_t delta(nanos_); - delta -= rhs.nanos_; - return MonoDelta(delta); + return rhs - *this; } void MonoTime::AddDelta(const MonoDelta &delta) { @@ -328,7 +324,11 @@ MonoTime operator-(const MonoTime& t, const MonoDelta& delta) { } MonoDelta operator-(const MonoTime& t_end, const MonoTime& t_beg) { - return t_end.GetDeltaSince(t_beg); + DCHECK(t_beg.Initialized()); + DCHECK(t_end.Initialized()); + int64_t delta(t_end.nanos_); + delta -= t_beg.nanos_; + return MonoDelta(delta); } } // namespace kudu diff --git a/src/kudu/util/monotime.h b/src/kudu/util/monotime.h index bb8ec35..f0013a1 100644 --- a/src/kudu/util/monotime.h +++ b/src/kudu/util/monotime.h @@ -131,6 +131,7 @@ class KUDU_EXPORT MonoDelta { static const int64_t kUninitialized; friend class MonoTime; + friend MonoDelta operator-(const class MonoTime&, const class MonoTime&); FRIEND_TEST(TestMonoTime, TestDeltaConversions); explicit MonoDelta(int64_t delta); @@ -169,6 +170,8 @@ class KUDU_EXPORT MonoTime { /// Select the earliest between the specified time points. /// + /// @deprecated Use @c use std::min() instead. + /// /// @param [in] a /// The first MonoTime object to select from. /// @param [in] b @@ -187,11 +190,15 @@ class KUDU_EXPORT MonoTime { /// Compute time interval between the point in time specified by this /// and the specified object. /// + /// @deprecated Use @c kudu::operator-(const MonoTime&, const MonoTime&) + /// instead. + /// /// @param [in] rhs /// The object that corresponds to the left boundary of the time interval, /// where this object corresponds to the right boundary of the interval. /// @return The resulting time interval represented as a MonoDelta object. - MonoDelta GetDeltaSince(const MonoTime &rhs) const; + MonoDelta GetDeltaSince(const MonoTime &rhs) const ATTRIBUTE_DEPRECATED( + "use kudu::operator-(const MonoTime&, const MonoTime&) instead"); /// Advance this object's time specification by the specified interval. /// @@ -246,6 +253,7 @@ class KUDU_EXPORT MonoTime { private: friend class MonoDelta; + friend MonoDelta operator-(const MonoTime&, const MonoTime&); FRIEND_TEST(TestMonoTime, TestTimeSpec); FRIEND_TEST(TestMonoTime, TestDeltaConversions); @@ -403,8 +411,6 @@ MonoTime KUDU_EXPORT operator-(const MonoTime& t, const MonoDelta& delta); /// Compute the time interval between the specified points in time. /// -/// Semantically, this is equivalent to t0.GetDeltaSince(t1). -/// /// @param [in] t_end /// The second point in time. Semantically corresponds to the end /// of the resulting time interval.