From ef4bb499c2befa846a0d332f708d14c7bd85ff4b Mon Sep 17 00:00:00 2001 From: Yuval Ariel Date: Mon, 19 Dec 2022 10:19:28 +0200 Subject: [PATCH] CR#1 --- db/column_family.cc | 17 ++- db/column_family.h | 11 +- db/column_family_test.cc | 263 ++++++++++++++++++++---------------- db/write_controller_test.cc | 1 + include/rocksdb/options.h | 7 +- tools/db_bench_tool.cc | 3 +- 6 files changed, 168 insertions(+), 134 deletions(-) diff --git a/db/column_family.cc b/db/column_family.cc index b3ad9c8278..d14deca44b 100644 --- a/db/column_family.cc +++ b/db/column_family.cc @@ -882,8 +882,8 @@ int GetL0ThresholdSpeedupCompaction(int level0_file_num_compaction_trigger, } // namespace namespace { -const uint64_t Gb = 1073741824u; -const uint64_t Mb = 1048576u; +const uint64_t Gb = 1ull << 30; +const uint64_t Mb = 1ull << 20; const uint64_t kMinWriteRate = 16 * 1024u; // Minimum write rate 16KB/s. } // namespace @@ -893,8 +893,9 @@ std::unique_ptr ColumnFamilyData::DynamicSetupDelay( WriteStallCause& write_stall_cause) { uint64_t max_write_rate = write_controller->max_delayed_write_rate(); - const double rate_divider = CalculateWriteDelayDivider( - compaction_needed_bytes, write_stall_cause, mutable_cf_options); + const double rate_divider = + CalculateWriteDelayDividerAndMaybeUpdateWriteStallCause( + compaction_needed_bytes, mutable_cf_options, write_stall_cause); assert(rate_divider >= 1); auto write_rate = static_cast(max_write_rate / rate_divider); if (write_rate < kMinWriteRate) { @@ -945,10 +946,11 @@ ColumnFamilyData::GetWriteStallConditionAndCause( // Delay divider is by how much we divide the users delayed_write_rate. // E.g. divider 10 will result in 10 Mb/s from users 100 Mb/s. // The rate is reduced linearly according to the range from slowdown to stop. -double ColumnFamilyData::CalculateWriteDelayDivider( +double +ColumnFamilyData::CalculateWriteDelayDividerAndMaybeUpdateWriteStallCause( uint64_t compaction_needed_bytes, - ColumnFamilyData::WriteStallCause& write_stall_cause, - const MutableCFOptions& mutable_cf_options) { + const MutableCFOptions& mutable_cf_options, + ColumnFamilyData::WriteStallCause& write_stall_cause) { assert(current_ != nullptr); const auto* vstorage = current_->storage_info(); @@ -973,6 +975,7 @@ double ColumnFamilyData::CalculateWriteDelayDivider( auto hard_limit = mutable_cf_options.hard_pending_compaction_bytes_limit; // soft_limit != hard_limit here. we're in a kDelayed state here and not // stop. + assert(hard_limit > soft_limit); uint64_t soft_hard_range = hard_limit - soft_limit; // change rate every 1G change or 100Mb if soft_hard_range is too small. auto step_size = soft_hard_range > Gb ? Gb : 100 * Mb; diff --git a/db/column_family.h b/db/column_family.h index 821d67e070..792e46065c 100644 --- a/db/column_family.h +++ b/db/column_family.h @@ -488,8 +488,8 @@ class ColumnFamilyData { double TEST_CalculateWriteDelayDivider( uint64_t compaction_needed_bytes, WriteStallCause& write_stall_cause, const MutableCFOptions& mutable_cf_options) { - return CalculateWriteDelayDivider(compaction_needed_bytes, - write_stall_cause, mutable_cf_options); + return CalculateWriteDelayDividerAndMaybeUpdateWriteStallCause( + compaction_needed_bytes, write_stall_cause, mutable_cf_options); } private: @@ -498,9 +498,10 @@ class ColumnFamilyData { const MutableCFOptions& mutable_cf_options, WriteStallCause& write_stall_cause); - double CalculateWriteDelayDivider(uint64_t compaction_needed_bytes, - WriteStallCause& write_stall_cause, - const MutableCFOptions& mutable_cf_options); + double CalculateWriteDelayDividerAndMaybeUpdateWriteStallCause( + uint64_t compaction_needed_bytes, + const MutableCFOptions& mutable_cf_options, + WriteStallCause& write_stall_cause); public: void set_initialized() { initialized_.store(true); } diff --git a/db/column_family_test.cc b/db/column_family_test.cc index 470d354ddd..7972c00ae2 100644 --- a/db/column_family_test.cc +++ b/db/column_family_test.cc @@ -539,10 +539,10 @@ class ColumnFamilyTestBase : public testing::Test { ROCKSDB_NAMESPACE::ColumnFamilyData::WriteStallCause::kNone; dbfull()->TEST_LockMutex(); - double increment = cfd->TEST_CalculateWriteDelayDivider( + double divider = cfd->TEST_CalculateWriteDelayDivider( compaction_needed_bytes, write_stall_cause, mutable_cf_options); dbfull()->TEST_UnlockMutex(); - return increment; + return divider; } std::vector handles_; @@ -570,6 +570,12 @@ INSTANTIATE_TEST_CASE_P(FormatDef, ColumnFamilyTest, INSTANTIATE_TEST_CASE_P(FormatLatest, ColumnFamilyTest, testing::Values(kLatestFormatVersion)); +#define CALL_WRAPPER(func) \ + func; \ + ASSERT_FALSE(HasFailure()); + +// The params for this suite are the Format Version and whether +// use_dynamic_delay is used class ColumnFamilyTestWithDynamic : public ColumnFamilyTestBase, virtual public ::testing::WithParamInterface> { @@ -581,8 +587,8 @@ class ColumnFamilyTestWithDynamic uint64_t pending_bytes_to_set, int times_delayed, const MutableCFOptions& mutable_cf_options, - bool is_db_write_stopped, bool needs_delay, - int l0_files = 0) { + bool expected_is_db_write_stopped, + bool expected_needs_delay, int l0_files = 0) { VersionStorageInfo* vstorage = cfd->current()->storage_info(); vstorage->TEST_set_estimated_compaction_needed_bytes(pending_bytes_to_set); if (l0_files > 0) { @@ -590,25 +596,29 @@ class ColumnFamilyTestWithDynamic } RecalculateWriteStallConditions(cfd, mutable_cf_options); - CheckAssertions(is_db_write_stopped, needs_delay); + CheckAssertions(expected_is_db_write_stopped, expected_needs_delay); - double rate_multiplier = 0; - if (db_options_.use_dynamic_delay && needs_delay) { - rate_multiplier = CalculateWriteDelayDivider( + double rate_divider = 0; + if (db_options_.use_dynamic_delay && expected_needs_delay) { + rate_divider = CalculateWriteDelayDivider( cfd, vstorage->estimated_compaction_needed_bytes(), mutable_cf_options); } else { - rate_multiplier = 1; + rate_divider = 1; for (int i = 0; i < times_delayed; i++) { - rate_multiplier *= 1.25; + // each time SetupDelay is called the rate is divided by + // kIncSlowdownRatio (0.8) + rate_divider *= 1.25; } } - return rate_multiplier; + return rate_divider; } - void CheckAssertions(bool is_db_write_stopped, bool needs_delay) { - ASSERT_TRUE(IsDbWriteStopped() == is_db_write_stopped); - ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay() == needs_delay); + void CheckAssertions(bool expected_is_db_write_stopped, + bool expected_needs_delay) { + ASSERT_TRUE(IsDbWriteStopped() == expected_is_db_write_stopped); + ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay() == + expected_needs_delay); } }; @@ -2827,112 +2837,126 @@ TEST_P(ColumnFamilyTestWithDynamic, WriteStallSingleColumnFamily) { bool NotStopped = false; bool Delayed = true; bool NotDelayed = false; - double rate_mult; + double rate_divider; - SetDelayAndCalculateRate(cfd, 50 Gb, 0 /* times_delayed*/, mutable_cf_options, - NotStopped, NotDelayed); + CALL_WRAPPER(SetDelayAndCalculateRate(cfd, 50 Gb, 0 /* times_delayed*/, + mutable_cf_options, NotStopped, + NotDelayed)); - rate_mult = SetDelayAndCalculateRate(cfd, 201 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 201 Gb, 0 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); ASSERT_EQ(6, dbfull()->TEST_BGCompactionsAllowed()); - rate_mult = SetDelayAndCalculateRate(cfd, 400 Gb, 1 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 400 Gb, 1 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); ASSERT_EQ(6, dbfull()->TEST_BGCompactionsAllowed()); - rate_mult = SetDelayAndCalculateRate(cfd, 500 Gb, 2 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 500 Gb, 2 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 450 Gb, 1 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 450 Gb, 1 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 205 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 205 Gb, 0 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 202 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 202 Gb, 0 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 201 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 201 Gb, 0 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = + rate_divider = CALL_WRAPPER( SetDelayAndCalculateRate(cfd, 198 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, NotDelayed); + mutable_cf_options, NotStopped, NotDelayed)); - rate_mult = SetDelayAndCalculateRate(cfd, 399 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 399 Gb, 0 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 599 Gb, 1 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 599 Gb, 1 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 2001 Gb, 0 /* times_delayed*/, - mutable_cf_options, Stopped, NotDelayed); + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 2001 Gb, 0 /* times_delayed*/, + mutable_cf_options, Stopped, NotDelayed)); ASSERT_EQ(6, dbfull()->TEST_BGCompactionsAllowed()); - rate_mult = SetDelayAndCalculateRate(cfd, 3001 Gb, 0 /* times_delayed*/, - mutable_cf_options, Stopped, NotDelayed); + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 3001 Gb, 0 /* times_delayed*/, + mutable_cf_options, Stopped, NotDelayed)); - rate_mult = SetDelayAndCalculateRate(cfd, 390 Gb, 1 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 390 Gb, 1 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = + rate_divider = CALL_WRAPPER( SetDelayAndCalculateRate(cfd, 100 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, NotDelayed); + mutable_cf_options, NotStopped, NotDelayed)); - rate_mult = SetDelayAndCalculateRate(cfd, 100 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed, - 100 /* l0_files*/); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER(SetDelayAndCalculateRate( + cfd, 100 Gb, 0 /* times_delayed*/, mutable_cf_options, NotStopped, + Delayed, 100 /* l0_files*/)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); ASSERT_EQ(6, dbfull()->TEST_BGCompactionsAllowed()); - rate_mult = SetDelayAndCalculateRate(cfd, 100 Gb, 1 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed, - 101 /* l0_files*/); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER(SetDelayAndCalculateRate( + cfd, 100 Gb, 1 /* times_delayed*/, mutable_cf_options, NotStopped, + Delayed, 101 /* l0_files*/)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 300 Gb, 2 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed, - 0 /* l0_files*/); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER(SetDelayAndCalculateRate( + cfd, 300 Gb, 2 /* times_delayed*/, mutable_cf_options, NotStopped, + Delayed, 0 /* l0_files*/)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 300 Gb, 3 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed, - 101 /* l0_files*/); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER(SetDelayAndCalculateRate( + cfd, 300 Gb, 3 /* times_delayed*/, mutable_cf_options, NotStopped, + Delayed, 101 /* l0_files*/)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 200 Gb, 2 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 200 Gb, 2 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); vstorage->set_l0_delay_trigger_count(0); - rate_mult = + rate_divider = CALL_WRAPPER( SetDelayAndCalculateRate(cfd, 0 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, NotDelayed); + mutable_cf_options, NotStopped, NotDelayed)); mutable_cf_options.disable_auto_compactions = true; dbfull()->TEST_write_controler().set_delayed_write_rate(kBaseRate); @@ -2940,31 +2964,31 @@ TEST_P(ColumnFamilyTestWithDynamic, WriteStallSingleColumnFamily) { ASSERT_TRUE(!IsDbWriteStopped()); ASSERT_TRUE(!dbfull()->TEST_write_controler().NeedsDelay()); - rate_mult = SetDelayAndCalculateRate(cfd, 0 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, - NotDelayed, 50 /* l0_files*/); + rate_divider = CALL_WRAPPER(SetDelayAndCalculateRate( + cfd, 0 Gb, 0 /* times_delayed*/, mutable_cf_options, NotStopped, + NotDelayed, 50 /* l0_files*/)); ASSERT_EQ(0, GetDbDelayedWriteRate()); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + ASSERT_EQ(static_cast(kBaseRate / rate_divider), dbfull()->TEST_write_controler().delayed_write_rate()); - rate_mult = SetDelayAndCalculateRate(cfd, 300 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, - NotDelayed, 60 /* l0_files*/); + rate_divider = CALL_WRAPPER(SetDelayAndCalculateRate( + cfd, 300 Gb, 0 /* times_delayed*/, mutable_cf_options, NotStopped, + NotDelayed, 60 /* l0_files*/)); ASSERT_EQ(0, GetDbDelayedWriteRate()); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + ASSERT_EQ(static_cast(kBaseRate / rate_divider), dbfull()->TEST_write_controler().delayed_write_rate()); mutable_cf_options.disable_auto_compactions = false; - rate_mult = SetDelayAndCalculateRate(cfd, 500 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed, - 70 /* l0_files*/); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER(SetDelayAndCalculateRate( + cfd, 500 Gb, 0 /* times_delayed*/, mutable_cf_options, NotStopped, + Delayed, 70 /* l0_files*/)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 501 Gb, 1 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed, - 71 /* l0_files*/); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER(SetDelayAndCalculateRate( + cfd, 501 Gb, 1 /* times_delayed*/, mutable_cf_options, NotStopped, + Delayed, 71 /* l0_files*/)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); } @@ -3056,53 +3080,56 @@ TEST_P(ColumnFamilyTestWithDynamic, WriteStallTwoColumnFamilies) { bool NotStopped = false; bool Delayed = true; bool NotDelayed = false; - double rate_mult; + double rate_divider; - rate_mult = + rate_divider = CALL_WRAPPER( SetDelayAndCalculateRate(cfd, 50 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, NotDelayed); + mutable_cf_options, NotStopped, NotDelayed)); - rate_mult = + rate_divider = CALL_WRAPPER( SetDelayAndCalculateRate(cfd1, 201 Gb, 0 /* times_delayed*/, - mutable_cf_options1, NotStopped, NotDelayed); + mutable_cf_options1, NotStopped, NotDelayed)); - rate_mult = + rate_divider = CALL_WRAPPER( SetDelayAndCalculateRate(cfd1, 600 Gb, 0 /* times_delayed*/, - mutable_cf_options1, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + mutable_cf_options1, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 70 Gb, 0 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 70 Gb, 0 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = + rate_divider = CALL_WRAPPER( SetDelayAndCalculateRate(cfd1, 800 Gb, 1 /* times_delayed*/, - mutable_cf_options1, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + mutable_cf_options1, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 300 Gb, 2 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 300 Gb, 2 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = + rate_divider = CALL_WRAPPER( SetDelayAndCalculateRate(cfd1, 700 Gb, 1 /* times_delayed*/, - mutable_cf_options1, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + mutable_cf_options1, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = SetDelayAndCalculateRate(cfd, 500 Gb, 2 /* times_delayed*/, - mutable_cf_options, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + rate_divider = CALL_WRAPPER( + SetDelayAndCalculateRate(cfd, 500 Gb, 2 /* times_delayed*/, + mutable_cf_options, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); - rate_mult = + rate_divider = CALL_WRAPPER( SetDelayAndCalculateRate(cfd1, 600 Gb, 1 /* times_delayed*/, - mutable_cf_options1, NotStopped, Delayed); - ASSERT_EQ(static_cast(kBaseRate / rate_mult), + mutable_cf_options1, NotStopped, Delayed)); + ASSERT_EQ(static_cast(kBaseRate / rate_divider), GetDbDelayedWriteRate()); } diff --git a/db/write_controller_test.cc b/db/write_controller_test.cc index cb0295ebe1..8ae3611935 100644 --- a/db/write_controller_test.cc +++ b/db/write_controller_test.cc @@ -21,6 +21,7 @@ class TimeSetClock : public SystemClockWrapper { uint64_t NowNanos() override { return now_micros_ * std::milli::den; } }; } // namespace +// The param is whether dynamic_delay is used or not class WriteControllerTest : public testing::TestWithParam { public: WriteControllerTest() { clock_ = std::make_shared(); } diff --git a/include/rocksdb/options.h b/include/rocksdb/options.h index 07b2c5b219..9aa83cd12e 100644 --- a/include/rocksdb/options.h +++ b/include/rocksdb/options.h @@ -1057,9 +1057,10 @@ struct DBOptions { // enables a different kind of calculation (instead of SetupDelay) for the // delayed_write_rate whenever a call to RecalculateWriteStallConditions is // made. the calculation itself is explained in the ticket and in the code of - // CalculateWriteDelayDivider but in general its a linear decline of write - // speed with regards to by how much the system CURRENTLY exceeds the slowdown - // (soft_pending_compaction_bytes_limit and level0_slowdown_writes_trigger). + // CalculateWriteDelayDividerAndMaybeUpdateWriteStallCause but in general its + // a linear decline of write speed with regards to by how much the system + // CURRENTLY exceeds the slowdown (soft_pending_compaction_bytes_limit and + // level0_slowdown_writes_trigger). // // Default: true bool use_dynamic_delay = true; diff --git a/tools/db_bench_tool.cc b/tools/db_bench_tool.cc index 9612ec5feb..1b2475a1e5 100644 --- a/tools/db_bench_tool.cc +++ b/tools/db_bench_tool.cc @@ -1522,7 +1522,8 @@ DEFINE_uint64(delayed_write_rate, 8388608u, "Limited bytes allowed to DB when soft_rate_limit or " "level0_slowdown_writes_trigger triggers"); -DEFINE_bool(use_dynamic_delay, true, "use dynamic delay"); +DEFINE_bool(use_dynamic_delay, ROCKSDB_NAMESPACE::Options().use_dynamic_delay, + "use dynamic delay"); DEFINE_bool(enable_pipelined_write, true, "Allow WAL and memtable writes to be pipelined");