From 88f2f89068c429e273a39cfa323a2a263031edf4 Mon Sep 17 00:00:00 2001 From: Siying Dong Date: Mon, 14 Oct 2013 15:12:15 -0700 Subject: [PATCH] Change Function names from Compaction->Flush When they really mean Flush Summary: When I debug the unit test failures when enabling background flush thread, I feel the function names can be made clearer for people to understand. Also, if the names are fixed, in many places, some tests' bugs are obvious (and some of those tests are failing). This patch is to clean it up for future maintenance. Test Plan: Run test suites. Reviewers: haobo, dhruba, xjin Reviewed By: dhruba CC: leveldb Differential Revision: https://reviews.facebook.net/D13431 --- db/corruption_test.cc | 16 +++--- db/db_impl.cc | 50 ++++++++++-------- db/db_impl.h | 16 +++--- db/db_test.cc | 96 +++++++++++++++++------------------ db/deletefile_test.cc | 8 +-- helpers/memenv/memenv_test.cc | 2 +- tools/reduce_levels_test.cc | 2 +- 7 files changed, 98 insertions(+), 92 deletions(-) diff --git a/db/corruption_test.cc b/db/corruption_test.cc index ecd5b5344..f835edc68 100644 --- a/db/corruption_test.cc +++ b/db/corruption_test.cc @@ -230,7 +230,7 @@ TEST(CorruptionTest, NewFileErrorDuringWrite) { TEST(CorruptionTest, TableFile) { Build(100); DBImpl* dbi = reinterpret_cast(db_); - dbi->TEST_CompactMemTable(); + dbi->TEST_FlushMemTable(); dbi->TEST_CompactRange(0, nullptr, nullptr); dbi->TEST_CompactRange(1, nullptr, nullptr); @@ -241,7 +241,7 @@ TEST(CorruptionTest, TableFile) { TEST(CorruptionTest, TableFileIndexData) { Build(10000); // Enough to build multiple Tables DBImpl* dbi = reinterpret_cast(db_); - dbi->TEST_CompactMemTable(); + dbi->TEST_FlushMemTable(); Corrupt(kTableFile, -2000, 500); Reopen(); @@ -279,7 +279,7 @@ TEST(CorruptionTest, SequenceNumberRecovery) { TEST(CorruptionTest, CorruptedDescriptor) { ASSERT_OK(db_->Put(WriteOptions(), "foo", "hello")); DBImpl* dbi = reinterpret_cast(db_); - dbi->TEST_CompactMemTable(); + dbi->TEST_FlushMemTable(); dbi->TEST_CompactRange(0, nullptr, nullptr); Corrupt(kDescriptorFile, 0, 1000); @@ -296,7 +296,7 @@ TEST(CorruptionTest, CorruptedDescriptor) { TEST(CorruptionTest, CompactionInputError) { Build(10); DBImpl* dbi = reinterpret_cast(db_); - dbi->TEST_CompactMemTable(); + dbi->TEST_FlushMemTable(); const int last = dbi->MaxMemCompactionLevel(); ASSERT_EQ(1, Property("rocksdb.num-files-at-level" + NumberToString(last))); @@ -319,11 +319,11 @@ TEST(CorruptionTest, CompactionInputErrorParanoid) { for (int level = 1; level < dbi->NumberLevels(); level++) { dbi->Put(WriteOptions(), "", "begin"); dbi->Put(WriteOptions(), "~", "end"); - dbi->TEST_CompactMemTable(); + dbi->TEST_FlushMemTable(); } Build(10); - dbi->TEST_CompactMemTable(); + dbi->TEST_FlushMemTable(); ASSERT_EQ(1, Property("rocksdb.num-files-at-level0")); Corrupt(kTableFile, 100, 1); @@ -341,7 +341,7 @@ TEST(CorruptionTest, CompactionInputErrorParanoid) { TEST(CorruptionTest, UnrelatedKeys) { Build(10); DBImpl* dbi = reinterpret_cast(db_); - dbi->TEST_CompactMemTable(); + dbi->TEST_FlushMemTable(); Corrupt(kTableFile, 100, 1); std::string tmp1, tmp2; @@ -349,7 +349,7 @@ TEST(CorruptionTest, UnrelatedKeys) { std::string v; ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v)); ASSERT_EQ(Value(1000, &tmp2).ToString(), v); - dbi->TEST_CompactMemTable(); + dbi->TEST_FlushMemTable(); ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v)); ASSERT_EQ(Value(1000, &tmp2).ToString(), v); } diff --git a/db/db_impl.cc b/db/db_impl.cc index 57d5916b7..cfb523364 100644 --- a/db/db_impl.cc +++ b/db/db_impl.cc @@ -924,13 +924,13 @@ Status DBImpl::WriteLevel0Table(std::vector &mems, VersionEdit* edit, return s; } -Status DBImpl::CompactMemTable(bool* madeProgress) { +Status DBImpl::FlushMemTableToOutputFile(bool* madeProgress) { mutex_.AssertHeld(); assert(imm_.size() != 0); if (!imm_.IsFlushPending(options_.min_write_buffer_number_to_merge)) { - Log(options_.info_log, "Memcompaction already in progress"); - Status s = Status::IOError("Memcompaction already in progress"); + Log(options_.info_log, "FlushMemTableToOutputFile already in progress"); + Status s = Status::IOError("FlushMemTableToOutputFile already in progress"); return s; } @@ -998,7 +998,7 @@ void DBImpl::CompactRange(const Slice* begin, const Slice* end, } } } - TEST_CompactMemTable(); // TODO(sanjay): Skip if memtable does not overlap + TEST_FlushMemTable(); // TODO(sanjay): Skip if memtable does not overlap for (int level = 0; level < max_level_with_files; level++) { TEST_CompactRange(level, begin, end); } @@ -1345,7 +1345,7 @@ void DBImpl::TEST_CompactRange(int level, const Slice* begin,const Slice* end) { if (bg_compaction_scheduled_ == LargeNumber) { bg_compaction_scheduled_ = newvalue; } - MaybeScheduleCompaction(); + MaybeScheduleFlushOrCompaction(); while (manual_compaction_ == &manual) { bg_cv_.Wait(); } @@ -1366,12 +1366,12 @@ Status DBImpl::FlushMemTable(const FlushOptions& options) { Status s = Write(WriteOptions(), nullptr); if (s.ok() && options.wait) { // Wait until the compaction completes - s = WaitForCompactMemTable(); + s = WaitForFlushMemTable(); } return s; } -Status DBImpl::WaitForCompactMemTable() { +Status DBImpl::WaitForFlushMemTable() { Status s; // Wait until the compaction completes MutexLock l(&mutex_); @@ -1384,16 +1384,21 @@ Status DBImpl::WaitForCompactMemTable() { return s; } -Status DBImpl::TEST_CompactMemTable() { +Status DBImpl::TEST_FlushMemTable() { return FlushMemTable(FlushOptions()); } -Status DBImpl::TEST_WaitForCompactMemTable() { - return WaitForCompactMemTable(); +Status DBImpl::TEST_WaitForFlushMemTable() { + return WaitForFlushMemTable(); } Status DBImpl::TEST_WaitForCompact() { // Wait until the compaction completes + + // TODO: a bug here. This function actually does not necessarily + // wait for compact. It actually waits for scheduled compaction + // OR flush to finish. + MutexLock l(&mutex_); while ((bg_compaction_scheduled_ || bg_flush_scheduled_) && bg_error_.ok()) { @@ -1402,7 +1407,7 @@ Status DBImpl::TEST_WaitForCompact() { return bg_error_; } -void DBImpl::MaybeScheduleCompaction() { +void DBImpl::MaybeScheduleFlushOrCompaction() { mutex_.AssertHeld(); if (bg_work_gate_closed_) { // gate closed for backgrond work @@ -1442,9 +1447,9 @@ Status DBImpl::BackgroundFlush() { while (stat.ok() && imm_.IsFlushPending(options_.min_write_buffer_number_to_merge)) { Log(options_.info_log, - "BackgroundCallFlush doing CompactMemTable, flush slots available %d", + "BackgroundCallFlush doing FlushMemTableToOutputFile, flush slots available %d", options_.max_background_flushes - bg_flush_scheduled_); - stat = CompactMemTable(); + stat = FlushMemTableToOutputFile(); } return stat; } @@ -1521,7 +1526,7 @@ void DBImpl::BackgroundCallCompaction() { // So reschedule another compaction if we made progress in the // last compaction. if (madeProgress) { - MaybeScheduleCompaction(); + MaybeScheduleFlushOrCompaction(); } bg_cv_.SignalAll(); @@ -1535,9 +1540,10 @@ Status DBImpl::BackgroundCompaction(bool* madeProgress, // TODO: remove memtable flush from formal compaction while (imm_.IsFlushPending(options_.min_write_buffer_number_to_merge)) { Log(options_.info_log, - "BackgroundCompaction doing CompactMemTable, compaction slots available %d", + "BackgroundCompaction doing FlushMemTableToOutputFile, compaction slots " + "available %d", options_.max_background_compactions - bg_compaction_scheduled_); - Status stat = CompactMemTable(madeProgress); + Status stat = FlushMemTableToOutputFile(madeProgress); if (!stat.ok()) { return stat; } @@ -1590,7 +1596,7 @@ Status DBImpl::BackgroundCompaction(bool* madeProgress, versions_->ReleaseCompactionFiles(c.get(), status); *madeProgress = true; } else { - MaybeScheduleCompaction(); // do more compaction work in parallel. + MaybeScheduleFlushOrCompaction(); // do more compaction work in parallel. CompactionState* compact = new CompactionState(c.get()); status = DoCompactionWork(compact); CleanupCompaction(compact); @@ -1914,7 +1920,7 @@ Status DBImpl::DoCompactionWork(CompactionState* compact) { const uint64_t imm_start = env_->NowMicros(); mutex_.Lock(); if (imm_.IsFlushPending(options_.min_write_buffer_number_to_merge)) { - CompactMemTable(); + FlushMemTableToOutputFile(); bg_cv_.SignalAll(); // Wakeup MakeRoomForWrite() if necessary } mutex_.Unlock(); @@ -2356,7 +2362,7 @@ Status DBImpl::GetImpl(const ReadOptions& options, if (!options_.disable_seek_compaction && have_stat_update && current->UpdateStats(stats)) { - MaybeScheduleCompaction(); + MaybeScheduleFlushOrCompaction(); } mem->Unref(); imm.UnrefAll(); @@ -2434,7 +2440,7 @@ std::vector DBImpl::MultiGet(const ReadOptions& options, mutex_.Lock(); if (!options_.disable_seek_compaction && have_stat_update && current->UpdateStats(stats)) { - MaybeScheduleCompaction(); + MaybeScheduleFlushOrCompaction(); } mem->Unref(); imm.UnrefAll(); @@ -2853,7 +2859,7 @@ Status DBImpl::MakeRoomForWrite(bool force) { mem_->Ref(); mem_->SetLogNumber(logfile_number_); force = false; // Do not force another compaction if have room - MaybeScheduleCompaction(); + MaybeScheduleFlushOrCompaction(); } } return s; @@ -3229,7 +3235,7 @@ Status DB::Open(const Options& options, const std::string& dbname, DB** dbptr) { if (s.ok()) { impl->mem_->SetLogNumber(impl->logfile_number_); impl->DeleteObsoleteFiles(); - impl->MaybeScheduleCompaction(); + impl->MaybeScheduleFlushOrCompaction(); impl->MaybeScheduleLogDBDeployStats(); } } diff --git a/db/db_impl.h b/db/db_impl.h index efc59d253..ef2ef5944 100644 --- a/db/db_impl.h +++ b/db/db_impl.h @@ -82,11 +82,11 @@ class DBImpl : public DB { // Compact any files in the named level that overlap [*begin, *end] void TEST_CompactRange(int level, const Slice* begin, const Slice* end); - // Force current memtable contents to be compacted. - Status TEST_CompactMemTable(); + // Force current memtable contents to be flushed. + Status TEST_FlushMemTable(); // Wait for memtable compaction - Status TEST_WaitForCompactMemTable(); + Status TEST_WaitForFlushMemTable(); // Wait for any compaction Status TEST_WaitForCompact(); @@ -148,9 +148,9 @@ class DBImpl : public DB { // Delete any unneeded files and stale in-memory entries. void DeleteObsoleteFiles(); - // Compact the in-memory write buffer to disk. Switches to a new + // Flush the in-memory write buffer to storage. Switches to a new // log-file/memtable and writes a new descriptor iff successful. - Status CompactMemTable(bool* madeProgress = nullptr); + Status FlushMemTableToOutputFile(bool* madeProgress = nullptr); Status RecoverLogFile(uint64_t log_number, VersionEdit* edit, @@ -173,14 +173,14 @@ class DBImpl : public DB { // Force current memtable contents to be flushed. Status FlushMemTable(const FlushOptions& options); - // Wait for memtable compaction - Status WaitForCompactMemTable(); + // Wait for memtable flushed + Status WaitForFlushMemTable(); void MaybeScheduleLogDBDeployStats(); static void BGLogDBDeployStats(void* db); void LogDBDeployStats(); - void MaybeScheduleCompaction(); + void MaybeScheduleFlushOrCompaction(); static void BGWorkCompaction(void* db); static void BGWorkFlush(void* db); void BackgroundCallCompaction(); diff --git a/db/db_test.cc b/db/db_test.cc index d0dc26146..b59de240b 100644 --- a/db/db_test.cc +++ b/db/db_test.cc @@ -570,7 +570,7 @@ class DBTest { for (int i = 0; i < n; i++) { Put(small, "begin"); Put(large, "end"); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); } } @@ -739,7 +739,7 @@ TEST(DBTest, GetFromImmutableLayer) { TEST(DBTest, GetFromVersions) { do { ASSERT_OK(Put("foo", "v1")); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ("v1", Get("foo")); } while (ChangeOptions()); } @@ -754,7 +754,7 @@ TEST(DBTest, GetSnapshot) { ASSERT_OK(Put(key, "v2")); ASSERT_EQ("v2", Get(key)); ASSERT_EQ("v1", Get(key, s1)); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ("v2", Get(key)); ASSERT_EQ("v1", Get(key, s1)); db_->ReleaseSnapshot(s1); @@ -770,9 +770,9 @@ TEST(DBTest, GetLevel0Ordering) { // one has a smaller "smallest" key. ASSERT_OK(Put("bar", "b")); ASSERT_OK(Put("foo", "v1")); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_OK(Put("foo", "v2")); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ("v2", Get("foo")); } while (ChangeOptions()); } @@ -784,7 +784,7 @@ TEST(DBTest, GetOrderedByLevels) { ASSERT_EQ("v1", Get("foo")); ASSERT_OK(Put("foo", "v2")); ASSERT_EQ("v2", Get("foo")); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ("v2", Get("foo")); } while (ChangeOptions()); } @@ -822,7 +822,7 @@ TEST(DBTest, GetEncountersEmptyLevel) { compaction_count++; Put("a", "begin"); Put("z", "end"); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); } // Step 2: clear level 1 if necessary. @@ -1668,7 +1668,7 @@ TEST(DBTest, CompactionTrigger) { values.push_back(RandomString(&rnd, 10000)); ASSERT_OK(Put(Key(i), values[i])); } - dbfull()->TEST_WaitForCompactMemTable(); + dbfull()->TEST_WaitForFlushMemTable(); ASSERT_EQ(NumTableFilesAtLevel(0), num + 1); } @@ -1706,7 +1706,7 @@ TEST(DBTest, UniversalCompactionTrigger) { ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000))); key_idx++; } - dbfull()->TEST_WaitForCompactMemTable(); + dbfull()->TEST_WaitForFlushMemTable(); ASSERT_EQ(NumTableFilesAtLevel(0), num + 1); } @@ -1741,7 +1741,7 @@ TEST(DBTest, UniversalCompactionTrigger) { ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000))); key_idx++; } - dbfull()->TEST_WaitForCompactMemTable(); + dbfull()->TEST_WaitForFlushMemTable(); ASSERT_EQ(NumTableFilesAtLevel(0), num + 3); } @@ -1770,7 +1770,7 @@ TEST(DBTest, UniversalCompactionTrigger) { ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000))); key_idx++; } - dbfull()->TEST_WaitForCompactMemTable(); + dbfull()->TEST_WaitForFlushMemTable(); ASSERT_EQ(NumTableFilesAtLevel(0), num + 3); } @@ -1840,7 +1840,7 @@ TEST(DBTest, UniversalCompactionSizeAmplification) { ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000))); key_idx++; } - dbfull()->TEST_WaitForCompactMemTable(); + dbfull()->TEST_WaitForFlushMemTable(); ASSERT_EQ(NumTableFilesAtLevel(0), num + 1); } ASSERT_EQ(NumTableFilesAtLevel(0), 2); @@ -1873,7 +1873,7 @@ TEST(DBTest, UniversalCompactionOptions) { ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000))); key_idx++; } - dbfull()->TEST_WaitForCompactMemTable(); + dbfull()->TEST_WaitForFlushMemTable(); if (num < options.level0_file_num_compaction_trigger - 1) { ASSERT_EQ(NumTableFilesAtLevel(0), num + 1); @@ -1994,7 +1994,7 @@ void MinLevelHelper(DBTest* self, Options& options) { values.push_back(RandomString(&rnd, 10000)); ASSERT_OK(self->Put(Key(i), values[i])); } - self->dbfull()->TEST_WaitForCompactMemTable(); + self->dbfull()->TEST_WaitForFlushMemTable(); ASSERT_EQ(self->NumTableFilesAtLevel(0), num + 1); } @@ -2219,7 +2219,7 @@ TEST(DBTest, CompactionFilter) { snprintf(key, sizeof(key), "B%010d", i); Put(key, value); } - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); // Push all files to the highest level L2. Verify that // the compaction is each level invokes the filter for @@ -2267,7 +2267,7 @@ TEST(DBTest, CompactionFilter) { snprintf(key, sizeof(key), "B%010d", i); Put(key, value); } - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); // push all files to the highest level L2. This // means that all keys should pass at least once @@ -2294,7 +2294,7 @@ TEST(DBTest, CompactionFilter) { snprintf(key, sizeof(key), "B%010d", i); Put(key, value); } - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_NE(NumTableFilesAtLevel(0), 0); ASSERT_EQ(NumTableFilesAtLevel(1), 0); ASSERT_EQ(NumTableFilesAtLevel(2), 0); @@ -2365,7 +2365,7 @@ TEST(DBTest, CompactionFilterWithValueChange) { } // push all files to lower levels - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); dbfull()->TEST_CompactRange(0, nullptr, nullptr); dbfull()->TEST_CompactRange(1, nullptr, nullptr); @@ -2378,7 +2378,7 @@ TEST(DBTest, CompactionFilterWithValueChange) { // push all files to lower levels. This should // invoke the compaction filter for all 100000 keys. - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); dbfull()->TEST_CompactRange(0, nullptr, nullptr); dbfull()->TEST_CompactRange(1, nullptr, nullptr); @@ -2416,14 +2416,14 @@ TEST(DBTest, SparseMerge) { Put(key, value); } Put("C", "vc"); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); dbfull()->TEST_CompactRange(0, nullptr, nullptr); // Make sparse update Put("A", "va2"); Put("B100", "bvalue2"); Put("C", "vc2"); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); // Compactions should not cause us to create a situation where // a file overlaps too much data at the next level. @@ -2599,7 +2599,7 @@ TEST(DBTest, HiddenValuesAreRemoved) { Put("foo", "tiny"); Put("pastfoo2", "v2"); // Advance sequence number one more - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); ASSERT_GT(NumTableFilesAtLevel(0), 0); ASSERT_EQ(big, Get("foo", snapshot)); @@ -2634,7 +2634,7 @@ TEST(DBTest, CompactBetweenSnapshots) { // All entries (including duplicates) exist // before any compaction is triggered. - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); ASSERT_EQ("sixth", Get("foo")); ASSERT_EQ("fourth", Get("foo", snapshot2)); ASSERT_EQ("first", Get("foo", snapshot1)); @@ -2673,21 +2673,21 @@ TEST(DBTest, CompactBetweenSnapshots) { TEST(DBTest, DeletionMarkers1) { Put("foo", "v1"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); const int last = dbfull()->MaxMemCompactionLevel(); ASSERT_EQ(NumTableFilesAtLevel(last), 1); // foo => v1 is now in last level // Place a table at level last-1 to prevent merging with preceding mutation Put("a", "begin"); Put("z", "end"); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ(NumTableFilesAtLevel(last), 1); ASSERT_EQ(NumTableFilesAtLevel(last-1), 1); Delete("foo"); Put("foo", "v2"); ASSERT_EQ(AllEntriesFor("foo"), "[ v2, DEL, v1 ]"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); // Moves to level last-2 + ASSERT_OK(dbfull()->TEST_FlushMemTable()); // Moves to level last-2 if (CurrentOptions().purge_redundant_kvs_while_flush) { ASSERT_EQ(AllEntriesFor("foo"), "[ v2, v1 ]"); } else { @@ -2706,20 +2706,20 @@ TEST(DBTest, DeletionMarkers1) { TEST(DBTest, DeletionMarkers2) { Put("foo", "v1"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); const int last = dbfull()->MaxMemCompactionLevel(); ASSERT_EQ(NumTableFilesAtLevel(last), 1); // foo => v1 is now in last level // Place a table at level last-1 to prevent merging with preceding mutation Put("a", "begin"); Put("z", "end"); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ(NumTableFilesAtLevel(last), 1); ASSERT_EQ(NumTableFilesAtLevel(last-1), 1); Delete("foo"); ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); // Moves to level last-2 + ASSERT_OK(dbfull()->TEST_FlushMemTable()); // Moves to level last-2 ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]"); dbfull()->TEST_CompactRange(last-2, nullptr, nullptr); // DEL kept: "last" file overlaps @@ -2738,10 +2738,10 @@ TEST(DBTest, OverlapInLevel0) { //Fill levels 1 and 2 to disable the pushing of new memtables to levels > 0. ASSERT_OK(Put("100", "v100")); ASSERT_OK(Put("999", "v999")); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_OK(Delete("100")); ASSERT_OK(Delete("999")); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ("0,1,1", FilesPerLevel()); // Make files spanning the following ranges in level-0: @@ -2750,11 +2750,11 @@ TEST(DBTest, OverlapInLevel0) { // Note that files are sorted by smallest key. ASSERT_OK(Put("300", "v300")); ASSERT_OK(Put("500", "v500")); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_OK(Put("200", "v200")); ASSERT_OK(Put("600", "v600")); ASSERT_OK(Put("900", "v900")); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ("2,1,1", FilesPerLevel()); // Compact away the placeholder files we created initially @@ -2766,7 +2766,7 @@ TEST(DBTest, OverlapInLevel0) { // not detect the overlap with level-0 files and would incorrectly place // the deletion in a deeper level. ASSERT_OK(Delete("600")); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ("3", FilesPerLevel()); ASSERT_EQ("NOT_FOUND", Get("600")); } while (ChangeOptions(kSkipUniversalCompaction)); @@ -3104,7 +3104,7 @@ TEST(DBTest, ManifestWriteError) { ASSERT_EQ("bar", Get("foo")); // Memtable compaction (will succeed) - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); ASSERT_EQ("bar", Get("foo")); const int last = dbfull()->MaxMemCompactionLevel(); ASSERT_EQ(NumTableFilesAtLevel(last), 1); // foo=>bar is now in last level @@ -3152,7 +3152,7 @@ TEST(DBTest, BloomFilter) { for (int i = 0; i < N; i += 100) { ASSERT_OK(Put(Key(i), Key(i))); } - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); // Prevent auto compactions triggered by seeks env_->delay_sstable_sync_.Release_Store(env_); @@ -3322,13 +3322,13 @@ TEST(DBTest, CompactOnFlush) { Reopen(&options); Put("foo", "v1"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); ASSERT_EQ(AllEntriesFor("foo"), "[ v1 ]"); // Write two new keys Put("a", "begin"); Put("z", "end"); - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); // Case1: Delete followed by a put Delete("foo"); @@ -3337,7 +3337,7 @@ TEST(DBTest, CompactOnFlush) { // After the current memtable is flushed, the DEL should // have been removed - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); ASSERT_EQ(AllEntriesFor("foo"), "[ v2, v1 ]"); dbfull()->CompactRange(nullptr, nullptr); @@ -3347,7 +3347,7 @@ TEST(DBTest, CompactOnFlush) { Delete("foo"); Delete("foo"); ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, DEL, v2 ]"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v2 ]"); dbfull()->CompactRange(nullptr, nullptr); ASSERT_EQ(AllEntriesFor("foo"), "[ ]"); @@ -3356,7 +3356,7 @@ TEST(DBTest, CompactOnFlush) { Put("foo", "v3"); Delete("foo"); ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v3 ]"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); ASSERT_EQ(AllEntriesFor("foo"), "[ DEL ]"); dbfull()->CompactRange(nullptr, nullptr); ASSERT_EQ(AllEntriesFor("foo"), "[ ]"); @@ -3365,7 +3365,7 @@ TEST(DBTest, CompactOnFlush) { Put("foo", "v4"); Put("foo", "v5"); ASSERT_EQ(AllEntriesFor("foo"), "[ v5, v4 ]"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); ASSERT_EQ(AllEntriesFor("foo"), "[ v5 ]"); dbfull()->CompactRange(nullptr, nullptr); ASSERT_EQ(AllEntriesFor("foo"), "[ v5 ]"); @@ -3380,7 +3380,7 @@ TEST(DBTest, CompactOnFlush) { Put("foo", "v6"); const Snapshot* snapshot = db_->GetSnapshot(); Put("foo", "v7"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); ASSERT_EQ(AllEntriesFor("foo"), "[ v7, v6 ]"); db_->ReleaseSnapshot(snapshot); @@ -3394,7 +3394,7 @@ TEST(DBTest, CompactOnFlush) { const Snapshot* snapshot1 = db_->GetSnapshot(); Put("foo", "v8"); Put("foo", "v9"); - ASSERT_OK(dbfull()->TEST_CompactMemTable()); + ASSERT_OK(dbfull()->TEST_FlushMemTable()); ASSERT_EQ(AllEntriesFor("foo"), "[ v9 ]"); db_->ReleaseSnapshot(snapshot1); } while (ChangeCompactOptions()); @@ -3662,7 +3662,7 @@ TEST(DBTest, ReadCompaction) { } // clear level 0 and 1 if necessary. - dbfull()->TEST_CompactMemTable(); + dbfull()->TEST_FlushMemTable(); dbfull()->TEST_CompactRange(0, nullptr, nullptr); dbfull()->TEST_CompactRange(1, nullptr, nullptr); ASSERT_EQ(NumTableFilesAtLevel(0), 0); @@ -4186,7 +4186,7 @@ void PrefixScanInit(DBTest *dbtest) { snprintf(buf, sizeof(buf), "%02d______:end", 10); keystr = std::string(buf); ASSERT_OK(dbtest->Put(keystr, keystr)); - dbtest->dbfull()->TEST_CompactMemTable(); + dbtest->dbfull()->TEST_FlushMemTable(); dbtest->dbfull()->CompactRange(nullptr, nullptr); // move to level 1 // GROUP 1 @@ -4197,7 +4197,7 @@ void PrefixScanInit(DBTest *dbtest) { snprintf(buf, sizeof(buf), "%02d______:end", i+1); keystr = std::string(buf); ASSERT_OK(dbtest->Put(keystr, keystr)); - dbtest->dbfull()->TEST_CompactMemTable(); + dbtest->dbfull()->TEST_FlushMemTable(); } // GROUP 2 @@ -4210,7 +4210,7 @@ void PrefixScanInit(DBTest *dbtest) { small_range_sstfiles+i+1); keystr = std::string(buf); ASSERT_OK(dbtest->Put(keystr, keystr)); - dbtest->dbfull()->TEST_CompactMemTable(); + dbtest->dbfull()->TEST_FlushMemTable(); } } diff --git a/db/deletefile_test.cc b/db/deletefile_test.cc index 3c4c459b4..78a55febb 100644 --- a/db/deletefile_test.cc +++ b/db/deletefile_test.cc @@ -92,12 +92,12 @@ class DeleteFileTest { void CreateTwoLevels() { AddKeys(50000, 10000); DBImpl* dbi = reinterpret_cast(db_); - ASSERT_OK(dbi->TEST_CompactMemTable()); - ASSERT_OK(dbi->TEST_WaitForCompactMemTable()); + ASSERT_OK(dbi->TEST_FlushMemTable()); + ASSERT_OK(dbi->TEST_WaitForFlushMemTable()); AddKeys(50000, 10000); - ASSERT_OK(dbi->TEST_CompactMemTable()); - ASSERT_OK(dbi->TEST_WaitForCompactMemTable()); + ASSERT_OK(dbi->TEST_FlushMemTable()); + ASSERT_OK(dbi->TEST_WaitForFlushMemTable()); } }; diff --git a/helpers/memenv/memenv_test.cc b/helpers/memenv/memenv_test.cc index 7cdc2bbeb..19fc8ff2a 100644 --- a/helpers/memenv/memenv_test.cc +++ b/helpers/memenv/memenv_test.cc @@ -215,7 +215,7 @@ TEST(MemEnvTest, DBTest) { delete iterator; DBImpl* dbi = reinterpret_cast(db); - ASSERT_OK(dbi->TEST_CompactMemTable()); + ASSERT_OK(dbi->TEST_FlushMemTable()); for (size_t i = 0; i < 3; ++i) { std::string res; diff --git a/tools/reduce_levels_test.cc b/tools/reduce_levels_test.cc index 154e7929c..0b504c3ca 100644 --- a/tools/reduce_levels_test.cc +++ b/tools/reduce_levels_test.cc @@ -45,7 +45,7 @@ public: return Status::InvalidArgument("DB not opened."); } DBImpl* db_impl = reinterpret_cast(db_); - return db_impl->TEST_CompactMemTable(); + return db_impl->TEST_FlushMemTable(); } void CloseDB() {