You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kudu.apache.org by al...@apache.org on 2020/08/10 23:55:16 UTC
[kudu] branch master updated (0cc190f -> 1cd6fe4)
This is an automated email from the ASF dual-hosted git repository.
alexey pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/kudu.git.
from 0cc190f [tablet] acquire a lock for DCHECK() only in debug build
new 2187f9c [kserver] fix const-correctness for getter methods
new 1cd6fe4 [monotime] add MonoDelta::operator{+,-}()
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
src/kudu/kserver/kserver.h | 9 ++++-----
src/kudu/util/monotime-test.cc | 39 +++++++++++++++++++++++++++++++++++++++
src/kudu/util/monotime.cc | 19 ++++++++++++++-----
src/kudu/util/monotime.h | 22 ++++++++++++++++++++--
4 files changed, 77 insertions(+), 12 deletions(-)
[kudu] 02/02: [monotime] add MonoDelta::operator{+,-}()
Posted by al...@apache.org.
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 1cd6fe4f500777def1446ee5dcc93c40dd2f3812
Author: Alexey Serbin <al...@apache.org>
AuthorDate: Sun Aug 9 23:28:04 2020 -0700
[monotime] add MonoDelta::operator{+,-}()
Added a bit of syntactic sugar: MonoDelta::operator+() and
MonoDelta::operator-() and corresponding test scenarios.
I'm going to use these new operators in a follow-up changelist.
Change-Id: Ibfad30af72128b4d0054993243bfc00e67b89a9e
Reviewed-on: http://gerrit.cloudera.org:8080/16317
Tested-by: Andrew Wong <aw...@cloudera.com>
Reviewed-by: Andrew Wong <aw...@cloudera.com>
---
src/kudu/util/monotime-test.cc | 39 +++++++++++++++++++++++++++++++++++++++
src/kudu/util/monotime.cc | 19 ++++++++++++++-----
src/kudu/util/monotime.h | 22 ++++++++++++++++++++--
3 files changed, 73 insertions(+), 7 deletions(-)
diff --git a/src/kudu/util/monotime-test.cc b/src/kudu/util/monotime-test.cc
index 4711f1f..8a4279e 100644
--- a/src/kudu/util/monotime-test.cc
+++ b/src/kudu/util/monotime-test.cc
@@ -215,6 +215,45 @@ TEST(TestMonoTime, TestOperators) {
EXPECT_TRUE(m_end.Equals(o_end));
}
+ // MonoDelta& MonoDelta::operator+=(const MonoDelta& delta);
+ {
+ MonoDelta d0 = MonoDelta::FromNanoseconds(0);
+ MonoDelta d1 = MonoDelta::FromNanoseconds(1);
+ MonoDelta d1_prev = d1;
+ d1 += d0;
+ ASSERT_EQ(d1_prev, d1);
+ ASSERT_EQ(1, d1.ToNanoseconds());
+ d0 += d1;
+ ASSERT_EQ(d1, d0);
+ ASSERT_EQ(1, d0.ToNanoseconds());
+ d1 += d1_prev;
+ ASSERT_EQ(2, d1.ToNanoseconds());
+
+ MonoDelta d2 = MonoDelta::FromNanoseconds(-1);
+ d1 += d2;
+ ASSERT_EQ(1, d1.ToNanoseconds());
+ d2 += d1;
+ ASSERT_EQ(0, d2.ToNanoseconds());
+ }
+
+ // MonoDelta& MonoDelta::operator-=(const MonoDelta& delta);
+ {
+ MonoDelta d0 = MonoDelta::FromNanoseconds(0);
+ MonoDelta d1 = MonoDelta::FromNanoseconds(1);
+ MonoDelta d1_prev = d1;
+ d1 -= d0;
+ ASSERT_EQ(d1_prev, d1);
+ ASSERT_EQ(1, d1.ToNanoseconds());
+ d0 -= d1;
+ ASSERT_EQ(-1, d0.ToNanoseconds());
+
+ MonoDelta d2 = MonoDelta::FromNanoseconds(-2);
+ d0 -= d2;
+ ASSERT_EQ(1, d0.ToNanoseconds());
+ d2 -= d0;
+ ASSERT_EQ(-3, d2.ToNanoseconds());
+ }
+
// bool operator==(const MonoDelta& lhs, const MonoDelta& rhs);
{
MonoDelta dn = MonoDelta::FromNanoseconds(0);
diff --git a/src/kudu/util/monotime.cc b/src/kudu/util/monotime.cc
index b0299cc..102789a 100644
--- a/src/kudu/util/monotime.cc
+++ b/src/kudu/util/monotime.cc
@@ -63,7 +63,7 @@ MonoDelta MonoDelta::FromNanoseconds(int64_t ns) {
}
MonoDelta::MonoDelta()
- : nano_delta_(kUninitialized) {
+ : nano_delta_(kUninitialized) {
}
bool MonoDelta::Initialized() const {
@@ -145,6 +145,10 @@ void MonoDelta::ToTimeVal(struct timeval *tv) const {
}
}
+void MonoDelta::ToTimeSpec(struct timespec* ts) const {
+ DCHECK(Initialized());
+ NanosToTimeSpec(nano_delta_, ts);
+}
void MonoDelta::NanosToTimeSpec(int64_t nanos, struct timespec* ts) {
ts->tv_sec = nanos / MonoTime::kNanosecondsPerSecond;
@@ -158,9 +162,14 @@ void MonoDelta::NanosToTimeSpec(int64_t nanos, struct timespec* ts) {
}
}
-void MonoDelta::ToTimeSpec(struct timespec *ts) const {
- DCHECK(Initialized());
- NanosToTimeSpec(nano_delta_, ts);
+MonoDelta& MonoDelta::operator+=(const MonoDelta& delta) {
+ nano_delta_ += delta.nano_delta_;
+ return *this;
+}
+
+MonoDelta& MonoDelta::operator-=(const MonoDelta& delta) {
+ nano_delta_ -= delta.nano_delta_;
+ return *this;
}
///
@@ -238,7 +247,7 @@ MonoTime& MonoTime::operator-=(const MonoDelta& delta) {
return *this;
}
-MonoTime::MonoTime(const struct timespec &ts) KUDU_MONOTIME_NOEXCEPT {
+MonoTime::MonoTime(const struct timespec& ts) KUDU_MONOTIME_NOEXCEPT {
// Monotonic time resets when the machine reboots. The 64-bit limitation
// means that we can't represent times larger than 292 years, which should be
// adequate.
diff --git a/src/kudu/util/monotime.h b/src/kudu/util/monotime.h
index 7943019..60ce205 100644
--- a/src/kudu/util/monotime.h
+++ b/src/kudu/util/monotime.h
@@ -130,7 +130,7 @@ class KUDU_EXPORT MonoDelta {
///
/// @param [out] ts
/// Placeholder for the result value.
- void ToTimeSpec(struct timespec *ts) const;
+ void ToTimeSpec(struct timespec* ts) const;
/// Convert a nanosecond value to a timespec.
///
@@ -140,6 +140,24 @@ class KUDU_EXPORT MonoDelta {
/// Placeholder for the resulting timespec representation.
static void NanosToTimeSpec(int64_t nanos, struct timespec* ts);
+ /// @name Syntactic sugar: increment/decrement operators for MonoDelta.
+ ///@{
+ ///
+ /// Add a delta to current time interval.
+ ///
+ /// @param [in] delta
+ /// The delta to add.
+ /// @return Reference to the modified object.
+ MonoDelta& operator+=(const MonoDelta& delta);
+
+ /// Substract a delta from current time interval.
+ ///
+ /// @param [in] delta
+ /// The delta to substract.
+ /// @return Reference to the modified object.
+ MonoDelta& operator-=(const MonoDelta& delta);
+ ///@}
+
private:
static const int64_t kUninitialized;
@@ -270,7 +288,7 @@ class KUDU_EXPORT MonoTime {
FRIEND_TEST(TestMonoTime, TestTimeSpec);
FRIEND_TEST(TestMonoTime, TestDeltaConversions);
- explicit MonoTime(const struct timespec &ts) KUDU_MONOTIME_NOEXCEPT;
+ explicit MonoTime(const struct timespec& ts) KUDU_MONOTIME_NOEXCEPT;
explicit MonoTime(int64_t nanos) KUDU_MONOTIME_NOEXCEPT;
double ToSeconds() const;
int64_t nanos_;
[kudu] 01/02: [kserver] fix const-correctness for getter methods
Posted by al...@apache.org.
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 2187f9c1c8d8b98ffbeb464f16d2f52f8c76d3ba
Author: Alexey Serbin <al...@apache.org>
AuthorDate: Sun Aug 9 21:11:27 2020 -0700
[kserver] fix const-correctness for getter methods
Changed signature of the getter methods in kserver to be const-correct
as per [1].
This patch does not contain any functional changes.
[1] https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/const.md
Change-Id: Id845e36ab99b3b9bd5c4ccb5eb6263a96acd5a0a
Reviewed-on: http://gerrit.cloudera.org:8080/16316
Tested-by: Alexey Serbin <as...@cloudera.com>
Reviewed-by: Andrew Wong <aw...@cloudera.com>
---
src/kudu/kserver/kserver.h | 9 ++++-----
1 file changed, 4 insertions(+), 5 deletions(-)
diff --git a/src/kudu/kserver/kserver.h b/src/kudu/kserver/kserver.h
index f8b127f..37a7ffc 100644
--- a/src/kudu/kserver/kserver.h
+++ b/src/kudu/kserver/kserver.h
@@ -59,13 +59,12 @@ class KuduServer : public server::ServerBase {
// Shuts down a KuduServer instance.
void Shutdown() override;
- ThreadPool* tablet_prepare_pool() const { return tablet_prepare_pool_.get(); }
- ThreadPool* tablet_apply_pool() const { return tablet_apply_pool_.get(); }
- ThreadPool* raft_pool() const { return raft_pool_.get(); }
- scoped_refptr<AtomicGauge<int32_t>> num_raft_leaders() const { return num_raft_leaders_; }
+ ThreadPool* tablet_prepare_pool() { return tablet_prepare_pool_.get(); }
+ ThreadPool* tablet_apply_pool() { return tablet_apply_pool_.get(); }
+ ThreadPool* raft_pool() { return raft_pool_.get(); }
+ scoped_refptr<AtomicGauge<int32_t>> num_raft_leaders() { return num_raft_leaders_; }
private:
-
// Thread pool for preparing ops, shared between all tablets.
std::unique_ptr<ThreadPool> tablet_prepare_pool_;