| // Copyright (c) 2013 The LevelDB Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. See the AUTHORS file for names of contributors. |
| |
| #include "leveldb/db.h" |
| #include "db/db_impl.h" |
| #include "leveldb/cache.h" |
| #include "util/testharness.h" |
| #include "util/testutil.h" |
| |
| namespace leveldb { |
| |
| class AutoCompactTest { |
| public: |
| std::string dbname_; |
| Cache* tiny_cache_; |
| Options options_; |
| DB* db_; |
| |
| AutoCompactTest() { |
| dbname_ = test::TmpDir() + "/autocompact_test"; |
| tiny_cache_ = NewLRUCache(100); |
| options_.block_cache = tiny_cache_; |
| DestroyDB(dbname_, options_); |
| options_.create_if_missing = true; |
| options_.compression = kNoCompression; |
| ASSERT_OK(DB::Open(options_, dbname_, &db_)); |
| } |
| |
| ~AutoCompactTest() { |
| delete db_; |
| DestroyDB(dbname_, Options()); |
| delete tiny_cache_; |
| } |
| |
| std::string Key(int i) { |
| char buf[100]; |
| snprintf(buf, sizeof(buf), "key%06d", i); |
| return std::string(buf); |
| } |
| |
| uint64_t Size(const Slice& start, const Slice& limit) { |
| Range r(start, limit); |
| uint64_t size; |
| db_->GetApproximateSizes(&r, 1, &size); |
| return size; |
| } |
| |
| void DoReads(int n); |
| }; |
| |
| static const int kValueSize = 200 * 1024; |
| static const int kTotalSize = 100 * 1024 * 1024; |
| static const int kCount = kTotalSize / kValueSize; |
| |
| // Read through the first n keys repeatedly and check that they get |
| // compacted (verified by checking the size of the key space). |
| void AutoCompactTest::DoReads(int n) { |
| std::string value(kValueSize, 'x'); |
| DBImpl* dbi = reinterpret_cast<DBImpl*>(db_); |
| |
| // Fill database |
| for (int i = 0; i < kCount; i++) { |
| ASSERT_OK(db_->Put(WriteOptions(), Key(i), value)); |
| } |
| ASSERT_OK(dbi->TEST_CompactMemTable()); |
| |
| // Delete everything |
| for (int i = 0; i < kCount; i++) { |
| ASSERT_OK(db_->Delete(WriteOptions(), Key(i))); |
| } |
| ASSERT_OK(dbi->TEST_CompactMemTable()); |
| |
| // Get initial measurement of the space we will be reading. |
| const int64_t initial_size = Size(Key(0), Key(n)); |
| const int64_t initial_other_size = Size(Key(n), Key(kCount)); |
| |
| // Read until size drops significantly. |
| std::string limit_key = Key(n); |
| for (int read = 0; true; read++) { |
| ASSERT_LT(read, 100) << "Taking too long to compact"; |
| Iterator* iter = db_->NewIterator(ReadOptions()); |
| for (iter->SeekToFirst(); |
| iter->Valid() && iter->key().ToString() < limit_key; |
| iter->Next()) { |
| // Drop data |
| } |
| delete iter; |
| // Wait a little bit to allow any triggered compactions to complete. |
| Env::Default()->SleepForMicroseconds(1000000); |
| uint64_t size = Size(Key(0), Key(n)); |
| fprintf(stderr, "iter %3d => %7.3f MB [other %7.3f MB]\n", |
| read+1, size/1048576.0, Size(Key(n), Key(kCount))/1048576.0); |
| if (size <= initial_size/10) { |
| break; |
| } |
| } |
| |
| // Verify that the size of the key space not touched by the reads |
| // is pretty much unchanged. |
| const int64_t final_other_size = Size(Key(n), Key(kCount)); |
| ASSERT_LE(final_other_size, initial_other_size + 1048576); |
| ASSERT_GE(final_other_size, initial_other_size/5 - 1048576); |
| } |
| |
| TEST(AutoCompactTest, ReadAll) { |
| DoReads(kCount); |
| } |
| |
| TEST(AutoCompactTest, ReadHalf) { |
| DoReads(kCount/2); |
| } |
| |
| } // namespace leveldb |
| |
| int main(int argc, char** argv) { |
| return leveldb::test::RunAllTests(); |
| } |