From 945d2b59b97385b902f881599e5cea49152c7031 Mon Sep 17 00:00:00 2001 From: Vamsi Ponnekanti Date: Tue, 19 Feb 2013 17:51:06 -0800 Subject: [PATCH] [Add randomwithverify benchmark option] Summary: Added RandomWithVerify benchmark option. Test Plan: This whole diff is to test. [nponnekanti@dev902 /data/users/nponnekanti/rocksdb] ./db_bench --benchmarks=randomwithverify LevelDB: version 1.5 Date: Tue Feb 19 17:50:28 2013 CPU: 24 * Intel(R) Xeon(R) CPU X5650 @ 2.67GHz CPUCache: 12288 KB Keys: 16 bytes each Values: 100 bytes each (50 bytes after compression) Entries: 1000000 RawSize: 110.6 MB (estimated) FileSize: 62.9 MB (estimated) Compression: snappy WARNING: Assertions are enabled; benchmarks unnecessarily slow ------------------------------------------------ Created bg thread 0x7fa9c3fff700 randomwithverify : 5.004 micros/op 199836 ops/sec; ( get:900000 put:80000 del:20000 total:1000000 found:711992) Revert Plan: OK Task ID: # Reviewers: dhruba, emayanke Reviewed By: dhruba CC: leveldb Differential Revision: https://reviews.facebook.net/D8685 --- db/db_bench.cc | 170 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 168 insertions(+), 2 deletions(-) diff --git a/db/db_bench.cc b/db/db_bench.cc index f2361fb36..7ddab12e2 100644 --- a/db/db_bench.cc +++ b/db/db_bench.cc @@ -58,6 +58,7 @@ static const char* FLAGS_benchmarks = "readseq," "readreverse," "readrandomwriterandom," // mix reads and writes based on FLAGS_readwritepercent + "randomwithverify," // random reads and writes with some verification "fill100K," "crc32c," "snappycomp," @@ -68,6 +69,11 @@ static const char* FLAGS_benchmarks = // Number of key/values to place in database static long FLAGS_num = 1000000; +// Number of distinct keys to use. Used in RandomWithVerify to read/write +// on fewer keys so that gets are more likely to find the key and puts +// are more likely to update the same key +static long FLAGS_numdistinct = 1000; + // Number of read operations to do. If negative, do FLAGS_num reads. static long FLAGS_reads = -1; @@ -184,6 +190,10 @@ static int FLAGS_level0_file_num_compaction_trigger = 4; // setting is 9 gets for every 1 put. static int FLAGS_readwritepercent = 90; +// This percent of deletes are done (used in RandomWithVerify only) +// Must be smaller than total writepercent (i.e 100 - FLAGS_readwritepercent) +static int FLAGS_deletepercent = 2; + // Option to disable compation triggered by read. static int FLAGS_disable_seek_compaction = false; @@ -749,6 +759,8 @@ class Benchmark { method = &Benchmark::ReadWhileWriting; } else if (name == Slice("readrandomwriterandom")) { method = &Benchmark::ReadRandomWriteRandom; + } else if (name == Slice("randomwithverify")) { + method = &Benchmark::RandomWithVerify; } else if (name == Slice("compact")) { method = &Benchmark::Compact; } else if (name == Slice("crc32c")) { @@ -1218,6 +1230,151 @@ class Benchmark { } } + // Given a key K and value V, this puts (K+"0", V), (K+"1", V), (K+"2", V) + // in DB atomically i.e in a single batch. Also refer MultiGet. + Status MultiPut(const WriteOptions& writeoptions, + const Slice& key, const Slice& value) { + std::string suffixes[3] = {"2", "1", "0"}; + std::string keys[3]; + + WriteBatch batch; + Status s; + for (int i = 0; i < 3; i++) { + keys[i] = key.ToString() + suffixes[i]; + batch.Put(keys[i], value); + } + + s = db_->Write(writeoptions, &batch); + return s; + } + + + // Given a key K, this deletes (K+"0", V), (K+"1", V), (K+"2", V) + // in DB atomically i.e in a single batch. Also refer MultiGet. + Status MultiDelete(const WriteOptions& writeoptions, + const Slice& key) { + std::string suffixes[3] = {"1", "2", "0"}; + std::string keys[3]; + + WriteBatch batch; + Status s; + for (int i = 0; i < 3; i++) { + keys[i] = key.ToString() + suffixes[i]; + batch.Delete(keys[i]); + } + + s = db_->Write(writeoptions, &batch); + return s; + } + + // Given a key K and value V, this gets values for K+"0", K+"1" and K+"2" + // in the same snapshot, and verifies that all the values are identical. + // ASSUMES that MultiPut was used to put (K, V) into the DB. + Status MultiGet(const ReadOptions& readoptions, + const Slice& key, std::string* value) { + std::string suffixes[3] = {"0", "1", "2"}; + std::string keys[3]; + Slice key_slices[3]; + std::string values[3]; + ReadOptions readoptionscopy = readoptions; + readoptionscopy.snapshot = db_->GetSnapshot(); + Status s; + for (int i = 0; i < 3; i++) { + keys[i] = key.ToString() + suffixes[i]; + key_slices[i] = keys[i]; + s = db_->Get(readoptionscopy, key_slices[i], value); + if (!s.ok() && !s.IsNotFound()) { + fprintf(stderr, "get error: %s\n", s.ToString().c_str()); + values[i] = ""; + // we continue after error rather than exiting so that we can + // find more errors if any + } else if (s.IsNotFound()) { + values[i] = ""; + } else { + values[i] = *value; + } + } + db_->ReleaseSnapshot(readoptionscopy.snapshot); + + if ((values[0] != values[1]) || (values[1] != values[2])) { + fprintf(stderr, "inconsistent values for key %s: %s, %s, %s\n", + key.ToString().c_str(), values[0].c_str(), values[1].c_str(), + values[2].c_str()); + // we continue after error rather than exiting so that we can + // find more errors if any + } + + return s; + } + + // Differs from readrandomwriterandom in the following ways: + // (a) Uses MultiGet/MultiPut to read/write key values. Refer to those funcs. + // (b) Does deletes as well (per FLAGS_deletepercent) + // (c) In order to achieve high % of 'found' during lookups, and to do + // multiple writes (including puts and deletes) it uses upto + // FLAGS_numdistinct distinct keys instead of FLAGS_num distinct keys. + void RandomWithVerify(ThreadState* thread) { + ReadOptions options(FLAGS_verify_checksum, true); + RandomGenerator gen; + std::string value; + long found = 0; + int get_weight = 0; + int put_weight = 0; + int delete_weight = 0; + long gets_done = 0; + long puts_done = 0; + long deletes_done = 0; + // the number of iterations is the larger of read_ or write_ + for (long i = 0; i < readwrites_; i++) { + char key[100]; + const int k = thread->rand.Next() % (FLAGS_numdistinct); + snprintf(key, sizeof(key), "%016d", k); + if (get_weight == 0 && put_weight == 0 && delete_weight == 0) { + // one batch complated, reinitialize for next batch + get_weight = FLAGS_readwritepercent; + delete_weight = FLAGS_deletepercent; + put_weight = 100 - get_weight - delete_weight; + } + if (get_weight > 0) { + // do all the gets first + Status s = MultiGet(options, key, &value); + if (!s.ok() && !s.IsNotFound()) { + fprintf(stderr, "get error: %s\n", s.ToString().c_str()); + // we continue after error rather than exiting so that we can + // find more errors if any + } else if (!s.IsNotFound()) { + found++; + } + get_weight--; + gets_done++; + } else if (put_weight > 0) { + // then do all the corresponding number of puts + // for all the gets we have done earlier + Status s = MultiPut(write_options_, key, gen.Generate(value_size_)); + if (!s.ok()) { + fprintf(stderr, "multiput error: %s\n", s.ToString().c_str()); + exit(1); + } + put_weight--; + puts_done++; + } else if (delete_weight > 0) { + Status s = MultiDelete(write_options_, key); + if (!s.ok()) { + fprintf(stderr, "multidelete error: %s\n", s.ToString().c_str()); + exit(1); + } + delete_weight--; + deletes_done++; + } + + thread->stats.FinishedSingleOp(db_); + } + char msg[100]; + snprintf(msg, sizeof(msg), "( get:%ld put:%ld del:%ld total:%ld found:%ld)", + gets_done, puts_done, deletes_done, readwrites_, found); + thread->stats.AddMessage(msg); + } + // // This is diffferent from ReadWhileWriting because it does not use // an extra thread. @@ -1243,6 +1400,15 @@ class Benchmark { } if (get_weight > 0) { // do all the gets first + Status s = db_->Get(options, key, &value); + if (!s.ok() && !s.IsNotFound()) { + fprintf(stderr, "get error: %s\n", s.ToString().c_str()); + // we continue after error rather than exiting so that we can + // find more errors if any + } else if (!s.IsNotFound()) { + found++; + } + if (db_->Get(options, key, &value).ok()) { found++; } @@ -1262,8 +1428,8 @@ class Benchmark { thread->stats.FinishedSingleOp(db_); } char msg[100]; - snprintf(msg, sizeof(msg), "( reads:%ld writes:%ld total:%ld )", - reads_done, writes_done, readwrites_); + snprintf(msg, sizeof(msg), "( reads:%ld writes:%ld total:%ld found:%ld)", + reads_done, writes_done, readwrites_, found); thread->stats.AddMessage(msg); } -- GitLab