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 <stdio.h>
6 #include <stdlib.h>
7 #include <kcpolydb.h>
8 #include "util/histogram.h"
9 #include "util/random.h"
10 #include "util/testutil.h"
11 
12 // Comma-separated list of operations to run in the specified order
13 //   Actual benchmarks:
14 //
15 //   fillseq       -- write N values in sequential key order in async mode
16 //   fillrandom    -- write N values in random key order in async mode
17 //   overwrite     -- overwrite N values in random key order in async mode
18 //   fillseqsync   -- write N/100 values in sequential key order in sync mode
19 //   fillrandsync  -- write N/100 values in random key order in sync mode
20 //   fillrand100K  -- write N/1000 100K values in random order in async mode
21 //   fillseq100K   -- write N/1000 100K values in seq order in async mode
22 //   readseq       -- read N times sequentially
23 //   readseq100K   -- read N/1000 100K values in sequential order in async mode
24 //   readrand100K  -- read N/1000 100K values in sequential order in async mode
25 //   readrandom    -- read N times in random order
26 static const char* FLAGS_benchmarks =
27     "fillseq,"
28     "fillseqsync,"
29     "fillrandsync,"
30     "fillrandom,"
31     "overwrite,"
32     "readrandom,"
33     "readseq,"
34     "fillrand100K,"
35     "fillseq100K,"
36     "readseq100K,"
37     "readrand100K,"
38     ;
39 
40 // Number of key/values to place in database
41 static int FLAGS_num = 1000000;
42 
43 // Number of read operations to do.  If negative, do FLAGS_num reads.
44 static int FLAGS_reads = -1;
45 
46 // Size of each value
47 static int FLAGS_value_size = 100;
48 
49 // Arrange to generate values that shrink to this fraction of
50 // their original size after compression
51 static double FLAGS_compression_ratio = 0.5;
52 
53 // Print histogram of operation timings
54 static bool FLAGS_histogram = false;
55 
56 // Cache size. Default 4 MB
57 static int FLAGS_cache_size = 4194304;
58 
59 // Page size. Default 1 KB
60 static int FLAGS_page_size = 1024;
61 
62 // If true, do not destroy the existing database.  If you set this
63 // flag and also specify a benchmark that wants a fresh database, that
64 // benchmark will fail.
65 static bool FLAGS_use_existing_db = false;
66 
67 // Compression flag. If true, compression is on. If false, compression
68 // is off.
69 static bool FLAGS_compression = true;
70 
71 // Use the db with the following name.
72 static const char* FLAGS_db = NULL;
73 
74 inline
DBSynchronize(kyotocabinet::TreeDB * db_)75 static void DBSynchronize(kyotocabinet::TreeDB* db_)
76 {
77   // Synchronize will flush writes to disk
78   if (!db_->synchronize()) {
79     fprintf(stderr, "synchronize error: %s\n", db_->error().name());
80   }
81 }
82 
83 namespace leveldb {
84 
85 // Helper for quickly generating random data.
86 namespace {
87 class RandomGenerator {
88  private:
89   std::string data_;
90   int pos_;
91 
92  public:
RandomGenerator()93   RandomGenerator() {
94     // We use a limited amount of data over and over again and ensure
95     // that it is larger than the compression window (32KB), and also
96     // large enough to serve all typical value sizes we want to write.
97     Random rnd(301);
98     std::string piece;
99     while (data_.size() < 1048576) {
100       // Add a short fragment that is as compressible as specified
101       // by FLAGS_compression_ratio.
102       test::CompressibleString(&rnd, FLAGS_compression_ratio, 100, &piece);
103       data_.append(piece);
104     }
105     pos_ = 0;
106   }
107 
Generate(int len)108   Slice Generate(int len) {
109     if (pos_ + len > data_.size()) {
110       pos_ = 0;
111       assert(len < data_.size());
112     }
113     pos_ += len;
114     return Slice(data_.data() + pos_ - len, len);
115   }
116 };
117 
TrimSpace(Slice s)118 static Slice TrimSpace(Slice s) {
119   int start = 0;
120   while (start < s.size() && isspace(s[start])) {
121     start++;
122   }
123   int limit = s.size();
124   while (limit > start && isspace(s[limit-1])) {
125     limit--;
126   }
127   return Slice(s.data() + start, limit - start);
128 }
129 
130 }  // namespace
131 
132 class Benchmark {
133  private:
134   kyotocabinet::TreeDB* db_;
135   int db_num_;
136   int num_;
137   int reads_;
138   double start_;
139   double last_op_finish_;
140   int64_t bytes_;
141   std::string message_;
142   Histogram hist_;
143   RandomGenerator gen_;
144   Random rand_;
145   kyotocabinet::LZOCompressor<kyotocabinet::LZO::RAW> comp_;
146 
147   // State kept for progress messages
148   int done_;
149   int next_report_;     // When to report next
150 
PrintHeader()151   void PrintHeader() {
152     const int kKeySize = 16;
153     PrintEnvironment();
154     fprintf(stdout, "Keys:       %d bytes each\n", kKeySize);
155     fprintf(stdout, "Values:     %d bytes each (%d bytes after compression)\n",
156             FLAGS_value_size,
157             static_cast<int>(FLAGS_value_size * FLAGS_compression_ratio + 0.5));
158     fprintf(stdout, "Entries:    %d\n", num_);
159     fprintf(stdout, "RawSize:    %.1f MB (estimated)\n",
160             ((static_cast<int64_t>(kKeySize + FLAGS_value_size) * num_)
161              / 1048576.0));
162     fprintf(stdout, "FileSize:   %.1f MB (estimated)\n",
163             (((kKeySize + FLAGS_value_size * FLAGS_compression_ratio) * num_)
164              / 1048576.0));
165     PrintWarnings();
166     fprintf(stdout, "------------------------------------------------\n");
167   }
168 
PrintWarnings()169   void PrintWarnings() {
170 #if defined(__GNUC__) && !defined(__OPTIMIZE__)
171     fprintf(stdout,
172             "WARNING: Optimization is disabled: benchmarks unnecessarily slow\n"
173             );
174 #endif
175 #ifndef NDEBUG
176     fprintf(stdout,
177             "WARNING: Assertions are enabled; benchmarks unnecessarily slow\n");
178 #endif
179   }
180 
PrintEnvironment()181   void PrintEnvironment() {
182     fprintf(stderr, "Kyoto Cabinet:    version %s, lib ver %d, lib rev %d\n",
183             kyotocabinet::VERSION, kyotocabinet::LIBVER, kyotocabinet::LIBREV);
184 
185 #if defined(__linux)
186     time_t now = time(NULL);
187     fprintf(stderr, "Date:           %s", ctime(&now));  // ctime() adds newline
188 
189     FILE* cpuinfo = fopen("/proc/cpuinfo", "r");
190     if (cpuinfo != NULL) {
191       char line[1000];
192       int num_cpus = 0;
193       std::string cpu_type;
194       std::string cache_size;
195       while (fgets(line, sizeof(line), cpuinfo) != NULL) {
196         const char* sep = strchr(line, ':');
197         if (sep == NULL) {
198           continue;
199         }
200         Slice key = TrimSpace(Slice(line, sep - 1 - line));
201         Slice val = TrimSpace(Slice(sep + 1));
202         if (key == "model name") {
203           ++num_cpus;
204           cpu_type = val.ToString();
205         } else if (key == "cache size") {
206           cache_size = val.ToString();
207         }
208       }
209       fclose(cpuinfo);
210       fprintf(stderr, "CPU:            %d * %s\n", num_cpus, cpu_type.c_str());
211       fprintf(stderr, "CPUCache:       %s\n", cache_size.c_str());
212     }
213 #endif
214   }
215 
Start()216   void Start() {
217     start_ = Env::Default()->NowMicros() * 1e-6;
218     bytes_ = 0;
219     message_.clear();
220     last_op_finish_ = start_;
221     hist_.Clear();
222     done_ = 0;
223     next_report_ = 100;
224   }
225 
FinishedSingleOp()226   void FinishedSingleOp() {
227     if (FLAGS_histogram) {
228       double now = Env::Default()->NowMicros() * 1e-6;
229       double micros = (now - last_op_finish_) * 1e6;
230       hist_.Add(micros);
231       if (micros > 20000) {
232         fprintf(stderr, "long op: %.1f micros%30s\r", micros, "");
233         fflush(stderr);
234       }
235       last_op_finish_ = now;
236     }
237 
238     done_++;
239     if (done_ >= next_report_) {
240       if      (next_report_ < 1000)   next_report_ += 100;
241       else if (next_report_ < 5000)   next_report_ += 500;
242       else if (next_report_ < 10000)  next_report_ += 1000;
243       else if (next_report_ < 50000)  next_report_ += 5000;
244       else if (next_report_ < 100000) next_report_ += 10000;
245       else if (next_report_ < 500000) next_report_ += 50000;
246       else                            next_report_ += 100000;
247       fprintf(stderr, "... finished %d ops%30s\r", done_, "");
248       fflush(stderr);
249     }
250   }
251 
Stop(const Slice & name)252   void Stop(const Slice& name) {
253     double finish = Env::Default()->NowMicros() * 1e-6;
254 
255     // Pretend at least one op was done in case we are running a benchmark
256     // that does not call FinishedSingleOp().
257     if (done_ < 1) done_ = 1;
258 
259     if (bytes_ > 0) {
260       char rate[100];
261       snprintf(rate, sizeof(rate), "%6.1f MB/s",
262                (bytes_ / 1048576.0) / (finish - start_));
263       if (!message_.empty()) {
264         message_  = std::string(rate) + " " + message_;
265       } else {
266         message_ = rate;
267       }
268     }
269 
270     fprintf(stdout, "%-12s : %11.3f micros/op;%s%s\n",
271             name.ToString().c_str(),
272             (finish - start_) * 1e6 / done_,
273             (message_.empty() ? "" : " "),
274             message_.c_str());
275     if (FLAGS_histogram) {
276       fprintf(stdout, "Microseconds per op:\n%s\n", hist_.ToString().c_str());
277     }
278     fflush(stdout);
279   }
280 
281  public:
282   enum Order {
283     SEQUENTIAL,
284     RANDOM
285   };
286   enum DBState {
287     FRESH,
288     EXISTING
289   };
290 
Benchmark()291   Benchmark()
292   : db_(NULL),
293     num_(FLAGS_num),
294     reads_(FLAGS_reads < 0 ? FLAGS_num : FLAGS_reads),
295     bytes_(0),
296     rand_(301) {
297     std::vector<std::string> files;
298     std::string test_dir;
299     Env::Default()->GetTestDirectory(&test_dir);
300     Env::Default()->GetChildren(test_dir.c_str(), &files);
301     if (!FLAGS_use_existing_db) {
302       for (int i = 0; i < files.size(); i++) {
303         if (Slice(files[i]).starts_with("dbbench_polyDB")) {
304           std::string file_name(test_dir);
305           file_name += "/";
306           file_name += files[i];
307           Env::Default()->DeleteFile(file_name.c_str());
308         }
309       }
310     }
311   }
312 
~Benchmark()313   ~Benchmark() {
314     if (!db_->close()) {
315       fprintf(stderr, "close error: %s\n", db_->error().name());
316     }
317   }
318 
Run()319   void Run() {
320     PrintHeader();
321     Open(false);
322 
323     const char* benchmarks = FLAGS_benchmarks;
324     while (benchmarks != NULL) {
325       const char* sep = strchr(benchmarks, ',');
326       Slice name;
327       if (sep == NULL) {
328         name = benchmarks;
329         benchmarks = NULL;
330       } else {
331         name = Slice(benchmarks, sep - benchmarks);
332         benchmarks = sep + 1;
333       }
334 
335       Start();
336 
337       bool known = true;
338       bool write_sync = false;
339       if (name == Slice("fillseq")) {
340         Write(write_sync, SEQUENTIAL, FRESH, num_, FLAGS_value_size, 1);
341         DBSynchronize(db_);
342       } else if (name == Slice("fillrandom")) {
343         Write(write_sync, RANDOM, FRESH, num_, FLAGS_value_size, 1);
344         DBSynchronize(db_);
345       } else if (name == Slice("overwrite")) {
346         Write(write_sync, RANDOM, EXISTING, num_, FLAGS_value_size, 1);
347         DBSynchronize(db_);
348       } else if (name == Slice("fillrandsync")) {
349         write_sync = true;
350         Write(write_sync, RANDOM, FRESH, num_ / 100, FLAGS_value_size, 1);
351         DBSynchronize(db_);
352       } else if (name == Slice("fillseqsync")) {
353         write_sync = true;
354         Write(write_sync, SEQUENTIAL, FRESH, num_ / 100, FLAGS_value_size, 1);
355         DBSynchronize(db_);
356       } else if (name == Slice("fillrand100K")) {
357         Write(write_sync, RANDOM, FRESH, num_ / 1000, 100 * 1000, 1);
358         DBSynchronize(db_);
359       } else if (name == Slice("fillseq100K")) {
360         Write(write_sync, SEQUENTIAL, FRESH, num_ / 1000, 100 * 1000, 1);
361         DBSynchronize(db_);
362       } else if (name == Slice("readseq")) {
363         ReadSequential();
364       } else if (name == Slice("readrandom")) {
365         ReadRandom();
366       } else if (name == Slice("readrand100K")) {
367         int n = reads_;
368         reads_ /= 1000;
369         ReadRandom();
370         reads_ = n;
371       } else if (name == Slice("readseq100K")) {
372         int n = reads_;
373         reads_ /= 1000;
374         ReadSequential();
375         reads_ = n;
376       } else {
377         known = false;
378         if (name != Slice()) {  // No error message for empty name
379           fprintf(stderr, "unknown benchmark '%s'\n", name.ToString().c_str());
380         }
381       }
382       if (known) {
383         Stop(name);
384       }
385     }
386   }
387 
388  private:
Open(bool sync)389     void Open(bool sync) {
390     assert(db_ == NULL);
391 
392     // Initialize db_
393     db_ = new kyotocabinet::TreeDB();
394     char file_name[100];
395     db_num_++;
396     std::string test_dir;
397     Env::Default()->GetTestDirectory(&test_dir);
398     snprintf(file_name, sizeof(file_name),
399              "%s/dbbench_polyDB-%d.kct",
400              test_dir.c_str(),
401              db_num_);
402 
403     // Create tuning options and open the database
404     int open_options = kyotocabinet::PolyDB::OWRITER |
405                        kyotocabinet::PolyDB::OCREATE;
406     int tune_options = kyotocabinet::TreeDB::TSMALL |
407         kyotocabinet::TreeDB::TLINEAR;
408     if (FLAGS_compression) {
409       tune_options |= kyotocabinet::TreeDB::TCOMPRESS;
410       db_->tune_compressor(&comp_);
411     }
412     db_->tune_options(tune_options);
413     db_->tune_page_cache(FLAGS_cache_size);
414     db_->tune_page(FLAGS_page_size);
415     db_->tune_map(256LL<<20);
416     if (sync) {
417       open_options |= kyotocabinet::PolyDB::OAUTOSYNC;
418     }
419     if (!db_->open(file_name, open_options)) {
420       fprintf(stderr, "open error: %s\n", db_->error().name());
421     }
422   }
423 
Write(bool sync,Order order,DBState state,int num_entries,int value_size,int entries_per_batch)424   void Write(bool sync, Order order, DBState state,
425              int num_entries, int value_size, int entries_per_batch) {
426     // Create new database if state == FRESH
427     if (state == FRESH) {
428       if (FLAGS_use_existing_db) {
429         message_ = "skipping (--use_existing_db is true)";
430         return;
431       }
432       delete db_;
433       db_ = NULL;
434       Open(sync);
435       Start();  // Do not count time taken to destroy/open
436     }
437 
438     if (num_entries != num_) {
439       char msg[100];
440       snprintf(msg, sizeof(msg), "(%d ops)", num_entries);
441       message_ = msg;
442     }
443 
444     // Write to database
445     for (int i = 0; i < num_entries; i++)
446     {
447       const int k = (order == SEQUENTIAL) ? i : (rand_.Next() % num_entries);
448       char key[100];
449       snprintf(key, sizeof(key), "%016d", k);
450       bytes_ += value_size + strlen(key);
451       std::string cpp_key = key;
452       if (!db_->set(cpp_key, gen_.Generate(value_size).ToString())) {
453         fprintf(stderr, "set error: %s\n", db_->error().name());
454       }
455       FinishedSingleOp();
456     }
457   }
458 
ReadSequential()459   void ReadSequential() {
460     kyotocabinet::DB::Cursor* cur = db_->cursor();
461     cur->jump();
462     std::string ckey, cvalue;
463     while (cur->get(&ckey, &cvalue, true)) {
464       bytes_ += ckey.size() + cvalue.size();
465       FinishedSingleOp();
466     }
467     delete cur;
468   }
469 
ReadRandom()470   void ReadRandom() {
471     std::string value;
472     for (int i = 0; i < reads_; i++) {
473       char key[100];
474       const int k = rand_.Next() % reads_;
475       snprintf(key, sizeof(key), "%016d", k);
476       db_->get(key, &value);
477       FinishedSingleOp();
478     }
479   }
480 };
481 
482 }  // namespace leveldb
483 
main(int argc,char ** argv)484 int main(int argc, char** argv) {
485   std::string default_db_path;
486   for (int i = 1; i < argc; i++) {
487     double d;
488     int n;
489     char junk;
490     if (leveldb::Slice(argv[i]).starts_with("--benchmarks=")) {
491       FLAGS_benchmarks = argv[i] + strlen("--benchmarks=");
492     } else if (sscanf(argv[i], "--compression_ratio=%lf%c", &d, &junk) == 1) {
493       FLAGS_compression_ratio = d;
494     } else if (sscanf(argv[i], "--histogram=%d%c", &n, &junk) == 1 &&
495                (n == 0 || n == 1)) {
496       FLAGS_histogram = n;
497     } else if (sscanf(argv[i], "--num=%d%c", &n, &junk) == 1) {
498       FLAGS_num = n;
499     } else if (sscanf(argv[i], "--reads=%d%c", &n, &junk) == 1) {
500       FLAGS_reads = n;
501     } else if (sscanf(argv[i], "--value_size=%d%c", &n, &junk) == 1) {
502       FLAGS_value_size = n;
503     } else if (sscanf(argv[i], "--cache_size=%d%c", &n, &junk) == 1) {
504       FLAGS_cache_size = n;
505     } else if (sscanf(argv[i], "--page_size=%d%c", &n, &junk) == 1) {
506       FLAGS_page_size = n;
507     } else if (sscanf(argv[i], "--compression=%d%c", &n, &junk) == 1 &&
508                (n == 0 || n == 1)) {
509       FLAGS_compression = (n == 1) ? true : false;
510     } else if (strncmp(argv[i], "--db=", 5) == 0) {
511       FLAGS_db = argv[i] + 5;
512     } else {
513       fprintf(stderr, "Invalid flag '%s'\n", argv[i]);
514       exit(1);
515     }
516   }
517 
518   // Choose a location for the test database if none given with --db=<path>
519   if (FLAGS_db == NULL) {
520       leveldb::Env::Default()->GetTestDirectory(&default_db_path);
521       default_db_path += "/dbbench";
522       FLAGS_db = default_db_path.c_str();
523   }
524 
525   leveldb::Benchmark benchmark;
526   benchmark.Run();
527   return 0;
528 }
529