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 86bdc679f6a5435c649d2ac0f6557daab632b953 Author: Alexey Serbin <[email protected]> AuthorDate: Thu Aug 10 15:11:53 2023 -0700 [util] deprecate {MonoTime,MonoDelta}::Equals() methods All these Equals(), LessThan(), MoreThan(), Earliest(), AddDelta(), etc. methods look a bit funny in the C++ code. Also, the API already exposes more expressive means to do the same: the corresponding operators. To prevent spreading the harder-to-read and funny looking code, this patch declares those operators obsolete to promote using the better option. Of course, due to the compatibility reasons, those methods are still kept in the public API as they used to be, but now the compiler will emit a warning when trying to use those deprecated methods. I also took the liberty of updating the related code to be more style-compliant and making other minor improvements. Change-Id: I716955dcc7359f920d0b5bedf9035a42edeb6e92 Reviewed-on: http://gerrit.cloudera.org:8080/20442 Reviewed-by: Mahesh Reddy <[email protected]> Reviewed-by: Abhishek Chennaka <[email protected]> Tested-by: Alexey Serbin <[email protected]> --- src/kudu/consensus/time_manager-test.cc | 3 +- src/kudu/integration-tests/master-stress-test.cc | 6 +- src/kudu/rpc/exactly_once_rpc-test.cc | 13 +-- src/kudu/rpc/result_tracker.cc | 11 +- src/kudu/util/monotime-test.cc | 19 ++-- src/kudu/util/monotime.cc | 122 +++++++++++------------ src/kudu/util/monotime.h | 72 ++++++++----- src/kudu/util/threadpool.cc | 6 +- 8 files changed, 136 insertions(+), 116 deletions(-) diff --git a/src/kudu/consensus/time_manager-test.cc b/src/kudu/consensus/time_manager-test.cc index 32608db25..da37c83c2 100644 --- a/src/kudu/consensus/time_manager-test.cc +++ b/src/kudu/consensus/time_manager-test.cc @@ -203,8 +203,7 @@ TEST_F(TimeManagerTest, TestTimeManagerLeaderMode) { // safe time shouldn't move anymore ... ASSERT_EQ(time_manager_->GetSafeTime(), safe_after); now = clock_.Now(); - MonoTime after_small = MonoTime::Now(); - after_small.AddDelta(MonoDelta::FromMilliseconds(100)); + const auto after_small = MonoTime::Now() + MonoDelta::FromMilliseconds(100); ASSERT_TRUE(time_manager_->WaitUntilSafe(now, after_small).IsTimedOut()); // ... unless we get a message from the leader. diff --git a/src/kudu/integration-tests/master-stress-test.cc b/src/kudu/integration-tests/master-stress-test.cc index 1889ff4a5..dd07243ec 100644 --- a/src/kudu/integration-tests/master-stress-test.cc +++ b/src/kudu/integration-tests/master-stress-test.cc @@ -23,6 +23,7 @@ #include <string> #include <thread> #include <tuple> +#include <type_traits> #include <unordered_map> #include <utility> #include <vector> @@ -49,7 +50,6 @@ #include "kudu/master/master.proxy.h" #include "kudu/mini-cluster/external_mini_cluster.h" #include "kudu/rpc/messenger.h" -#include "kudu/rpc/response_callback.h" #include "kudu/rpc/rpc_controller.h" #include "kudu/tablet/tablet.pb.h" #include "kudu/thrift/client.h" @@ -436,8 +436,8 @@ class MasterStressTest : public ExternalMiniClusterITestBase, MessengerBuilder bld("RestartMasterMessenger"); CHECK_OK(bld.Build(&messenger)); - MonoTime deadline(MonoTime::Now()); - deadline.AddDelta(MonoDelta::FromSeconds(FLAGS_num_seconds_to_run)); + const auto deadline = MonoTime::Now() + + MonoDelta::FromSeconds(FLAGS_num_seconds_to_run); MonoTime now(MonoTime::Now()); while (now < deadline) { diff --git a/src/kudu/rpc/exactly_once_rpc-test.cc b/src/kudu/rpc/exactly_once_rpc-test.cc index 31f474489..8308b66bb 100644 --- a/src/kudu/rpc/exactly_once_rpc-test.cc +++ b/src/kudu/rpc/exactly_once_rpc-test.cc @@ -25,6 +25,7 @@ #include <ostream> #include <string> #include <thread> +#include <type_traits> #include <utility> #include <vector> @@ -44,7 +45,6 @@ #include "kudu/rpc/rtest.pb.h" #include "kudu/rpc/rtest.proxy.h" #include "kudu/util/countdown_latch.h" -#include "kudu/util/mem_tracker.h" #include "kudu/util/monotime.h" #include "kudu/util/net/sockaddr.h" #include "kudu/util/pb_util.h" @@ -220,11 +220,10 @@ class ExactlyOnceRpcTest : public RpcTestBase { shared_ptr<Messenger> messenger, int value, int server_sleep = 0) : latch(1) { - MonoTime now = MonoTime::Now(); - now.AddDelta(MonoDelta::FromMilliseconds(10000)); + const auto deadline = MonoTime::Now() + MonoDelta::FromSeconds(10); rpc = new CalculatorServiceRpc(server_picker, request_tracker, - now, + deadline, std::move(messenger), value, &latch, @@ -298,8 +297,7 @@ class ExactlyOnceRpcTest : public RpcTestBase { // This continuously issues calls to the server, that often last longer than // 'remember_responses_ttl_ms', making sure that we don't get errors back. void DoLongWritesThread(MonoDelta run_for) { - MonoTime run_until = MonoTime::Now(); - run_until.AddDelta(run_for); + const auto run_until = MonoTime::Now() + run_for; int counter = 0; while (MonoTime::Now() < run_until) { unique_ptr<RetriableRpcExactlyOnceAdder> adder(new RetriableRpcExactlyOnceAdder( @@ -327,8 +325,7 @@ class ExactlyOnceRpcTest : public RpcTestBase { // client should be GCed. void StubbornlyWriteTheSameRequestThread(ResultTracker::SequenceNumber sequence_number, MonoDelta run_for) { - MonoTime run_until = MonoTime::Now(); - run_until.AddDelta(run_for); + const auto run_until = MonoTime::Now() + run_for; // Make an initial request, so that we get a response to compare to. ExactlyOnceResponsePB original_response; CHECK_OK(MakeAddCall(sequence_number, 0, &original_response)); diff --git a/src/kudu/rpc/result_tracker.cc b/src/kudu/rpc/result_tracker.cc index d5a376c2b..7d2c3fe3c 100644 --- a/src/kudu/rpc/result_tracker.cc +++ b/src/kudu/rpc/result_tracker.cc @@ -20,6 +20,7 @@ #include <algorithm> #include <mutex> #include <ostream> +#include <type_traits> #include <gflags/gflags.h> #include <glog/logging.h> @@ -474,12 +475,10 @@ void ResultTracker::GCResults() { lock_guard<simple_spinlock> l(lock_); MonoTime now = MonoTime::Now(); // Calculate the instants before which we'll start GCing ClientStates and CompletionRecords. - MonoTime time_to_gc_clients_from = now; - time_to_gc_clients_from.AddDelta( - MonoDelta::FromMilliseconds(-FLAGS_remember_clients_ttl_ms)); - MonoTime time_to_gc_responses_from = now; - time_to_gc_responses_from.AddDelta( - MonoDelta::FromMilliseconds(-FLAGS_remember_responses_ttl_ms)); + const auto time_to_gc_clients_from = now - + MonoDelta::FromMilliseconds(FLAGS_remember_clients_ttl_ms); + const auto time_to_gc_responses_from = now - + MonoDelta::FromMilliseconds(FLAGS_remember_responses_ttl_ms); // Now go through the ClientStates. If we haven't heard from a client in a while // GC it and all its completion records (making sure there isn't actually one in progress first). diff --git a/src/kudu/util/monotime-test.cc b/src/kudu/util/monotime-test.cc index a75d6fa70..7404b7b24 100644 --- a/src/kudu/util/monotime-test.cc +++ b/src/kudu/util/monotime-test.cc @@ -23,12 +23,19 @@ #include <cstdint> #include <ctime> #include <ostream> +#include <string> #include <glog/logging.h> #include <gtest/gtest.h> #include "kudu/util/test_util.h" +// Many original scenarios in this test suite use the deprecated +// MonoTime/MonoDelta API, so let's add a blanket pragma to quell the warnings +// about using the deprecated methods. +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + namespace kudu { TEST(TestMonoTime, TestMonotonicity) { @@ -38,16 +45,14 @@ TEST(TestMonoTime, TestMonotonicity) { do { next = MonoTime::Now(); - //LOG(INFO) << " next = " << next.ToString(); - } while (!prev.ComesBefore(next)); - ASSERT_FALSE(next.ComesBefore(prev)); + } while (prev >= next); + ASSERT_LE(prev, next); alarm(0); } TEST(TestMonoTime, TestComparison) { - MonoTime now(MonoTime::Now()); - MonoTime future(now); - future.AddDelta(MonoDelta::FromNanoseconds(1L)); + const MonoTime now(MonoTime::Now()); + const MonoTime future(now + MonoDelta::FromNanoseconds(1L)); ASSERT_GT((future - now).ToNanoseconds(), 0); ASSERT_LT((now - future).ToNanoseconds(), 0); @@ -508,3 +513,5 @@ TEST(TestMonoTimePerf, TestMonoTimePerf) { } } // namespace kudu + +#pragma GCC diagnostic pop diff --git a/src/kudu/util/monotime.cc b/src/kudu/util/monotime.cc index da7a6c55a..1a44f74bb 100644 --- a/src/kudu/util/monotime.cc +++ b/src/kudu/util/monotime.cc @@ -19,6 +19,7 @@ #include <sys/time.h> +#include <cstdint> #include <ctime> #include <limits> #include <ostream> @@ -47,8 +48,7 @@ namespace kudu { const int64_t MonoDelta::kUninitialized = kint64min; MonoDelta MonoDelta::FromSeconds(double seconds) { - int64_t delta = seconds * MonoTime::kNanosecondsPerSecond; - return MonoDelta(delta); + return MonoDelta(seconds * MonoTime::kNanosecondsPerSecond); } MonoDelta MonoDelta::FromMilliseconds(int64_t ms) { @@ -71,22 +71,16 @@ bool MonoDelta::Initialized() const { return nano_delta_ != kUninitialized; } -bool MonoDelta::LessThan(const MonoDelta &rhs) const { - DCHECK(Initialized()); - DCHECK(rhs.Initialized()); - return nano_delta_ < rhs.nano_delta_; +bool MonoDelta::LessThan(const MonoDelta& rhs) const { + return *this < rhs; } -bool MonoDelta::MoreThan(const MonoDelta &rhs) const { - DCHECK(Initialized()); - DCHECK(rhs.Initialized()); - return nano_delta_ > rhs.nano_delta_; +bool MonoDelta::MoreThan(const MonoDelta& rhs) const { + return *this > rhs; } -bool MonoDelta::Equals(const MonoDelta &rhs) const { - DCHECK(Initialized()); - DCHECK(rhs.Initialized()); - return nano_delta_ == rhs.nano_delta_; +bool MonoDelta::Equals(const MonoDelta& rhs) const { + return *this == rhs; } std::string MonoDelta::ToString() const { @@ -94,14 +88,12 @@ std::string MonoDelta::ToString() const { } MonoDelta::MonoDelta(int64_t delta) - : nano_delta_(delta) { + : nano_delta_(delta) { } double MonoDelta::ToSeconds() const { DCHECK(Initialized()); - double d(nano_delta_); - d /= MonoTime::kNanosecondsPerSecond; - return d; + return static_cast<double>(nano_delta_) / MonoTime::kNanosecondsPerSecond; } int64_t MonoDelta::ToNanoseconds() const { @@ -111,7 +103,7 @@ int64_t MonoDelta::ToNanoseconds() const { int64_t MonoDelta::ToMicroseconds() const { DCHECK(Initialized()); - return nano_delta_ / MonoTime::kNanosecondsPerMicrosecond; + return nano_delta_ / MonoTime::kNanosecondsPerMicrosecond; } int64_t MonoDelta::ToMilliseconds() const { @@ -119,7 +111,7 @@ int64_t MonoDelta::ToMilliseconds() const { return nano_delta_ / MonoTime::kNanosecondsPerMillisecond; } -void MonoDelta::ToTimeVal(struct timeval *tv) const { +void MonoDelta::ToTimeVal(struct timeval* tv) const { DCHECK(Initialized()); tv->tv_sec = nano_delta_ / MonoTime::kNanosecondsPerSecond; tv->tv_usec = (nano_delta_ - (tv->tv_sec * MonoTime::kNanosecondsPerSecond)) @@ -210,20 +202,16 @@ bool MonoTime::Initialized() const { return nanos_ != 0; } -MonoDelta MonoTime::GetDeltaSince(const MonoTime &rhs) const { +MonoDelta MonoTime::GetDeltaSince(const MonoTime& rhs) const { return rhs - *this; } -void MonoTime::AddDelta(const MonoDelta &delta) { - DCHECK(Initialized()); - DCHECK(delta.Initialized()); - nanos_ += delta.nano_delta_; +void MonoTime::AddDelta(const MonoDelta& delta) { + this->operator+=(delta); } -bool MonoTime::ComesBefore(const MonoTime &rhs) const { - DCHECK(Initialized()); - DCHECK(rhs.Initialized()); - return nanos_ < rhs.nanos_; +bool MonoTime::ComesBefore(const MonoTime& rhs) const { + return *this < rhs; } std::string MonoTime::ToString() const { @@ -236,16 +224,20 @@ void MonoTime::ToTimeSpec(struct timespec* ts) const { } bool MonoTime::Equals(const MonoTime& other) const { - return nanos_ == other.nanos_; + return *this == other; } MonoTime& MonoTime::operator+=(const MonoDelta& delta) { - this->AddDelta(delta); + DCHECK(Initialized()); + DCHECK(delta.Initialized()); + nanos_ += delta.nano_delta_; return *this; } MonoTime& MonoTime::operator-=(const MonoDelta& delta) { - this->AddDelta(MonoDelta(-1 * delta.nano_delta_)); + DCHECK(Initialized()); + DCHECK(delta.Initialized()); + nanos_ -= delta.nano_delta_; return *this; } @@ -264,9 +256,7 @@ MonoTime::MonoTime(int64_t nanos) KUDU_MONOTIME_NOEXCEPT } double MonoTime::ToSeconds() const { - double d(nanos_); - d /= MonoTime::kNanosecondsPerSecond; - return d; + return static_cast<double>(nanos_) / MonoTime::kNanosecondsPerSecond; } void SleepFor(const MonoDelta& delta) { @@ -274,80 +264,84 @@ void SleepFor(const MonoDelta& delta) { base::SleepForNanoseconds(delta.ToNanoseconds()); } -bool operator==(const MonoDelta &lhs, const MonoDelta &rhs) { - return lhs.Equals(rhs); +bool operator==(const MonoDelta& lhs, const MonoDelta& rhs) { + DCHECK(lhs.Initialized()); + DCHECK(rhs.Initialized()); + return lhs.nano_delta_ == rhs.nano_delta_; } -bool operator!=(const MonoDelta &lhs, const MonoDelta &rhs) { - return !lhs.Equals(rhs); +bool operator!=(const MonoDelta& lhs, const MonoDelta& rhs) { + return !(lhs == rhs); } -bool operator<(const MonoDelta &lhs, const MonoDelta &rhs) { - return lhs.LessThan(rhs); +bool operator<(const MonoDelta& lhs, const MonoDelta& rhs) { + DCHECK(lhs.Initialized()); + DCHECK(rhs.Initialized()); + return lhs.nano_delta_ < rhs.nano_delta_; } -bool operator<=(const MonoDelta &lhs, const MonoDelta &rhs) { - return lhs.LessThan(rhs) || lhs.Equals(rhs); +bool operator<=(const MonoDelta& lhs, const MonoDelta& rhs) { + return !(lhs > rhs); } -bool operator>(const MonoDelta &lhs, const MonoDelta &rhs) { - return lhs.MoreThan(rhs); +bool operator>(const MonoDelta& lhs, const MonoDelta& rhs) { + return rhs < lhs; } -bool operator>=(const MonoDelta &lhs, const MonoDelta &rhs) { - return lhs.MoreThan(rhs) || lhs.Equals(rhs); +bool operator>=(const MonoDelta& lhs, const MonoDelta& rhs) { + return !(lhs < rhs); } -MonoDelta operator-(const MonoDelta &lhs, const MonoDelta &rhs) { +MonoDelta operator-(const MonoDelta& lhs, const MonoDelta& rhs) { return MonoDelta(lhs.nano_delta_ - rhs.nano_delta_); } -MonoDelta operator+(const MonoDelta &lhs, const MonoDelta &rhs) { +MonoDelta operator+(const MonoDelta& lhs, const MonoDelta& rhs) { return MonoDelta(lhs.nano_delta_ + rhs.nano_delta_); } bool operator==(const MonoTime& lhs, const MonoTime& rhs) { - return lhs.Equals(rhs); + return lhs.nanos_ == rhs.nanos_; } bool operator!=(const MonoTime& lhs, const MonoTime& rhs) { - return !lhs.Equals(rhs); + return !(lhs == rhs); } bool operator<(const MonoTime& lhs, const MonoTime& rhs) { - return lhs.ComesBefore(rhs); + DCHECK(lhs.Initialized()); + DCHECK(rhs.Initialized()); + return lhs.nanos_ < rhs.nanos_; } bool operator<=(const MonoTime& lhs, const MonoTime& rhs) { - return lhs.ComesBefore(rhs) || lhs.Equals(rhs); + return !(lhs > rhs); } bool operator>(const MonoTime& lhs, const MonoTime& rhs) { - return rhs.ComesBefore(lhs); + return rhs < lhs; } bool operator>=(const MonoTime& lhs, const MonoTime& rhs) { - return rhs.ComesBefore(lhs) || rhs.Equals(lhs); + return !(lhs < rhs); } MonoTime operator+(const MonoTime& t, const MonoDelta& delta) { - MonoTime tmp(t); - tmp.AddDelta(delta); - return tmp; + DCHECK(t.Initialized()); + DCHECK(delta.Initialized()); + return MonoTime(t.nanos_ + delta.nano_delta_); } MonoTime operator-(const MonoTime& t, const MonoDelta& delta) { - MonoTime tmp(t); - tmp.AddDelta(MonoDelta::FromNanoseconds(-delta.ToNanoseconds())); - return tmp; + DCHECK(t.Initialized()); + DCHECK(delta.Initialized()); + return MonoTime(t.nanos_ - delta.nano_delta_); } MonoDelta operator-(const MonoTime& t_end, const MonoTime& t_beg) { DCHECK(t_beg.Initialized()); DCHECK(t_end.Initialized()); - int64_t delta(t_end.nanos_); - delta -= t_beg.nanos_; - return MonoDelta(delta); + return MonoDelta(t_end.nanos_ - t_beg.nanos_); } std::ostream& operator<<(std::ostream& os, const kudu::MonoTime& time) { diff --git a/src/kudu/util/monotime.h b/src/kudu/util/monotime.h index 474dde1ee..583a1de01 100644 --- a/src/kudu/util/monotime.h +++ b/src/kudu/util/monotime.h @@ -94,30 +94,39 @@ class KUDU_EXPORT MonoDelta { /// @return @c true iff this object is initialized. bool Initialized() const; + /// @deprecated Use operator<(const MonoDelta&, const MonoDelta&) instead. + /// /// Check whether this time interval is shorter than the specified one. /// /// @param [in] rhs /// A time interval for comparison. /// @return @c true iff this time interval is strictly shorter /// than the specified one. - bool LessThan(const MonoDelta &rhs) const; + bool LessThan(const MonoDelta& rhs) const + ATTRIBUTE_DEPRECATED("use operator<(const MonoDelta&, const MonoDelta&) instead"); + /// @deprecated Use operator>(const MonoDelta&, const MonoDelta&) instead. + /// /// Check whether this time interval is longer than the specified one. /// /// @param [in] rhs /// A time interval for comparison. /// @return @c true iff this time interval is strictly longer /// than the specified one. - bool MoreThan(const MonoDelta &rhs) const; + bool MoreThan(const MonoDelta& rhs) const + ATTRIBUTE_DEPRECATED("use operator>(const MonoDelta&, const MonoDelta&) instead"); + /// @deprecated Use operator==(const MonoDelta&, const MonoDelta&) instead. + /// /// Check whether this time interval has the same duration - /// as the specified one. + /// as the specified one. /// /// @param [in] rhs /// A time interval for comparison. /// @return @c true iff this time interval has the same duration as the /// the specified one. - bool Equals(const MonoDelta &rhs) const; + bool Equals(const MonoDelta& rhs) const ATTRIBUTE_DEPRECATED( + "use operator==(const MonoDelta&, const MonoDelta&) instead"); /// @return String representation of this interval's duration (in seconds). std::string ToString() const; @@ -137,7 +146,7 @@ class KUDU_EXPORT MonoDelta { /// /// @param [out] tv /// Placeholder for the result value. - void ToTimeVal(struct timeval *tv) const; + void ToTimeVal(struct timeval* tv) const; /// Represent this time interval as a timespec structure, with nanosecond /// accuracy. @@ -180,6 +189,11 @@ class KUDU_EXPORT MonoDelta { friend MonoDelta operator-(const class MonoTime&, const class MonoTime&); friend MonoDelta operator-(const MonoDelta&, const MonoDelta&); friend MonoDelta operator+(const MonoDelta&, const MonoDelta&); + friend class MonoTime operator-(const class MonoTime&, const class MonoDelta&); + friend class MonoTime operator+(const class MonoTime&, const class MonoDelta&); + friend bool operator==(const MonoDelta&, const MonoDelta&); + friend bool operator<(const MonoDelta&, const MonoDelta&); + friend bool operator>(const MonoDelta&, const MonoDelta&); FRIEND_TEST(TestMonoTime, TestDeltaConversions); @@ -223,9 +237,9 @@ class KUDU_EXPORT MonoTime { /// @return MonoTime equal to farthest possible time into the past. static MonoTime Min(); - /// Select the earliest between the specified time points. + /// @deprecated Use std::min() instead. /// - /// @deprecated Use @c use std::min() instead. + /// Select the earliest between the specified time points. /// /// @param [in] a /// The first MonoTime object to select from. @@ -242,25 +256,30 @@ class KUDU_EXPORT MonoTime { /// @return @c true iff the object is initialized. bool Initialized() const; - /// 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. /// + /// Compute time interval between the point in time specified by this + /// and the specified object. + /// /// @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 ATTRIBUTE_DEPRECATED( + MonoDelta GetDeltaSince(const MonoTime& rhs) const ATTRIBUTE_DEPRECATED( "use kudu::operator-(const MonoTime&, const MonoTime&) instead"); + /// @deprecated Use @c operator+=(const MonoDelta&) instead. + /// /// Advance this object's time specification by the specified interval. /// /// @param [in] delta /// The time interval to add. - void AddDelta(const MonoDelta &delta); + void AddDelta(const MonoDelta& delta) ATTRIBUTE_DEPRECATED( + "use operator+=(const MonoDelta&) instead"); + /// @deprecated Use @c operator<(const MonoTime&, const MonoTime&) instead. + /// /// Check whether the point in time specified by this object is earlier /// than the specified one. /// @@ -268,7 +287,8 @@ class KUDU_EXPORT MonoTime { /// The other MonoTime object to compare with. /// @return @c true iff the point in time represented by this MonoTime object /// is earlier then the point in time represented by the parameter. - bool ComesBefore(const MonoTime &rhs) const; + bool ComesBefore(const MonoTime& rhs) const ATTRIBUTE_DEPRECATED( + "use operator<(const MonoTime&, const MonoTime&) instead"); /// @return String representation of the object (in seconds). std::string ToString() const; @@ -280,16 +300,16 @@ class KUDU_EXPORT MonoTime { /// Placeholder for the result value. void ToTimeSpec(struct timespec* ts) const; + /// @deprecated Use operator==(const MonoTime&, const MonoTime&) instead. + /// /// Check whether this object represents the same point in time as the other. /// /// @param [in] other /// The other MonoTime object to compare. /// @return @c true iff the point in time represented by this MonoTime object /// is the same as the one represented by the other. - bool Equals(const MonoTime& other) const; - - /// @name Syntactic sugar: increment/decrement operators for MonoTime. - ///@{ + bool Equals(const MonoTime& other) const ATTRIBUTE_DEPRECATED( + "use operator==(const MonoTime&, const MonoTime&) instead"); /// Add a delta to the point in time represented by the object. /// @@ -304,11 +324,15 @@ class KUDU_EXPORT MonoTime { /// The delta to substract. /// @return Reference to the modified object. MonoTime& operator-=(const MonoDelta& delta); - ///@} private: friend class MonoDelta; friend MonoDelta operator-(const MonoTime&, const MonoTime&); + friend MonoTime operator-(const MonoTime&, const MonoDelta&); + friend MonoTime operator+(const MonoTime&, const MonoDelta&); + friend bool operator==(const MonoTime&, const MonoTime&); + friend bool operator<(const MonoTime&, const MonoTime&); + FRIEND_TEST(TestMonoTime, TestTimeSpec); FRIEND_TEST(TestMonoTime, TestDeltaConversions); @@ -339,7 +363,7 @@ void KUDU_EXPORT SleepFor(const MonoDelta& delta); /// A time interval for comparison: the right-hand operand. /// @return @c true iff the time interval represented by @c lhs is equal /// to the time interval represented by @c rhs. -bool KUDU_EXPORT operator==(const MonoDelta &lhs, const MonoDelta &rhs); +bool KUDU_EXPORT operator==(const MonoDelta& lhs, const MonoDelta& rhs); /// @param [in] lhs /// A time interval for comparison: the left-hand operand. @@ -347,7 +371,7 @@ bool KUDU_EXPORT operator==(const MonoDelta &lhs, const MonoDelta &rhs); /// A time interval for comparison: the right-hand operand. /// @return @c true iff the time interval represented by @c lhs is not equal /// to the time interval represented by @c rhs. -bool KUDU_EXPORT operator!=(const MonoDelta &lhs, const MonoDelta &rhs); +bool KUDU_EXPORT operator!=(const MonoDelta& lhs, const MonoDelta& rhs); /// @param [in] lhs /// A time interval for comparison: the left-hand operand. @@ -355,7 +379,7 @@ bool KUDU_EXPORT operator!=(const MonoDelta &lhs, const MonoDelta &rhs); /// A time interval for comparison: the right-hand operand. /// @return @c true iff the time interval represented by @c lhs is shorter /// than the time interval represented by @c rhs. -bool KUDU_EXPORT operator<(const MonoDelta &lhs, const MonoDelta &rhs); +bool KUDU_EXPORT operator<(const MonoDelta& lhs, const MonoDelta& rhs); /// @param [in] lhs /// A time interval for comparison: the left-hand operand. @@ -363,7 +387,7 @@ bool KUDU_EXPORT operator<(const MonoDelta &lhs, const MonoDelta &rhs); /// A time interval for comparison: the right-hand operand. /// @return @c true iff the time interval represented by @c lhs is shorter /// than or equal to the time interval represented by @c rhs. -bool KUDU_EXPORT operator<=(const MonoDelta &lhs, const MonoDelta &rhs); +bool KUDU_EXPORT operator<=(const MonoDelta& lhs, const MonoDelta& rhs); /// @param [in] lhs /// A time interval for comparison: the left-hand operand. @@ -371,7 +395,7 @@ bool KUDU_EXPORT operator<=(const MonoDelta &lhs, const MonoDelta &rhs); /// A time interval for comparison: the right-hand operand. /// @return @c true iff the time interval represented by @c lhs is longer /// than the time interval represented by @c rhs. -bool KUDU_EXPORT operator>(const MonoDelta &lhs, const MonoDelta &rhs); +bool KUDU_EXPORT operator>(const MonoDelta& lhs, const MonoDelta& rhs); /// @param [in] lhs /// A time interval for comparison: the left-hand operand. @@ -379,7 +403,7 @@ bool KUDU_EXPORT operator>(const MonoDelta &lhs, const MonoDelta &rhs); /// A time interval for comparison: the right-hand operand. /// @return @c true iff the time interval represented by @c lhs is longer /// than or equal to the time interval represented by @c rhs. -bool KUDU_EXPORT operator>=(const MonoDelta &lhs, const MonoDelta &rhs); +bool KUDU_EXPORT operator>=(const MonoDelta& lhs, const MonoDelta& rhs); /// @param [in] lhs /// A time interval for substraction: the left-hand operand. diff --git a/src/kudu/util/threadpool.cc b/src/kudu/util/threadpool.cc index f8a10758d..4454ca04f 100644 --- a/src/kudu/util/threadpool.cc +++ b/src/kudu/util/threadpool.cc @@ -260,9 +260,9 @@ void ThreadPoolToken::Shutdown() { // Submit a task, running after delay_ms delay some time Status ThreadPoolToken::Schedule(std::function<void()> f, int64_t delay_ms) { CHECK(mode() == ThreadPool::ExecutionMode::SERIAL); - MonoTime execute_time = MonoTime::Now(); - execute_time.AddDelta(MonoDelta::FromMilliseconds(delay_ms)); - return pool_->Schedule(this, std::move(f), execute_time); + return pool_->Schedule(this, + std::move(f), + MonoTime::Now() + MonoDelta::FromMilliseconds(delay_ms)); } void ThreadPoolToken::Wait() {
