andreacavalli/rocksdb
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix for flaky test BackupableDBTest.RateLimiting (#7167)

Browse Source 
Summary:
BackupableDBTest.RateLimiting test is failing due to timed out
on our test server. It might be because of nested loops run sequentially that test different type of combinations of parameters. This patch converts the test into parameterized test so that all combinations can be tested out.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/7167

Test Plan: make check -j64

Reviewed By: zhichao-cao

Differential Revision: D22709531

Pulled By: akankshamahajan15

fbshipit-source-id: 95518153e87b3b5311a6c1960a191bca58898786
This commit is contained in:
Akanksha Mahajan 2020-07-24 14:45:45 -07:00 committed by Facebook GitHub Bot
parent 0c5bb10f06
commit 7e37a5918c
1 changed files with 67 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
utilities/backupable/backupable_db_test.cc
View File

@ -1832,25 +1832,47 @@ TEST_F(BackupableDBTest, KeepLogFiles) {
AssertBackupConsistency(0, 0, 500, 600, true); AssertBackupConsistency(0, 0, 500, 600, true);
} }
TEST_F(BackupableDBTest, RateLimiting) { class BackupableDBRateLimitingTestWithParam
size_t const kMicrosPerSec = 1000 * 1000LL; : public BackupableDBTest,
public testing::WithParamInterface<
std::tuple<bool /* make throttle */,
int /* 0 = single threaded, 1 = multi threaded*/,
std::pair<uint64_t, uint64_t> /* limits */>> {
public:
BackupableDBRateLimitingTestWithParam() {}
};
uint64_t const MB = 1024 * 1024; uint64_t const MB = 1024 * 1024;
const std::vector<std::pair<uint64_t, uint64_t>> limits( INSTANTIATE_TEST_CASE_P(
{{1 * MB, 5 * MB}, {2 * MB, 3 * MB}}); RateLimiting, BackupableDBRateLimitingTestWithParam,
::testing::Values(std::make_tuple(false, 0, std::make_pair(1 * MB, 5 * MB)),
std::make_tuple(false, 0, std::make_pair(2 * MB, 3 * MB)),
std::make_tuple(false, 1, std::make_pair(1 * MB, 5 * MB)),
std::make_tuple(false, 1, std::make_pair(2 * MB, 3 * MB)),
std::make_tuple(true, 0, std::make_pair(1 * MB, 5 * MB)),
std::make_tuple(true, 0, std::make_pair(2 * MB, 3 * MB)),
std::make_tuple(true, 1, std::make_pair(1 * MB, 5 * MB)),
std::make_tuple(true, 1,
std::make_pair(2 * MB, 3 * MB))));
TEST_P(BackupableDBRateLimitingTestWithParam, RateLimiting) {
size_t const kMicrosPerSec = 1000 * 1000LL;
std::shared_ptr<RateLimiter> backupThrottler(NewGenericRateLimiter(1)); std::shared_ptr<RateLimiter> backupThrottler(NewGenericRateLimiter(1));
std::shared_ptr<RateLimiter> restoreThrottler(NewGenericRateLimiter(1)); std::shared_ptr<RateLimiter> restoreThrottler(NewGenericRateLimiter(1));
for (bool makeThrottler : {false, true}) { bool makeThrottler = std::get<0>(GetParam());
if (makeThrottler) { if (makeThrottler) {
backupable_options_->backup_rate_limiter = backupThrottler; backupable_options_->backup_rate_limiter = backupThrottler;
backupable_options_->restore_rate_limiter = restoreThrottler; backupable_options_->restore_rate_limiter = restoreThrottler;
} }
// iter 0 -- single threaded // iter 0 -- single threaded
// iter 1 -- multi threaded // iter 1 -- multi threaded
for (int iter = 0; iter < 2; ++iter) { int iter = std::get<1>(GetParam());
for (const auto& limit : limits) { const std::pair<uint64_t, uint64_t> limit = std::get<2>(GetParam());
// destroy old data // destroy old data
DestroyDB(dbname_, Options()); DestroyDB(dbname_, Options());
if (makeThrottler) { if (makeThrottler) {
@ -1868,8 +1890,7 @@ TEST_F(BackupableDBTest, RateLimiting) {
auto start_backup = db_chroot_env_->NowMicros(); auto start_backup = db_chroot_env_->NowMicros();
ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(), false)); ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(), false));
auto backup_time = db_chroot_env_->NowMicros() - start_backup; auto backup_time = db_chroot_env_->NowMicros() - start_backup;
auto rate_limited_backup_time = auto rate_limited_backup_time = (bytes_written * kMicrosPerSec) / limit.first;
(bytes_written * kMicrosPerSec) / limit.first;
ASSERT_GT(backup_time, 0.8 * rate_limited_backup_time); ASSERT_GT(backup_time, 0.8 * rate_limited_backup_time);
CloseDBAndBackupEngine(); CloseDBAndBackupEngine();
@ -1885,9 +1906,6 @@ TEST_F(BackupableDBTest, RateLimiting) {
AssertBackupConsistency(0, 0, 100000, 100010); AssertBackupConsistency(0, 0, 100000, 100010);
} }
}
}
}
TEST_F(BackupableDBTest, ReadOnlyBackupEngine) { TEST_F(BackupableDBTest, ReadOnlyBackupEngine) {
DestroyDB(dbname_, options_); DestroyDB(dbname_, options_);