Inside Bitcoin

1// Copyright (c) 2013 The LevelDB Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file. See the AUTHORS file for names of contributors.
4
5#include "db/db_impl.h"
6#include "leveldb/cache.h"
7#include "leveldb/db.h"
8#include "util/testharness.h"
9#include "util/testutil.h"
10
11namespace leveldb {
12
13class AutoCompactTest {
14 public:
15  AutoCompactTest() {
16    dbname_ = test::TmpDir() + "/autocompact_test";
17    tiny_cache_ = NewLRUCache(100);
18    options_.block_cache = tiny_cache_;
19    DestroyDB(dbname_, options_);
20    options_.create_if_missing = true;
21    options_.compression = kNoCompression;
22    ASSERT_OK(DB::Open(options_, dbname_, &db_));
23  }
24
25  ~AutoCompactTest() {
26    delete db_;
27    DestroyDB(dbname_, Options());
28    delete tiny_cache_;
29  }
30
31  std::string Key(int i) {
32    char buf[100];
33    snprintf(buf, sizeof(buf), "key%06d", i);
34    return std::string(buf);
35  }
36
37  uint64_t Size(const Slice& start, const Slice& limit) {
38    Range r(start, limit);
39    uint64_t size;
40    db_->GetApproximateSizes(&r, 1, &size);
41    return size;
42  }
43
44  void DoReads(int n);
45
46 private:
47  std::string dbname_;
48  Cache* tiny_cache_;
49  Options options_;
50  DB* db_;
51};
52
53static const int kValueSize = 200 * 1024;
54static const int kTotalSize = 100 * 1024 * 1024;
55static const int kCount = kTotalSize / kValueSize;
56
57// Read through the first n keys repeatedly and check that reads do NOT
58// trigger compaction (seek compaction is disabled in this fork).
59void AutoCompactTest::DoReads(int n) {
60  std::string value(kValueSize, 'x');
61  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
62
63  // Fill database
64  for (int i = 0; i < kCount; i++) {
65    ASSERT_OK(db_->Put(WriteOptions(), Key(i), value));
66  }
67  ASSERT_OK(dbi->TEST_CompactMemTable());
68
69  // Delete everything
70  for (int i = 0; i < kCount; i++) {
71    ASSERT_OK(db_->Delete(WriteOptions(), Key(i)));
72  }
73  ASSERT_OK(dbi->TEST_CompactMemTable());
74
75  // Get initial measurement of the space we will be reading.
76  const int64_t initial_size = Size(Key(0), Key(n));
77  const int64_t initial_other_size = Size(Key(n), Key(kCount));
78
79  // Read repeatedly. The size of the read range must NOT shrink: with
80  // seek compaction disabled, reads never schedule a compaction.
81  std::string limit_key = Key(n);
82  for (int read = 0; read < 100; read++) {
83    Iterator* iter = db_->NewIterator(ReadOptions());
84    for (iter->SeekToFirst();
85         iter->Valid() && iter->key().ToString() < limit_key; iter->Next()) {
86      // Drop data
87    }
88    delete iter;
89    uint64_t size = Size(Key(0), Key(n));
90    fprintf(stderr, "iter %3d => %7.3f MB [other %7.3f MB]\n", read + 1,
91            size / 1048576.0, Size(Key(n), Key(kCount)) / 1048576.0);
92  }
93  // Give any background work a chance to run, even though none should.
94  Env::Default()->SleepForMicroseconds(1000000);
95  ASSERT_EQ(Size(Key(0), Key(n)), static_cast<uint64_t>(initial_size));
96
97  // Verify that the size of the key space not touched by the reads
98  // is pretty much unchanged.
99  const int64_t final_other_size = Size(Key(n), Key(kCount));
100  ASSERT_LE(final_other_size, initial_other_size + 1048576);
101  ASSERT_GE(final_other_size, initial_other_size / 5 - 1048576);
102}
103
104TEST(AutoCompactTest, ReadAll) { DoReads(kCount); }
105
106TEST(AutoCompactTest, ReadHalf) { DoReads(kCount / 2); }
107
108}  // namespace leveldb
109
110int main(int argc, char** argv) { return leveldb::test::RunAllTests(); }
111