1 // Copyright (c) 2011 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 "leveldb/cache.h"
6
7 #include <vector>
8 #include "util/coding.h"
9 #include "util/testharness.h"
10
11 namespace leveldb {
12
13 // Conversions between numeric keys/values and the types expected by Cache.
EncodeKey(int k)14 static std::string EncodeKey(int k) {
15 std::string result;
16 PutFixed32(&result, k);
17 return result;
18 }
DecodeKey(const Slice & k)19 static int DecodeKey(const Slice& k) {
20 assert(k.size() == 4);
21 return DecodeFixed32(k.data());
22 }
EncodeValue(uintptr_t v)23 static void* EncodeValue(uintptr_t v) { return reinterpret_cast<void*>(v); }
DecodeValue(void * v)24 static int DecodeValue(void* v) { return reinterpret_cast<uintptr_t>(v); }
25
26 class CacheTest {
27 public:
28 static CacheTest* current_;
29
Deleter(const Slice & key,void * v)30 static void Deleter(const Slice& key, void* v) {
31 current_->deleted_keys_.push_back(DecodeKey(key));
32 current_->deleted_values_.push_back(DecodeValue(v));
33 }
34
35 static const int kCacheSize = 1000;
36 std::vector<int> deleted_keys_;
37 std::vector<int> deleted_values_;
38 Cache* cache_;
39
CacheTest()40 CacheTest() : cache_(NewLRUCache(kCacheSize)) {
41 current_ = this;
42 }
43
~CacheTest()44 ~CacheTest() {
45 delete cache_;
46 }
47
Lookup(int key)48 int Lookup(int key) {
49 Cache::Handle* handle = cache_->Lookup(EncodeKey(key));
50 const int r = (handle == NULL) ? -1 : DecodeValue(cache_->Value(handle));
51 if (handle != NULL) {
52 cache_->Release(handle);
53 }
54 return r;
55 }
56
Insert(int key,int value,int charge=1)57 void Insert(int key, int value, int charge = 1) {
58 cache_->Release(cache_->Insert(EncodeKey(key), EncodeValue(value), charge,
59 &CacheTest::Deleter));
60 }
61
InsertAndReturnHandle(int key,int value,int charge=1)62 Cache::Handle* InsertAndReturnHandle(int key, int value, int charge = 1) {
63 return cache_->Insert(EncodeKey(key), EncodeValue(value), charge,
64 &CacheTest::Deleter);
65 }
66
Erase(int key)67 void Erase(int key) {
68 cache_->Erase(EncodeKey(key));
69 }
70 };
71 CacheTest* CacheTest::current_;
72
TEST(CacheTest,HitAndMiss)73 TEST(CacheTest, HitAndMiss) {
74 ASSERT_EQ(-1, Lookup(100));
75
76 Insert(100, 101);
77 ASSERT_EQ(101, Lookup(100));
78 ASSERT_EQ(-1, Lookup(200));
79 ASSERT_EQ(-1, Lookup(300));
80
81 Insert(200, 201);
82 ASSERT_EQ(101, Lookup(100));
83 ASSERT_EQ(201, Lookup(200));
84 ASSERT_EQ(-1, Lookup(300));
85
86 Insert(100, 102);
87 ASSERT_EQ(102, Lookup(100));
88 ASSERT_EQ(201, Lookup(200));
89 ASSERT_EQ(-1, Lookup(300));
90
91 ASSERT_EQ(1, deleted_keys_.size());
92 ASSERT_EQ(100, deleted_keys_[0]);
93 ASSERT_EQ(101, deleted_values_[0]);
94 }
95
TEST(CacheTest,Erase)96 TEST(CacheTest, Erase) {
97 Erase(200);
98 ASSERT_EQ(0, deleted_keys_.size());
99
100 Insert(100, 101);
101 Insert(200, 201);
102 Erase(100);
103 ASSERT_EQ(-1, Lookup(100));
104 ASSERT_EQ(201, Lookup(200));
105 ASSERT_EQ(1, deleted_keys_.size());
106 ASSERT_EQ(100, deleted_keys_[0]);
107 ASSERT_EQ(101, deleted_values_[0]);
108
109 Erase(100);
110 ASSERT_EQ(-1, Lookup(100));
111 ASSERT_EQ(201, Lookup(200));
112 ASSERT_EQ(1, deleted_keys_.size());
113 }
114
TEST(CacheTest,EntriesArePinned)115 TEST(CacheTest, EntriesArePinned) {
116 Insert(100, 101);
117 Cache::Handle* h1 = cache_->Lookup(EncodeKey(100));
118 ASSERT_EQ(101, DecodeValue(cache_->Value(h1)));
119
120 Insert(100, 102);
121 Cache::Handle* h2 = cache_->Lookup(EncodeKey(100));
122 ASSERT_EQ(102, DecodeValue(cache_->Value(h2)));
123 ASSERT_EQ(0, deleted_keys_.size());
124
125 cache_->Release(h1);
126 ASSERT_EQ(1, deleted_keys_.size());
127 ASSERT_EQ(100, deleted_keys_[0]);
128 ASSERT_EQ(101, deleted_values_[0]);
129
130 Erase(100);
131 ASSERT_EQ(-1, Lookup(100));
132 ASSERT_EQ(1, deleted_keys_.size());
133
134 cache_->Release(h2);
135 ASSERT_EQ(2, deleted_keys_.size());
136 ASSERT_EQ(100, deleted_keys_[1]);
137 ASSERT_EQ(102, deleted_values_[1]);
138 }
139
TEST(CacheTest,EvictionPolicy)140 TEST(CacheTest, EvictionPolicy) {
141 Insert(100, 101);
142 Insert(200, 201);
143 Insert(300, 301);
144 Cache::Handle* h = cache_->Lookup(EncodeKey(300));
145
146 // Frequently used entry must be kept around,
147 // as must things that are still in use.
148 for (int i = 0; i < kCacheSize + 100; i++) {
149 Insert(1000+i, 2000+i);
150 ASSERT_EQ(2000+i, Lookup(1000+i));
151 ASSERT_EQ(101, Lookup(100));
152 }
153 ASSERT_EQ(101, Lookup(100));
154 ASSERT_EQ(-1, Lookup(200));
155 ASSERT_EQ(301, Lookup(300));
156 cache_->Release(h);
157 }
158
TEST(CacheTest,UseExceedsCacheSize)159 TEST(CacheTest, UseExceedsCacheSize) {
160 // Overfill the cache, keeping handles on all inserted entries.
161 std::vector<Cache::Handle*> h;
162 for (int i = 0; i < kCacheSize + 100; i++) {
163 h.push_back(InsertAndReturnHandle(1000+i, 2000+i));
164 }
165
166 // Check that all the entries can be found in the cache.
167 for (int i = 0; i < h.size(); i++) {
168 ASSERT_EQ(2000+i, Lookup(1000+i));
169 }
170
171 for (int i = 0; i < h.size(); i++) {
172 cache_->Release(h[i]);
173 }
174 }
175
TEST(CacheTest,HeavyEntries)176 TEST(CacheTest, HeavyEntries) {
177 // Add a bunch of light and heavy entries and then count the combined
178 // size of items still in the cache, which must be approximately the
179 // same as the total capacity.
180 const int kLight = 1;
181 const int kHeavy = 10;
182 int added = 0;
183 int index = 0;
184 while (added < 2*kCacheSize) {
185 const int weight = (index & 1) ? kLight : kHeavy;
186 Insert(index, 1000+index, weight);
187 added += weight;
188 index++;
189 }
190
191 int cached_weight = 0;
192 for (int i = 0; i < index; i++) {
193 const int weight = (i & 1 ? kLight : kHeavy);
194 int r = Lookup(i);
195 if (r >= 0) {
196 cached_weight += weight;
197 ASSERT_EQ(1000+i, r);
198 }
199 }
200 ASSERT_LE(cached_weight, kCacheSize + kCacheSize/10);
201 }
202
TEST(CacheTest,NewId)203 TEST(CacheTest, NewId) {
204 uint64_t a = cache_->NewId();
205 uint64_t b = cache_->NewId();
206 ASSERT_NE(a, b);
207 }
208
TEST(CacheTest,Prune)209 TEST(CacheTest, Prune) {
210 Insert(1, 100);
211 Insert(2, 200);
212
213 Cache::Handle* handle = cache_->Lookup(EncodeKey(1));
214 ASSERT_TRUE(handle);
215 cache_->Prune();
216 cache_->Release(handle);
217
218 ASSERT_EQ(100, Lookup(1));
219 ASSERT_EQ(-1, Lookup(2));
220 }
221
222 } // namespace leveldb
223
main(int argc,char ** argv)224 int main(int argc, char** argv) {
225 return leveldb::test::RunAllTests();
226 }
227