1 // Copyright (c) 2018 The Chromium 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.
4
5 #include <map>
6 #include <memory>
7 #include <string>
8 #include <utility>
9 #include <vector>
10
11 #include "base/test/perf_time_logger.h"
12 #include "base/test/task_environment.h"
13 #include "base/threading/thread_task_runner_handle.h"
14 #include "base/timer/elapsed_timer.h"
15
16 #include "base/bind.h"
17 #include "base/bind_helpers.h"
18 #include "base/files/file_util.h"
19 #include "base/files/scoped_temp_dir.h"
20 #include "base/location.h"
21 #include "base/memory/ptr_util.h"
22 #include "base/run_loop.h"
23 #include "base/stl_util.h"
24 #include "base/strings/string_number_conversions.h"
25 #include "base/strings/stringprintf.h"
26 #include "base/threading/thread.h"
27 #include "build/build_config.h"
28 #include "components/leveldb_proto/internal/leveldb_database.h"
29 #include "components/leveldb_proto/internal/proto_database_impl.h"
30 #include "components/leveldb_proto/internal/unique_proto_database.h"
31 #include "components/leveldb_proto/public/proto_database.h"
32 #include "components/leveldb_proto/public/shared_proto_database_client_list.h"
33 #include "components/leveldb_proto/testing/proto/test_db.pb.h"
34 #include "testing/gmock/include/gmock/gmock.h"
35 #include "testing/gtest/include/gtest/gtest.h"
36 #include "testing/perf/perf_result_reporter.h"
37 #include "third_party/leveldatabase/env_chromium.h"
38 #include "third_party/leveldatabase/leveldb_chrome.h"
39
40 using base::ScopedTempDir;
41 using leveldb_env::Options;
42 using testing::_;
43 using testing::Invoke;
44 using testing::MakeMatcher;
45 using testing::Matcher;
46 using testing::MatcherInterface;
47 using testing::MatchResultListener;
48 using testing::Return;
49 using testing::UnorderedElementsAre;
50
51 namespace leveldb_proto {
52
53 namespace {
54
55 using KeyEntryVector = ProtoDatabase<TestProto>::KeyEntryVector;
56 using KeyEntryVectorMap =
57 std::map<std::string, std::unique_ptr<KeyEntryVector>>;
58
59 struct TestParams {
60 int num_entries;
61 int data_size;
62 int batch_size;
63 bool single_db;
64 };
65
66 struct PerfStats {
67 double time_ms = 0;
68 uint64_t max_memory_used_bytes = 0;
69 uint64_t memory_summed_bytes = 0;
70 int num_runs = 0;
71 };
72
73 static const std::string kSingleDBName = "singledb";
74 static constexpr char kMetricNumRunsCount[] = "num_runs";
75 static constexpr char kMetricTimeMs[] = "time";
76 static constexpr char kMetricMaxMemoryUseBytes[] = "max_memory_use";
77 static constexpr char kMetricAverageMemoryUseBytes[] = "average_memory_use";
78 static constexpr char kMetricTotalMemoryUseBytes[] = "total_memory_use";
79 static constexpr char kMetricMemUseAfterWritesBytes[] =
80 "memory_use_after_writes";
81 static constexpr char kMetricMemUseAfterLoadBytes[] = "memory_use_after_load";
82 static constexpr char kMetricTotalTimeTakenMs[] = "total_time_taken";
83 static constexpr char kMetricMaxIndTimeTakenMs[] = "max_individual_time_taken";
84
85 static const int kSmallDataSize = 10;
86 static const int kMediumDataSize = 100;
87 static const int kLargeDataSize = 1000;
88
89 static const int kDefaultNumDBs = 5;
90 static const int kSmallNumEntries = 300;
91 static const int kLargeNumEntries = 3000;
92
93 static const std::vector<TestParams> kFewEntriesDistributionTestParams = {
94 {2, kSmallDataSize, 1, false}, {1, kSmallDataSize, 1, false},
95 {1, kSmallDataSize, 1, false}, {3, kSmallDataSize, 1, false},
96 {4, kSmallDataSize, 1, false}, {5, kSmallDataSize, 1, false},
97 {8, kSmallDataSize, 1, false}, {10, kSmallDataSize, 1, false},
98 {10, kSmallDataSize, 1, false},
99 };
100
101 static const std::vector<TestParams> kManyEntriesDistributionTestParams = {
102 {20, kSmallDataSize, 1, false}, {10, kSmallDataSize, 1, false},
103 {10, kSmallDataSize, 1, false}, {30, kSmallDataSize, 1, false},
104 {40, kSmallDataSize, 1, false}, {50, kSmallDataSize, 1, false},
105 {80, kSmallDataSize, 1, false}, {100, kSmallDataSize, 1, false},
106 {100, kSmallDataSize, 1, false},
107 };
108
109 class TestDatabase {
110 public:
TestDatabase(scoped_refptr<base::SingleThreadTaskRunner> task_runner,const base::FilePath & path)111 TestDatabase(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
112 const base::FilePath& path)
113 : db_(std::make_unique<ProtoDatabaseImpl<TestProto>>(
114 ProtoDbType::TEST_DATABASE0,
115 path,
116 task_runner)) {
117 base::RunLoop run_init_db;
118 db_->Init(base::BindOnce(
119 [](base::OnceClosure signal, Enums::InitStatus status) {
120 bool success = status == Enums::kOK;
121 EXPECT_TRUE(success);
122 std::move(signal).Run();
123 },
124 run_init_db.QuitClosure()));
125 run_init_db.Run();
126
127 is_initialized_ = true;
128 }
129
is_initialized() const130 bool is_initialized() const { return is_initialized_; }
proto_db() const131 ProtoDatabaseImpl<TestProto>* proto_db() const { return db_.get(); }
132
133 private:
134 bool is_initialized_ = false;
135 std::unique_ptr<ProtoDatabaseImpl<TestProto>> db_;
136 };
137
138 } // namespace
139
140 class ProtoDBPerfTest : public testing::Test {
141 public:
SetUp()142 void SetUp() override { task_runner_ = base::ThreadTaskRunnerHandle::Get(); }
143
TearDown()144 void TearDown() override {
145 ShutdownDBs();
146 }
147
ShutdownDBs()148 void ShutdownDBs() {
149 dbs_.clear();
150 base::RunLoop().RunUntilIdle();
151 PruneBlockCache();
152 uint64_t mem;
153 GetApproximateMemoryUsage(&mem);
154 ASSERT_EQ(mem, 0U);
155 }
156
GetDatabase(const std::string & name,TestDatabase ** db)157 void GetDatabase(const std::string& name, TestDatabase** db) {
158 auto db_it = dbs_.find(name);
159 ASSERT_FALSE(db_it == dbs_.end());
160 *db = db_it->second.get();
161 }
162
task_runner()163 scoped_refptr<base::SingleThreadTaskRunner> task_runner() {
164 return task_runner_;
165 }
166
167 // Initializes a DB named |name| in a dedicated directory. The same directory
168 // will be used for all instances created for the same |name| for the lifetime
169 // of the test.
InitDB(const std::string & name)170 void InitDB(const std::string& name) {
171 if (!base::Contains(temp_dirs_, name)) {
172 auto temp_dir = std::make_unique<ScopedTempDir>();
173 EXPECT_TRUE(temp_dir->CreateUniqueTempDir());
174 temp_dirs_[name] = std::move(temp_dir);
175 }
176 auto db = std::make_unique<TestDatabase>(task_runner_,
177 temp_dirs_[name]->GetPath());
178 EXPECT_TRUE(db->is_initialized());
179 dbs_[name] = std::move(db);
180 }
181
InsertSuccessCallback(base::OnceClosure signal,uint64_t * memory_use,bool success)182 void InsertSuccessCallback(base::OnceClosure signal,
183 uint64_t* memory_use,
184 bool success) {
185 EXPECT_TRUE(success);
186 GetApproximateMemoryUsage(memory_use);
187 std::move(signal).Run();
188 }
189
InsertEntries(const std::string & db_name,std::unique_ptr<KeyEntryVector> entries,PerfStats * stats)190 void InsertEntries(const std::string& db_name,
191 std::unique_ptr<KeyEntryVector> entries,
192 PerfStats* stats) {
193 auto db_it = dbs_.find(db_name);
194 ASSERT_TRUE(db_it != dbs_.end());
195 TestDatabase* db = db_it->second.get();
196
197 base::RunLoop run_update_entries;
198 base::ElapsedTimer timer;
199 uint64_t memory_use;
200 db->proto_db()->UpdateEntries(
201 std::move(entries), std::make_unique<std::vector<std::string>>(),
202 base::BindOnce(&ProtoDBPerfTest::InsertSuccessCallback,
203 base::Unretained(this), run_update_entries.QuitClosure(),
204 &memory_use));
205 run_update_entries.Run();
206 stats->max_memory_used_bytes =
207 std::max(stats->max_memory_used_bytes, memory_use);
208 stats->memory_summed_bytes += memory_use;
209 stats->time_ms += timer.Elapsed().InMillisecondsF();
210 stats->num_runs++;
211 }
212
GenerateDBNames(int count)213 std::vector<std::string> GenerateDBNames(int count) {
214 std::vector<std::string> names;
215 for (int i = 0; i < count; i++) {
216 names.push_back(base::StringPrintf("test%03d_", i));
217 }
218 return names;
219 }
220
221 // Since we don't have access to the internal memtables of the individual DBs,
222 // but we do have access to the global shared block cache, we always subtract
223 // the block cache size from each individual estimate and then add it at the
224 // end.
GetApproximateMemoryUsage(uint64_t * approx_mem_use)225 void GetApproximateMemoryUsage(uint64_t* approx_mem_use) {
226 uint64_t total_usage = 0;
227 uint64_t block_cache_size =
228 leveldb_chrome::GetSharedBrowserBlockCache()->TotalCharge();
229 for (auto it = dbs_.begin(); it != dbs_.end(); ++it) {
230 uint64_t usage;
231 ASSERT_TRUE(GetApproximateMemoryUsageOfDB(it->second.get(), &usage));
232 total_usage += usage - block_cache_size;
233 }
234 *approx_mem_use = total_usage + block_cache_size;
235 }
236
RunAlternatingInsertTests(const std::vector<TestParams> & params,const std::string & test_name,int num_dbs)237 void RunAlternatingInsertTests(const std::vector<TestParams>& params,
238 const std::string& test_name,
239 int num_dbs) {
240 auto db_names = GenerateDBNames(num_dbs);
241
242 for (auto& p : params) {
243 std::string test_modifier = base::StringPrintf(
244 "%d_%d_%d", p.batch_size, p.num_entries, p.data_size);
245 RunAlternatingInsertTest(test_name, test_modifier, db_names, p);
246 }
247 }
248
249 // Runs a test to alternately insert elements with different prefixes into
250 // either a database for each prefix or a single DB.
RunAlternatingInsertTest(const std::string & test_name,const std::string & story_name,const std::vector<std::string> & prefixes,const TestParams & params)251 void RunAlternatingInsertTest(const std::string& test_name,
252 const std::string& story_name,
253 const std::vector<std::string>& prefixes,
254 const TestParams& params) {
255 // Make the entries for each database first.
256 KeyEntryVectorMap entries =
257 GenerateTestEntries(prefixes, params.num_entries, params.data_size);
258
259 InitDBs(params.single_db, prefixes);
260
261 int remaining = params.num_entries;
262 PerfStats stats;
263 while (remaining > 0) {
264 int begin_index = params.num_entries - remaining;
265 int end_index =
266 std::min(begin_index + params.batch_size, params.num_entries);
267
268 for (auto& prefix : prefixes) {
269 auto db_name = params.single_db ? kSingleDBName : prefix;
270
271 auto begin_it = entries[prefix]->begin() + begin_index;
272 auto end_it = entries[prefix]->begin() + end_index;
273 auto batch_entries = std::make_unique<KeyEntryVector>(begin_it, end_it);
274
275 InsertEntries(db_name, std::move(batch_entries), &stats);
276 }
277 remaining -= params.batch_size;
278 }
279
280 perf_test::PerfResultReporter reporter =
281 SetUpReporter(test_name, story_name);
282 reporter.AddResult(kMetricNumRunsCount,
283 static_cast<size_t>(stats.num_runs));
284 reporter.AddResult(kMetricTimeMs, stats.time_ms);
285 reporter.AddResult(kMetricMaxMemoryUseBytes,
286 static_cast<size_t>(stats.max_memory_used_bytes));
287 uint64_t average_memory_use = stats.memory_summed_bytes / stats.num_runs;
288 reporter.AddResult(kMetricAverageMemoryUseBytes,
289 static_cast<size_t>(average_memory_use));
290 }
291
292 // Used to measure the impact on memory in the case where the distribution of
293 // entries isn't equal amongst individual databases.
RunDistributionTestAndCleanup(const std::string & story_name,const std::vector<TestParams> & test_params,bool single_db)294 void RunDistributionTestAndCleanup(const std::string& story_name,
295 const std::vector<TestParams>& test_params,
296 bool single_db) {
297 std::vector<std::string> prefixes;
298 for (int i = 0; i < static_cast<int>(test_params.size()); i++) {
299 prefixes.emplace_back(base::StringPrintf("test%03d_", i));
300 }
301
302 InitDBs(single_db, prefixes);
303
304 PerfStats stats;
305 for (int i = 0; i < static_cast<int>(test_params.size()); i++) {
306 auto entries = GenerateTestEntries(
307 prefixes[i], test_params[i].num_entries, test_params[i].data_size);
308 auto db_name = single_db ? kSingleDBName : prefixes[i];
309
310 int remaining = test_params[i].num_entries;
311 while (remaining > 0) {
312 int begin_index = test_params[i].num_entries - remaining;
313 int end_index = std::min(begin_index + test_params[i].batch_size,
314 test_params[i].num_entries);
315
316 auto begin_it = entries->begin() + begin_index;
317 auto end_it = entries->begin() + end_index;
318 auto batch_entries = std::make_unique<KeyEntryVector>(begin_it, end_it);
319
320 InsertEntries(db_name, std::move(batch_entries), &stats);
321 remaining -= test_params[i].batch_size;
322 }
323 }
324
325 perf_test::PerfResultReporter reporter =
326 SetUpReporter("Distribution", story_name);
327 reporter.AddResult(kMetricTotalMemoryUseBytes,
328 static_cast<size_t>(stats.max_memory_used_bytes));
329 ShutdownDBs();
330 }
331
RunLoadEntriesSingleTestAndCleanup(unsigned int num_dbs,unsigned int num_entries,size_t data_size,std::set<unsigned int> dbs_to_load,std::string test_modifier,unsigned int * num_entries_loaded,bool fill_read_cache=true)332 void RunLoadEntriesSingleTestAndCleanup(unsigned int num_dbs,
333 unsigned int num_entries,
334 size_t data_size,
335 std::set<unsigned int> dbs_to_load,
336 std::string test_modifier,
337 unsigned int* num_entries_loaded,
338 bool fill_read_cache = true) {
339 std::vector<std::string> prefixes = GenerateDBNames(num_dbs);
340 PrefillDatabase(kSingleDBName, prefixes, num_entries, data_size);
341 uint64_t memory_use_before;
342 GetApproximateMemoryUsage(&memory_use_before);
343
344 ShutdownDBs();
345
346 InitDB(kSingleDBName);
347 TestDatabase* db;
348 GetDatabase(kSingleDBName, &db);
349
350 uint64_t time_ms = 0;
351 uint64_t max_time_ms = 0;
352 if (dbs_to_load.size() == 0) {
353 // The case where we just load all the DBs, so we give it an empty prefix.
354 LoadEntriesFromDB(db, "", fill_read_cache, num_entries_loaded, &time_ms);
355 } else {
356 for (auto& db_to_load : dbs_to_load) {
357 unsigned int curr_num_entries_loaded = 0;
358 uint64_t curr_time_ms = 0;
359 LoadEntriesFromDB(db, base::StringPrintf("test%03u_", db_to_load),
360 fill_read_cache, &curr_num_entries_loaded,
361 &curr_time_ms);
362 *num_entries_loaded += curr_num_entries_loaded;
363 max_time_ms = std::max(max_time_ms, curr_time_ms);
364 time_ms += curr_time_ms;
365 }
366 }
367 uint64_t memory_use_after;
368 GetApproximateMemoryUsage(&memory_use_after);
369
370 auto story_name =
371 base::StringPrintf("%u_%u_%zu", num_dbs, num_entries, data_size);
372 perf_test::PerfResultReporter reporter =
373 SetUpReporter(test_modifier, story_name);
374 reporter.AddResult(kMetricMemUseAfterWritesBytes,
375 static_cast<size_t>(memory_use_before));
376 reporter.AddResult(kMetricMemUseAfterLoadBytes,
377 static_cast<size_t>(memory_use_after));
378 reporter.AddResult(kMetricTotalTimeTakenMs, static_cast<size_t>(time_ms));
379 reporter.AddResult(kMetricMaxIndTimeTakenMs,
380 static_cast<size_t>(max_time_ms));
381
382 ShutdownDBs();
383 }
384
RunLoadEntriesMultiTestAndCleanup(unsigned int num_dbs,unsigned int num_entries,size_t data_size,std::set<unsigned int> dbs_to_load,std::string test_modifier,unsigned int * num_entries_loaded,bool fill_read_cache=true)385 void RunLoadEntriesMultiTestAndCleanup(unsigned int num_dbs,
386 unsigned int num_entries,
387 size_t data_size,
388 std::set<unsigned int> dbs_to_load,
389 std::string test_modifier,
390 unsigned int* num_entries_loaded,
391 bool fill_read_cache = true) {
392 std::vector<std::string> prefixes = GenerateDBNames(num_dbs);
393 for (unsigned int i = 0; i < num_dbs; i++) {
394 std::vector<std::string> single_prefix = {prefixes[i]};
395 PrefillDatabase(prefixes[i], single_prefix, num_entries, data_size);
396 }
397 uint64_t memory_use_before;
398 GetApproximateMemoryUsage(&memory_use_before);
399
400 ShutdownDBs();
401
402 uint64_t time_ms = 0;
403 uint64_t max_time_ms = 0;
404 for (unsigned int i = 0; i < num_dbs; i++) {
405 if (dbs_to_load.size() > 0 && dbs_to_load.find(i) == dbs_to_load.end())
406 continue;
407 InitDB(prefixes[i]);
408 TestDatabase* db;
409 GetDatabase(prefixes[i], &db);
410
411 unsigned int curr_num_entries_loaded = 0;
412 uint64_t curr_time_ms = 0;
413 LoadEntriesFromDB(db, std::string(), fill_read_cache,
414 &curr_num_entries_loaded, &curr_time_ms);
415 *num_entries_loaded += curr_num_entries_loaded;
416 max_time_ms = std::max(max_time_ms, curr_time_ms);
417 time_ms += curr_time_ms;
418 }
419
420 uint64_t memory_use_after;
421 GetApproximateMemoryUsage(&memory_use_after);
422 auto story_name =
423 base::StringPrintf("%u_%u_%zu", num_dbs, num_entries, data_size);
424 perf_test::PerfResultReporter reporter =
425 SetUpReporter(test_modifier, story_name);
426 reporter.AddResult(kMetricMemUseAfterWritesBytes,
427 static_cast<size_t>(memory_use_before));
428 reporter.AddResult(kMetricMemUseAfterLoadBytes,
429 static_cast<size_t>(memory_use_after));
430 reporter.AddResult(kMetricTotalTimeTakenMs, static_cast<size_t>(time_ms));
431 reporter.AddResult(kMetricMaxIndTimeTakenMs,
432 static_cast<size_t>(max_time_ms));
433
434 ShutdownDBs();
435 }
436
InitDBs(bool single_db,const std::vector<std::string> & prefixes)437 void InitDBs(bool single_db, const std::vector<std::string>& prefixes) {
438 if (single_db) {
439 InitDB(kSingleDBName);
440 } else {
441 for (auto& prefix : prefixes) {
442 InitDB(prefix);
443 }
444 }
445 }
446
PrefillDatabase(const std::string & name,std::vector<std::string> & prefixes,int num_entries,int data_size)447 PerfStats PrefillDatabase(const std::string& name,
448 std::vector<std::string>& prefixes,
449 int num_entries,
450 int data_size) {
451 InitDB(name);
452
453 auto entries = GenerateTestEntries(prefixes, num_entries, data_size);
454 PerfStats stats;
455 for (auto& prefix : prefixes) {
456 InsertEntries(name, std::move(entries[prefix]), &stats);
457 }
458 return stats;
459 }
460
CombinePerfStats(const PerfStats & a,const PerfStats & b)461 PerfStats CombinePerfStats(const PerfStats& a, const PerfStats& b) {
462 PerfStats out;
463 out.time_ms = a.time_ms + b.time_ms;
464 out.num_runs = a.num_runs + b.num_runs;
465 out.memory_summed_bytes = a.memory_summed_bytes + b.memory_summed_bytes;
466 out.max_memory_used_bytes =
467 std::max(a.max_memory_used_bytes, b.max_memory_used_bytes);
468 return out;
469 }
470
471 private:
PruneBlockCache()472 void PruneBlockCache() {
473 leveldb_chrome::GetSharedBrowserBlockCache()->Prune();
474 }
475
GenerateTestEntries(const std::vector<std::string> & prefixes,int num_entries,int data_size)476 KeyEntryVectorMap GenerateTestEntries(
477 const std::vector<std::string>& prefixes,
478 int num_entries,
479 int data_size) {
480 KeyEntryVectorMap entries;
481 for (const auto& prefix : prefixes) {
482 entries[prefix] = GenerateTestEntries(prefix, num_entries, data_size);
483 }
484 return entries;
485 }
486
GenerateTestEntries(const std::string & prefix,int num_entries,int data_size)487 std::unique_ptr<KeyEntryVector> GenerateTestEntries(const std::string& prefix,
488 int num_entries,
489 int data_size) {
490 auto entries = std::make_unique<KeyEntryVector>();
491 AddEntriesToVector(prefix, entries.get(), 0, num_entries, data_size);
492 return entries;
493 }
494
LoadEntriesFromDB(TestDatabase * db,std::string prefix,bool fill_read_cache,unsigned int * num_entries_loaded,uint64_t * time_ms)495 void LoadEntriesFromDB(TestDatabase* db,
496 std::string prefix,
497 bool fill_read_cache,
498 unsigned int* num_entries_loaded,
499 uint64_t* time_ms) {
500 base::ElapsedTimer timer;
501 base::RunLoop run_load_entries;
502 leveldb::ReadOptions options;
503 options.fill_cache = fill_read_cache;
504 db->proto_db()->LoadEntriesWithFilter(
505 KeyFilter(), options, prefix,
506 base::BindOnce(
507 [](base::OnceClosure signal, unsigned int* num_entries_loaded,
508 bool success, std::unique_ptr<std::vector<TestProto>> entries) {
509 EXPECT_TRUE(success);
510 *num_entries_loaded = entries->size();
511 std::move(signal).Run();
512 },
513 run_load_entries.QuitClosure(), num_entries_loaded));
514 run_load_entries.Run();
515 *time_ms = timer.Elapsed().InMilliseconds();
516 }
517
AddEntriesToVector(const std::string & prefix,KeyEntryVector * entries,int start_id,int num,int data_size)518 void AddEntriesToVector(const std::string& prefix,
519 KeyEntryVector* entries,
520 int start_id,
521 int num,
522 int data_size) {
523 for (int i = 0; i < num; i++) {
524 char data[data_size];
525 std::fill_n(data, data_size - 1, ':');
526 data[data_size - 1] = '\0';
527 std::string entry_name =
528 base::StringPrintf("%s_entry_%d", prefix.c_str(), (start_id + i));
529 TestProto proto;
530 proto.set_id(entry_name);
531 proto.set_data(std::string(data));
532 entries->emplace_back(std::make_pair(entry_name, std::move(proto)));
533 }
534 }
535
GetApproximateMemoryUsageOfDB(TestDatabase * db,uint64_t * memory_use)536 bool GetApproximateMemoryUsageOfDB(TestDatabase* db, uint64_t* memory_use) {
537 return db->proto_db()
538 ->db_wrapper_for_testing()
539 ->db_for_testing()
540 ->GetApproximateMemoryUse(memory_use);
541 }
542
SetUpReporter(const std::string & test_type,const std::string & story_name)543 perf_test::PerfResultReporter SetUpReporter(const std::string& test_type,
544 const std::string& story_name) {
545 perf_test::PerfResultReporter reporter("ProtoDB_" + test_type + ".",
546 story_name);
547 reporter.RegisterImportantMetric(kMetricNumRunsCount, "count");
548 reporter.RegisterImportantMetric(kMetricTimeMs, "ms");
549 reporter.RegisterImportantMetric(kMetricMaxMemoryUseBytes, "bytes");
550 reporter.RegisterImportantMetric(kMetricAverageMemoryUseBytes, "bytes");
551 reporter.RegisterImportantMetric(kMetricTotalMemoryUseBytes, "bytes");
552 reporter.RegisterImportantMetric(kMetricMemUseAfterWritesBytes, "bytes");
553 reporter.RegisterImportantMetric(kMetricMemUseAfterLoadBytes, "bytes");
554 reporter.RegisterImportantMetric(kMetricTotalTimeTakenMs, "ms");
555 reporter.RegisterImportantMetric(kMetricMaxIndTimeTakenMs, "ms");
556 return reporter;
557 }
558
559 std::map<std::string, std::unique_ptr<ScopedTempDir>> temp_dirs_;
560 std::map<std::string, std::unique_ptr<TestDatabase>> dbs_;
561 base::test::SingleThreadTaskEnvironment task_environment_;
562 scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
563 };
564
565 // Flakily times out on Windows, see http://crbug.com/918874.
566 #if defined(OS_WIN)
567 #define MAYBE_InsertMultipleDBsAlternating_Individual_100b \
568 DISABLED_InsertMultipleDBsAlternating_Individual_100b
569 #else
570 #define MAYBE_InsertMultipleDBsAlternating_Individual_100b \
571 InsertMultipleDBsAlternating_Individual_100b
572 #endif
TEST_F(ProtoDBPerfTest,MAYBE_InsertMultipleDBsAlternating_Individual_100b)573 TEST_F(ProtoDBPerfTest, MAYBE_InsertMultipleDBsAlternating_Individual_100b) {
574 // num_entries, data_size, batch_size, single_db.
575 TestParams params = {200, kMediumDataSize, 1, false};
576 RunAlternatingInsertTests({params}, "InsertMultipleDBsAlternating_Individual",
577 5);
578 }
579
580 // Flakily times out on Windows, see http://crbug.com/918874.
581 #if defined(OS_WIN)
582 #define MAYBE_InsertMultipleDBsAlternating_Individual_1000b \
583 DISABLED_InsertMultipleDBsAlternating_Individual_1000b
584 #else
585 #define MAYBE_InsertMultipleDBsAlternating_Individual_1000b \
586 InsertMultipleDBsAlternating_Individual_1000b
587 #endif
TEST_F(ProtoDBPerfTest,MAYBE_InsertMultipleDBsAlternating_Individual_1000b)588 TEST_F(ProtoDBPerfTest, MAYBE_InsertMultipleDBsAlternating_Individual_1000b) {
589 // num_entries, data_size, batch_size, single_db.
590 TestParams params = {200, kLargeDataSize, 1, false};
591 RunAlternatingInsertTests({params}, "InsertMultipleDBsAlternating_Individual",
592 5);
593 }
594
595 // Flakily times out on Windows, see http://crbug.com/918874.
596 #if defined(OS_WIN)
597 #define MAYBE_InsertSingleDBAlternating_Individual_100b \
598 DISABLED_InsertSingleDBAlternating_Individual_100b
599 #else
600 #define MAYBE_InsertSingleDBAlternating_Individual_100b \
601 InsertSingleDBAlternating_Individual_100b
602 #endif
TEST_F(ProtoDBPerfTest,MAYBE_InsertSingleDBAlternating_Individual_100b)603 TEST_F(ProtoDBPerfTest, MAYBE_InsertSingleDBAlternating_Individual_100b) {
604 // num_entries, data_size, batch_size, single_db.
605 TestParams params = {200, kMediumDataSize, 1, true};
606 RunAlternatingInsertTests({params}, "InsertSingleDBAlternating_Individual",
607 5);
608 }
609
610 // Flakily times out on Windows, see http://crbug.com/918874.
611 #if defined(OS_WIN)
612 #define MAYBE_InsertSingleDBAlternating_Individual_1000b \
613 DISABLED_InsertSingleDBAlternating_Individual_1000b
614 #else
615 #define MAYBE_InsertSingleDBAlternating_Individual_1000b \
616 InsertSingleDBAlternating_Individual_1000b
617 #endif
TEST_F(ProtoDBPerfTest,MAYBE_InsertSingleDBAlternating_Individual_1000b)618 TEST_F(ProtoDBPerfTest, MAYBE_InsertSingleDBAlternating_Individual_1000b) {
619 // num_entries, data_size, batch_size, single_db.
620 TestParams params = {200, kLargeDataSize, 1, true};
621 RunAlternatingInsertTests({params}, "InsertSingleDBAlternating_Individual",
622 5);
623 }
624
TEST_F(ProtoDBPerfTest,InsertMultipleDBsAlternating_LargeBatch_100b)625 TEST_F(ProtoDBPerfTest, InsertMultipleDBsAlternating_LargeBatch_100b) {
626 // num_entries, data_size, batch_size, single_db.
627 TestParams params = {200, kMediumDataSize, 200, false};
628 RunAlternatingInsertTests({params}, "InsertMultipleDBsAlternating_LargeBatch",
629 5);
630 }
631
TEST_F(ProtoDBPerfTest,InsertMultipleDBsAlternating_LargeBatch_1000b)632 TEST_F(ProtoDBPerfTest, InsertMultipleDBsAlternating_LargeBatch_1000b) {
633 // num_entries, data_size, batch_size, single_db.
634 TestParams params = {200, kLargeDataSize, 200, false};
635 RunAlternatingInsertTests({params}, "InsertMultipleDBsAlternating_LargeBatch",
636 5);
637 }
638
TEST_F(ProtoDBPerfTest,InsertSingleDBAlternating_LargeBatch_100b)639 TEST_F(ProtoDBPerfTest, InsertSingleDBAlternating_LargeBatch_100b) {
640 // num_entries, data_size, batch_size, single_db.
641 TestParams params = {200, kMediumDataSize, 200, true};
642 RunAlternatingInsertTests({params}, "InsertSingleDBAlternating_LargeBatch",
643 5);
644 }
645
TEST_F(ProtoDBPerfTest,InsertSingleDBAlternating_LargeBatch_1000b)646 TEST_F(ProtoDBPerfTest, InsertSingleDBAlternating_LargeBatch_1000b) {
647 // num_entries, data_size, batch_size, single_db.
648 TestParams params = {200, kLargeDataSize, 200, true};
649 RunAlternatingInsertTests({params}, "InsertSingleDBAlternating_LargeBatch",
650 5);
651 }
652
TEST_F(ProtoDBPerfTest,DistributionTestSmall_FewEntries_Single)653 TEST_F(ProtoDBPerfTest, DistributionTestSmall_FewEntries_Single) {
654 RunDistributionTestAndCleanup("Small_FewEntries_Single",
655 kFewEntriesDistributionTestParams, true);
656 }
657
TEST_F(ProtoDBPerfTest,DistributionTestSmall_FewEntries_Multi)658 TEST_F(ProtoDBPerfTest, DistributionTestSmall_FewEntries_Multi) {
659 RunDistributionTestAndCleanup("Small_FewEntries_Multi",
660 kFewEntriesDistributionTestParams, false);
661 }
662
TEST_F(ProtoDBPerfTest,DistributionTestSmall_ManyEntries_Single)663 TEST_F(ProtoDBPerfTest, DistributionTestSmall_ManyEntries_Single) {
664 RunDistributionTestAndCleanup("Small_ManyEntries_Single",
665 kManyEntriesDistributionTestParams, true);
666 }
667
TEST_F(ProtoDBPerfTest,DistributionTestSmall_ManyEntries_Multi)668 TEST_F(ProtoDBPerfTest, DistributionTestSmall_ManyEntries_Multi) {
669 RunDistributionTestAndCleanup("Small_ManyEntries_Multi",
670 kManyEntriesDistributionTestParams, false);
671 }
672
TEST_F(ProtoDBPerfTest,DistributionTestSmall_ManyEntries_Batch_Single)673 TEST_F(ProtoDBPerfTest, DistributionTestSmall_ManyEntries_Batch_Single) {
674 RunDistributionTestAndCleanup("Small_ManyEntries_Batch_Single",
675 kManyEntriesDistributionTestParams, true);
676 }
677
TEST_F(ProtoDBPerfTest,DistributionTestSmall_ManyEntries_Batch_Multi)678 TEST_F(ProtoDBPerfTest, DistributionTestSmall_ManyEntries_Batch_Multi) {
679 RunDistributionTestAndCleanup("Small_ManyEntries_Batch_Multi",
680 kManyEntriesDistributionTestParams, false);
681 }
682
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_Small)683 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_Small) {
684 unsigned int num_entries = 0;
685 RunLoadEntriesSingleTestAndCleanup(kDefaultNumDBs, kSmallNumEntries,
686 kSmallDataSize, {}, "LoadEntriesSingle",
687 &num_entries);
688 ASSERT_NE(num_entries, 0U);
689 }
690
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_Medium)691 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_Medium) {
692 unsigned int num_entries = 0;
693 RunLoadEntriesSingleTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
694 kSmallDataSize, {}, "LoadEntriesSingle",
695 &num_entries);
696 ASSERT_NE(num_entries, 0U);
697 }
698
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_Large)699 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_Large) {
700 unsigned int num_entries = 0;
701 RunLoadEntriesSingleTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
702 kMediumDataSize, {}, "LoadEntriesSingle",
703 &num_entries);
704 ASSERT_NE(num_entries, 0U);
705 }
706
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_Small)707 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_OnePrefix_Small) {
708 // Load only the entries that start with a particular prefix.
709 unsigned int num_entries = 0;
710 RunLoadEntriesSingleTestAndCleanup(
711 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {1},
712 "LoadEntriesSingle_OnePrefix", &num_entries);
713 ASSERT_NE(num_entries, 0U);
714 }
715
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_Medium)716 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_OnePrefix_Medium) {
717 // Load only the entries that start with a particular prefix.
718 unsigned int num_entries = 0;
719 RunLoadEntriesSingleTestAndCleanup(
720 kDefaultNumDBs, kLargeNumEntries, kSmallDataSize, {1},
721 "LoadEntriesSingle_OnePrefix", &num_entries);
722 ASSERT_NE(num_entries, 0U);
723 }
724
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_Large)725 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_OnePrefix_Large) {
726 // Load only the entries that start with a particular prefix.
727 unsigned int num_entries = 0;
728 RunLoadEntriesSingleTestAndCleanup(
729 kDefaultNumDBs, kLargeNumEntries, kMediumDataSize, {1},
730 "LoadEntriesSingle_OnePrefix", &num_entries);
731 ASSERT_NE(num_entries, 0U);
732 }
733
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_Small)734 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_Small) {
735 unsigned int num_entries = 0;
736 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kSmallNumEntries,
737 kSmallDataSize, {}, "LoadEntriesMulti",
738 &num_entries);
739 ASSERT_NE(num_entries, 0U);
740 }
741
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_Medium)742 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_Medium) {
743 unsigned int num_entries = 0;
744 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
745 kSmallDataSize, {}, "LoadEntriesMulti",
746 &num_entries);
747 ASSERT_NE(num_entries, 0U);
748 }
749
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_Large)750 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_Large) {
751 unsigned int num_entries = 0;
752 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
753 kMediumDataSize, {}, "LoadEntriesMulti",
754 &num_entries);
755 ASSERT_NE(num_entries, 0U);
756 }
757
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_Small)758 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_OnePrefix_Small) {
759 unsigned int num_entries = 0;
760 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kSmallNumEntries,
761 kSmallDataSize, {1},
762 "LoadEntriesMulti_OnePrefix", &num_entries);
763 ASSERT_NE(num_entries, 0U);
764 }
765
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_Medium)766 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_OnePrefix_Medium) {
767 unsigned int num_entries = 0;
768 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
769 kSmallDataSize, {1},
770 "LoadEntriesMulti_OnePrefix", &num_entries);
771 ASSERT_NE(num_entries, 0U);
772 }
773
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_Large)774 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_OnePrefix_Large) {
775 unsigned int num_entries = 0;
776 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
777 kMediumDataSize, {1},
778 "LoadEntriesMulti_OnePrefix", &num_entries);
779 ASSERT_NE(num_entries, 0U);
780 }
781
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_SkipReadCache_Small)782 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_SkipReadCache_Small) {
783 unsigned int num_entries = 0;
784 RunLoadEntriesSingleTestAndCleanup(kDefaultNumDBs, kSmallNumEntries,
785 kSmallDataSize, {},
786 "LoadEntriesSingle_SkipReadCache",
787 &num_entries, false /* fill_read_cache */);
788 ASSERT_NE(num_entries, 0U);
789 }
790
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_SkipReadCache_Medium)791 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_SkipReadCache_Medium) {
792 unsigned int num_entries = 0;
793 RunLoadEntriesSingleTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
794 kSmallDataSize, {},
795 "LoadEntriesSingle_SkipReadCache",
796 &num_entries, false /* fill_read_cache */);
797 ASSERT_NE(num_entries, 0U);
798 }
799
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_SkipReadCache_Large)800 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_SkipReadCache_Large) {
801 unsigned int num_entries = 0;
802 RunLoadEntriesSingleTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
803 kMediumDataSize, {},
804 "LoadEntriesSingle_SkipReadCache",
805 &num_entries, false /* fill_read_cache */);
806 ASSERT_NE(num_entries, 0U);
807 }
808
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_SkipReadCache_Small)809 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_OnePrefix_SkipReadCache_Small) {
810 // Load only the entries that start with a particular prefix.
811 unsigned int num_entries = 0;
812 RunLoadEntriesSingleTestAndCleanup(
813 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {1},
814 "LoadEntriesSingle_OnePrefix_SkipReadCache", &num_entries,
815 false /* fill_read_cache */);
816 ASSERT_NE(num_entries, 0U);
817 }
818
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_SkipReadCache_Medium)819 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_OnePrefix_SkipReadCache_Medium) {
820 // Load only the entries that start with a particular prefix.
821 unsigned int num_entries = 0;
822 RunLoadEntriesSingleTestAndCleanup(
823 kDefaultNumDBs, kLargeNumEntries, kSmallDataSize, {1},
824 "LoadEntriesSingle_OnePrefix_SkipReadCache", &num_entries,
825 false /* fill_read_cache */);
826 ASSERT_NE(num_entries, 0U);
827 }
828
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_SkipReadCache_Large)829 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_OnePrefix_SkipReadCache_Large) {
830 // Load only the entries that start with a particular prefix.
831 unsigned int num_entries = 0;
832 RunLoadEntriesSingleTestAndCleanup(
833 kDefaultNumDBs, kLargeNumEntries, kMediumDataSize, {1},
834 "LoadEntriesSingle_OnePrefix_SkipReadCache", &num_entries,
835 false /* fill_read_cache */);
836 ASSERT_NE(num_entries, 0U);
837 }
838
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_SkipReadCache_Small)839 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_SkipReadCache_Small) {
840 unsigned int num_entries = 0;
841 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kSmallNumEntries,
842 kSmallDataSize, {},
843 "LoadEntriesMulti_SkipReadCache",
844 &num_entries, false /* fill_read_cache */);
845 ASSERT_NE(num_entries, 0U);
846 }
847
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_SkipReadCache_Medium)848 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_SkipReadCache_Medium) {
849 unsigned int num_entries = 0;
850 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
851 kSmallDataSize, {},
852 "LoadEntriesMulti_SkipReadCache",
853 &num_entries, false /* fill_read_cache */);
854 ASSERT_NE(num_entries, 0U);
855 }
856
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_SkipReadCache_Large)857 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_SkipReadCache_Large) {
858 unsigned int num_entries = 0;
859 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
860 kMediumDataSize, {},
861 "LoadEntriesMulti_SkipReadCache",
862 &num_entries, false /* fill_read_cache */);
863 ASSERT_NE(num_entries, 0U);
864 }
865
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_SkipReadCache_Small)866 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_OnePrefix_SkipReadCache_Small) {
867 unsigned int num_entries = 0;
868 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kSmallNumEntries,
869 kSmallDataSize, {1},
870 "LoadEntriesMulti_OnePrefix_SkipReadCache",
871 &num_entries, false /* fill_read_cache */);
872 ASSERT_NE(num_entries, 0U);
873 }
874
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_SkipReadCache_Medium)875 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_OnePrefix_SkipReadCache_Medium) {
876 unsigned int num_entries = 0;
877 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
878 kSmallDataSize, {1},
879 "LoadEntriesMulti_OnePrefix_SkipReadCache",
880 &num_entries, false /* fill_read_cache */);
881 ASSERT_NE(num_entries, 0U);
882 }
883
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_SkipReadCache_Large)884 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_OnePrefix_SkipReadCache_Large) {
885 unsigned int num_entries = 0;
886 RunLoadEntriesMultiTestAndCleanup(kDefaultNumDBs, kLargeNumEntries,
887 kMediumDataSize, {1},
888 "LoadEntriesMulti_OnePrefix_SkipReadCache",
889 &num_entries, false /* fill_read_cache */);
890 ASSERT_NE(num_entries, 0U);
891 }
892
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_DifferingNumDBs_Small)893 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_OnePrefix_DifferingNumDBs_Small) {
894 unsigned int num_entries = 0;
895 RunLoadEntriesSingleTestAndCleanup(
896 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {1},
897 "LoadEntriesSingle_OnePrefix_DifferingNumDBs", &num_entries);
898 ASSERT_NE(num_entries, 0U);
899 }
900
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_DifferingNumDBs_Medium)901 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_OnePrefix_DifferingNumDBs_Medium) {
902 unsigned int num_entries = 0;
903 RunLoadEntriesSingleTestAndCleanup(
904 kDefaultNumDBs * 2, kSmallNumEntries, kSmallDataSize, {1},
905 "LoadEntriesSingle_OnePrefix_DifferingNumDBs", &num_entries);
906 ASSERT_NE(num_entries, 0U);
907 }
908
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_DifferingNumDBs_Large)909 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_OnePrefix_DifferingNumDBs_Large) {
910 unsigned int num_entries = 0;
911 RunLoadEntriesSingleTestAndCleanup(
912 kDefaultNumDBs * 4, kSmallNumEntries, kSmallDataSize, {1},
913 "LoadEntriesSingle_OnePrefix_DifferingNumDBs", &num_entries);
914 ASSERT_NE(num_entries, 0U);
915 }
916
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_DifferingNumDBs_Small)917 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_OnePrefix_DifferingNumDBs_Small) {
918 unsigned int num_entries = 0;
919 RunLoadEntriesMultiTestAndCleanup(
920 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {1},
921 "LoadEntriesMulti_OnePrefix_DifferingNumDBs", &num_entries);
922 ASSERT_NE(num_entries, 0U);
923 }
924
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_DifferingNumDBs_Medium)925 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_OnePrefix_DifferingNumDBs_Medium) {
926 unsigned int num_entries = 0;
927 RunLoadEntriesMultiTestAndCleanup(
928 kDefaultNumDBs * 2, kSmallNumEntries, kSmallDataSize, {1},
929 "LoadEntriesMulti_OnePrefix_DifferingNumDBs", &num_entries);
930 ASSERT_NE(num_entries, 0U);
931 }
932
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_DifferingNumDBs_Large)933 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_OnePrefix_DifferingNumDBs_Large) {
934 unsigned int num_entries = 0;
935 RunLoadEntriesMultiTestAndCleanup(
936 kDefaultNumDBs * 4, kSmallNumEntries, kSmallDataSize, {1},
937 "LoadEntriesMulti_OnePrefix_DifferingNumDBs", &num_entries);
938 ASSERT_NE(num_entries, 0U);
939 }
940
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_DifferingNumDBs_SkipReadCache_Small)941 TEST_F(ProtoDBPerfTest,
942 LoadEntriesSingle_OnePrefix_DifferingNumDBs_SkipReadCache_Small) {
943 unsigned int num_entries = 0;
944 RunLoadEntriesSingleTestAndCleanup(
945 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {1},
946 "LoadEntriesSingle_OnePrefix_DifferingNumDBs_SkipReadCache", &num_entries,
947 false /* fill_read_cache */);
948 ASSERT_NE(num_entries, 0U);
949 }
950
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_DifferingNumDBs_SkipReadCache_Medium)951 TEST_F(ProtoDBPerfTest,
952 LoadEntriesSingle_OnePrefix_DifferingNumDBs_SkipReadCache_Medium) {
953 unsigned int num_entries = 0;
954 RunLoadEntriesSingleTestAndCleanup(
955 kDefaultNumDBs * 2, kSmallNumEntries, kSmallDataSize, {1},
956 "LoadEntriesSingle_OnePrefix_DifferingNumDBs_SkipReadCache", &num_entries,
957 false /* fill_read_cache */);
958 ASSERT_NE(num_entries, 0U);
959 }
960
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_OnePrefix_DifferingNumDBs_SkipReadCache_Large)961 TEST_F(ProtoDBPerfTest,
962 LoadEntriesSingle_OnePrefix_DifferingNumDBs_SkipReadCache_Large) {
963 unsigned int num_entries = 0;
964 RunLoadEntriesSingleTestAndCleanup(
965 kDefaultNumDBs * 4, kSmallNumEntries, kSmallDataSize, {1},
966 "LoadEntriesSingle_OnePrefix_DifferingNumDBs_SkipReadCache", &num_entries,
967 false /* fill_read_cache */);
968 ASSERT_NE(num_entries, 0U);
969 }
970
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_DifferingNumDBs_SkipReadCache_Small)971 TEST_F(ProtoDBPerfTest,
972 LoadEntriesMulti_OnePrefix_DifferingNumDBs_SkipReadCache_Small) {
973 unsigned int num_entries = 0;
974 RunLoadEntriesMultiTestAndCleanup(
975 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {1},
976 "LoadEntriesMulti_OnePrefix_DifferingNumDBs_SkipReadCache", &num_entries,
977 false /* fill_read_cache */);
978 ASSERT_NE(num_entries, 0U);
979 }
980
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_DifferingNumDBs_SkipReadCache_Medium)981 TEST_F(ProtoDBPerfTest,
982 LoadEntriesMulti_OnePrefix_DifferingNumDBs_SkipReadCache_Medium) {
983 unsigned int num_entries = 0;
984 RunLoadEntriesMultiTestAndCleanup(
985 kDefaultNumDBs * 2, kSmallNumEntries, kSmallDataSize, {1},
986 "LoadEntriesMulti_OnePrefix_DifferingNumDBs_SkipReadCache", &num_entries,
987 false /* fill_read_cache */);
988 ASSERT_NE(num_entries, 0U);
989 }
990
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_OnePrefix_DifferingNumDBs_SkipReadCache_Large)991 TEST_F(ProtoDBPerfTest,
992 LoadEntriesMulti_OnePrefix_DifferingNumDBs_SkipReadCache_Large) {
993 unsigned int num_entries = 0;
994 RunLoadEntriesMultiTestAndCleanup(
995 kDefaultNumDBs * 4, kSmallNumEntries, kSmallDataSize, {1},
996 "LoadEntriesMulti_OnePrefix_DifferingNumDBs_SkipReadCache", &num_entries,
997 false /* fill_read_cache */);
998 ASSERT_NE(num_entries, 0U);
999 }
1000
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_DifferingNumDBs_Small)1001 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_DifferingNumDBs_Small) {
1002 unsigned int num_entries = 0;
1003 RunLoadEntriesSingleTestAndCleanup(
1004 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {},
1005 "LoadEntriesSingle_DifferingNumDBs", &num_entries);
1006 ASSERT_NE(num_entries, 0U);
1007 }
1008
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_DifferingNumDBs_Medium)1009 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_DifferingNumDBs_Medium) {
1010 unsigned int num_entries = 0;
1011 RunLoadEntriesSingleTestAndCleanup(
1012 kDefaultNumDBs * 2, kSmallNumEntries, kSmallDataSize, {},
1013 "LoadEntriesSingle_DifferingNumDBs", &num_entries);
1014 ASSERT_NE(num_entries, 0U);
1015 }
1016
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_DifferingNumDBs_Large)1017 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_DifferingNumDBs_Large) {
1018 unsigned int num_entries = 0;
1019 RunLoadEntriesSingleTestAndCleanup(
1020 kDefaultNumDBs * 4, kSmallNumEntries, kSmallDataSize, {},
1021 "LoadEntriesSingle_DifferingNumDBs", &num_entries);
1022 ASSERT_NE(num_entries, 0U);
1023 }
1024
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_DifferingNumDBs_Small)1025 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_DifferingNumDBs_Small) {
1026 unsigned int num_entries = 0;
1027 RunLoadEntriesMultiTestAndCleanup(
1028 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {},
1029 "LoadEntriesMulti_DifferingNumDBs", &num_entries);
1030 ASSERT_NE(num_entries, 0U);
1031 }
1032
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_DifferingNumDBs_Medium)1033 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_DifferingNumDBs_Medium) {
1034 unsigned int num_entries = 0;
1035 RunLoadEntriesMultiTestAndCleanup(
1036 kDefaultNumDBs * 2, kSmallNumEntries, kSmallDataSize, {},
1037 "LoadEntriesMulti_DifferingNumDBs", &num_entries);
1038 ASSERT_NE(num_entries, 0U);
1039 }
1040
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_DifferingNumDBs_Large)1041 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_DifferingNumDBs_Large) {
1042 unsigned int num_entries = 0;
1043 RunLoadEntriesMultiTestAndCleanup(
1044 kDefaultNumDBs * 4, kSmallNumEntries, kSmallDataSize, {},
1045 "LoadEntriesMulti_DifferingNumDBs", &num_entries);
1046 ASSERT_NE(num_entries, 0U);
1047 }
1048
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_DifferingNumDBs_SkipReadCache_Small)1049 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_DifferingNumDBs_SkipReadCache_Small) {
1050 unsigned int num_entries = 0;
1051 RunLoadEntriesSingleTestAndCleanup(
1052 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {},
1053 "LoadEntriesSingle_DifferingNumDBs_SkipReadCache", &num_entries,
1054 false /* fill_read_cache */);
1055 ASSERT_NE(num_entries, 0U);
1056 }
1057
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_DifferingNumDBs_SkipReadCache_Medium)1058 TEST_F(ProtoDBPerfTest,
1059 LoadEntriesSingle_DifferingNumDBs_SkipReadCache_Medium) {
1060 unsigned int num_entries = 0;
1061 RunLoadEntriesSingleTestAndCleanup(
1062 kDefaultNumDBs * 2, kSmallNumEntries, kSmallDataSize, {},
1063 "LoadEntriesSingle_DifferingNumDBs_SkipReadCache", &num_entries,
1064 false /* fill_read_cache */);
1065 ASSERT_NE(num_entries, 0U);
1066 }
1067
TEST_F(ProtoDBPerfTest,LoadEntriesSingle_DifferingNumDBs_SkipReadCache_Large)1068 TEST_F(ProtoDBPerfTest, LoadEntriesSingle_DifferingNumDBs_SkipReadCache_Large) {
1069 unsigned int num_entries = 0;
1070 RunLoadEntriesSingleTestAndCleanup(
1071 kDefaultNumDBs * 4, kSmallNumEntries, kSmallDataSize, {},
1072 "LoadEntriesSingle_DifferingNumDBs_SkipReadCache", &num_entries,
1073 false /* fill_read_cache */);
1074 ASSERT_NE(num_entries, 0U);
1075 }
1076
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_DifferingNumDBs_SkipReadCache_Small)1077 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_DifferingNumDBs_SkipReadCache_Small) {
1078 unsigned int num_entries = 0;
1079 RunLoadEntriesMultiTestAndCleanup(
1080 kDefaultNumDBs, kSmallNumEntries, kSmallDataSize, {},
1081 "LoadEntriesMulti_DifferingNumDBs_SkipReadCache", &num_entries,
1082 false /* fill_read_cache */);
1083 ASSERT_NE(num_entries, 0U);
1084 }
1085
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_DifferingNumDBs_SkipReadCache_Medium)1086 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_DifferingNumDBs_SkipReadCache_Medium) {
1087 unsigned int num_entries = 0;
1088 RunLoadEntriesMultiTestAndCleanup(
1089 kDefaultNumDBs * 2, kSmallNumEntries, kSmallDataSize, {},
1090 "LoadEntriesMulti_DifferingNumDBs_SkipReadCache", &num_entries,
1091 false /* fill_read_cache */);
1092 ASSERT_NE(num_entries, 0U);
1093 }
1094
TEST_F(ProtoDBPerfTest,LoadEntriesMulti_DifferingNumDBs_SkipReadCache_Large)1095 TEST_F(ProtoDBPerfTest, LoadEntriesMulti_DifferingNumDBs_SkipReadCache_Large) {
1096 unsigned int num_entries = 0;
1097 RunLoadEntriesMultiTestAndCleanup(
1098 kDefaultNumDBs * 4, kSmallNumEntries, kSmallDataSize, {},
1099 "LoadEntriesMulti_DifferingNumDBs_SkipReadCache", &num_entries,
1100 false /* fill_read_cache */);
1101 ASSERT_NE(num_entries, 0U);
1102 }
1103
1104 } // namespace leveldb_proto
1105