db_test.cc 465.4 KB
Newer Older
1 2 3 4 5
//  Copyright (c) 2013, Facebook, Inc.  All rights reserved.
//  This source code is licensed under the BSD-style license found in the
//  LICENSE file in the root directory of this source tree. An additional grant
//  of patent rights can be found in the PATENTS file in the same directory.
//
J
jorlow@chromium.org 已提交
6 7 8 9
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.

D
Dmitri Smirnov 已提交
10 11 12 13
// Introduction of SyncPoint effectively disabled building and running this test in Release build.
// which is a pity, it is a good test
#if !(defined NDEBUG) || !defined (OS_WIN)

14
#include <algorithm>
15
#include <iostream>
16
#include <set>
D
Dmitri Smirnov 已提交
17 18 19
#ifndef OS_WIN
#  include <unistd.h>
#endif
20
#include <thread>
21
#include <unordered_set>
S
Stanislau Hlebik 已提交
22
#include <utility>
K
krad 已提交
23
#include <fcntl.h>
24

25
#include "db/filename.h"
26
#include "db/dbformat.h"
J
jorlow@chromium.org 已提交
27 28
#include "db/db_impl.h"
#include "db/filename.h"
I
Igor Canadi 已提交
29
#include "db/job_context.h"
J
jorlow@chromium.org 已提交
30 31
#include "db/version_set.h"
#include "db/write_batch_internal.h"
I
Igor Canadi 已提交
32
#include "port/stack_trace.h"
33 34
#include "rocksdb/cache.h"
#include "rocksdb/compaction_filter.h"
K
Kai Liu 已提交
35
#include "rocksdb/db.h"
36
#include "rocksdb/env.h"
37
#include "rocksdb/experimental.h"
K
Kai Liu 已提交
38
#include "rocksdb/filter_policy.h"
39
#include "rocksdb/perf_context.h"
40 41
#include "rocksdb/slice.h"
#include "rocksdb/slice_transform.h"
S
Siying Dong 已提交
42
#include "rocksdb/table.h"
L
Lei Jin 已提交
43
#include "rocksdb/options.h"
44
#include "rocksdb/table_properties.h"
Y
Yueh-Hsuan Chiang 已提交
45
#include "rocksdb/thread_status.h"
46
#include "rocksdb/utilities/write_batch_with_index.h"
47
#include "rocksdb/utilities/checkpoint.h"
48
#include "rocksdb/utilities/convenience.h"
A
agiardullo 已提交
49
#include "rocksdb/utilities/optimistic_transaction_db.h"
K
kailiu 已提交
50
#include "table/block_based_table_factory.h"
51
#include "table/mock_table.h"
52
#include "table/plain_table_factory.h"
S
Sanjay Ghemawat 已提交
53
#include "util/hash.h"
K
Kai Liu 已提交
54
#include "util/hash_linklist_rep.h"
55
#include "utilities/merge_operators.h"
J
jorlow@chromium.org 已提交
56
#include "util/logging.h"
I
Igor Canadi 已提交
57
#include "util/compression.h"
58
#include "util/mutexlock.h"
L
Lei Jin 已提交
59
#include "util/rate_limiter.h"
K
Kai Liu 已提交
60
#include "util/statistics.h"
J
jorlow@chromium.org 已提交
61
#include "util/testharness.h"
62
#include "util/scoped_arena_iterator.h"
63
#include "util/sync_point.h"
J
jorlow@chromium.org 已提交
64
#include "util/testutil.h"
65
#include "util/mock_env.h"
66
#include "util/string_util.h"
67
#include "util/thread_status_util.h"
68
#include "util/xfunc.h"
J
jorlow@chromium.org 已提交
69

70
namespace rocksdb {
J
jorlow@chromium.org 已提交
71

I
Igor Canadi 已提交
72
static std::string RandomString(Random* rnd, int len) {
J
jorlow@chromium.org 已提交
73 74 75 76 77
  std::string r;
  test::RandomString(rnd, len, &r);
  return r;
}

78
namespace anon {
S
Sanjay Ghemawat 已提交
79 80
class AtomicCounter {
 private:
K
krad 已提交
81
  Env* env_;
S
Sanjay Ghemawat 已提交
82
  port::Mutex mu_;
K
krad 已提交
83
  port::CondVar cond_count_;
S
Sanjay Ghemawat 已提交
84 85
  int count_;
 public:
K
krad 已提交
86
  AtomicCounter(Env* env = NULL) : env_(env), cond_count_(&mu_), count_(0) {}
S
Sanjay Ghemawat 已提交
87 88 89
  void Increment() {
    MutexLock l(&mu_);
    count_++;
K
krad 已提交
90
    cond_count_.SignalAll();
S
Sanjay Ghemawat 已提交
91 92 93 94 95
  }
  int Read() {
    MutexLock l(&mu_);
    return count_;
  }
K
krad 已提交
96 97 98 99 100 101
  bool WaitFor(int count) {
    MutexLock l(&mu_);

    uint64_t start = env_->NowMicros();
    while (count_ < count) {
      uint64_t now = env_->NowMicros();
K
krad 已提交
102 103
      const uint64_t elapsed_micros = (now > start) ? now - start : 0;
      if (elapsed_micros > /*10s*/ 10 * 000 * 000) {
K
krad 已提交
104 105
        return false;
      }
K
krad 已提交
106
      cond_count_.TimedWait(now + /*1s*/ 1 * 000 * 000);
K
krad 已提交
107 108 109
      if (count_ < count) {
        GTEST_LOG_(WARNING) << "WaitFor is taking more time than usual";
      }
K
krad 已提交
110 111 112 113
    }

    return true;
  }
S
Sanjay Ghemawat 已提交
114 115 116
  void Reset() {
    MutexLock l(&mu_);
    count_ = 0;
K
krad 已提交
117
    cond_count_.SignalAll();
S
Sanjay Ghemawat 已提交
118 119
  }
};
120 121 122

struct OptionsOverride {
  std::shared_ptr<const FilterPolicy> filter_policy = nullptr;
123 124 125

  // Used as a bit mask of individual enums in which to skip an XF test point
  int skip_policy = 0;
126 127
};

128
}  // namespace anon
129

130 131 132 133
static std::string Key(int i) {
  char buf[100];
  snprintf(buf, sizeof(buf), "key%06d", i);
  return std::string(buf);
S
Sanjay Ghemawat 已提交
134 135
}

136 137 138
// Special Env used to delay background operations
class SpecialEnv : public EnvWrapper {
 public:
139
  Random rnd_;
S
sdong 已提交
140
  port::Mutex rnd_mutex_;  // Lock to pretect rnd_
141

A
Abhishek Kona 已提交
142
  // sstable Sync() calls are blocked while this pointer is non-nullptr.
I
Igor Canadi 已提交
143
  std::atomic<bool> delay_sstable_sync_;
144

145
  // Drop writes on the floor while this pointer is non-nullptr.
I
Igor Canadi 已提交
146
  std::atomic<bool> drop_writes_;
147

A
Abhishek Kona 已提交
148
  // Simulate no-space errors while this pointer is non-nullptr.
I
Igor Canadi 已提交
149
  std::atomic<bool> no_space_;
150

A
Abhishek Kona 已提交
151
  // Simulate non-writable file system while this pointer is non-nullptr
I
Igor Canadi 已提交
152
  std::atomic<bool> non_writable_;
153

A
Abhishek Kona 已提交
154
  // Force sync of manifest files to fail while this pointer is non-nullptr
I
Igor Canadi 已提交
155
  std::atomic<bool> manifest_sync_error_;
156

A
Abhishek Kona 已提交
157
  // Force write to manifest files to fail while this pointer is non-nullptr
I
Igor Canadi 已提交
158
  std::atomic<bool> manifest_write_error_;
159

I
Igor Canadi 已提交
160
  // Force write to log files to fail while this pointer is non-nullptr
I
Igor Canadi 已提交
161
  std::atomic<bool> log_write_error_;
I
Igor Canadi 已提交
162

163 164 165
  // Slow down every log write, in micro-seconds.
  std::atomic<int> log_write_slowdown_;

S
Sanjay Ghemawat 已提交
166
  bool count_random_reads_;
167
  anon::AtomicCounter random_read_counter_;
S
Sanjay Ghemawat 已提交
168

I
Igor Canadi 已提交
169 170 171
  bool count_sequential_reads_;
  anon::AtomicCounter sequential_read_counter_;

172
  anon::AtomicCounter sleep_counter_;
173

L
Lei Jin 已提交
174 175
  std::atomic<int64_t> bytes_written_;

176 177
  std::atomic<int> sync_counter_;

178 179 180 181
  std::atomic<uint32_t> non_writeable_rate_;

  std::atomic<uint32_t> new_writable_count_;

182
  std::atomic<uint32_t> non_writable_count_;
183

I
Igor Canadi 已提交
184 185
  std::function<void()>* table_write_callback_;

S
sdong 已提交
186 187
  std::atomic<int64_t> addon_time_;
  bool no_sleep_;
188

S
sdong 已提交
189
  explicit SpecialEnv(Env* base)
K
krad 已提交
190 191 192 193 194
      : EnvWrapper(base),
        rnd_(301),
        sleep_counter_(this),
        addon_time_(0),
        no_sleep_(false) {
I
Igor Canadi 已提交
195 196 197 198
    delay_sstable_sync_.store(false, std::memory_order_release);
    drop_writes_.store(false, std::memory_order_release);
    no_space_.store(false, std::memory_order_release);
    non_writable_.store(false, std::memory_order_release);
S
Sanjay Ghemawat 已提交
199
    count_random_reads_ = false;
I
Igor Canadi 已提交
200
    count_sequential_reads_ = false;
I
Igor Canadi 已提交
201 202 203
    manifest_sync_error_.store(false, std::memory_order_release);
    manifest_write_error_.store(false, std::memory_order_release);
    log_write_error_.store(false, std::memory_order_release);
204
    log_write_slowdown_ = 0;
L
Lei Jin 已提交
205
    bytes_written_ = 0;
206
    sync_counter_ = 0;
207 208
    non_writeable_rate_ = 0;
    new_writable_count_ = 0;
209
    non_writable_count_ = 0;
I
Igor Canadi 已提交
210
    table_write_callback_ = nullptr;
L
Lei Jin 已提交
211
  }
212

213
  Status NewWritableFile(const std::string& f, unique_ptr<WritableFile>* r,
I
Igor Sugak 已提交
214
                         const EnvOptions& soptions) override {
215 216 217
    class SSTableFile : public WritableFile {
     private:
      SpecialEnv* env_;
218
      unique_ptr<WritableFile> base_;
219 220

     public:
221
      SSTableFile(SpecialEnv* env, unique_ptr<WritableFile>&& base)
222
          : env_(env),
223
            base_(std::move(base)) {
224
      }
I
Igor Sugak 已提交
225
      Status Append(const Slice& data) override {
I
Igor Canadi 已提交
226 227 228
        if (env_->table_write_callback_) {
          (*env_->table_write_callback_)();
        }
I
Igor Canadi 已提交
229
        if (env_->drop_writes_.load(std::memory_order_acquire)) {
230 231
          // Drop writes on the floor
          return Status::OK();
I
Igor Canadi 已提交
232
        } else if (env_->no_space_.load(std::memory_order_acquire)) {
233
          return Status::IOError("No space left on device");
234
        } else {
L
Lei Jin 已提交
235
          env_->bytes_written_ += data.size();
236 237 238
          return base_->Append(data);
        }
      }
239 240 241 242 243 244 245 246
      Status Close() override {
        // Check preallocation size
        // preallocation size is never passed to base file.
        size_t preallocation_size = preallocation_block_size();
        TEST_SYNC_POINT_CALLBACK("DBTestWritableFile.GetPreallocationStatus",
                                 &preallocation_size);
        return base_->Close();
      }
I
Igor Sugak 已提交
247 248
      Status Flush() override { return base_->Flush(); }
      Status Sync() override {
249
        ++env_->sync_counter_;
I
Igor Canadi 已提交
250
        while (env_->delay_sstable_sync_.load(std::memory_order_acquire)) {
251 252 253 254
          env_->SleepForMicroseconds(100000);
        }
        return base_->Sync();
      }
I
Igor Sugak 已提交
255
      void SetIOPriority(Env::IOPriority pri) override {
L
Lei Jin 已提交
256 257
        base_->SetIOPriority(pri);
      }
258
    };
259 260 261
    class ManifestFile : public WritableFile {
     private:
      SpecialEnv* env_;
262
      unique_ptr<WritableFile> base_;
263
     public:
264 265
      ManifestFile(SpecialEnv* env, unique_ptr<WritableFile>&& b)
          : env_(env), base_(std::move(b)) { }
I
Igor Sugak 已提交
266
      Status Append(const Slice& data) override {
I
Igor Canadi 已提交
267
        if (env_->manifest_write_error_.load(std::memory_order_acquire)) {
268 269 270 271 272
          return Status::IOError("simulated writer error");
        } else {
          return base_->Append(data);
        }
      }
I
Igor Sugak 已提交
273 274 275
      Status Close() override { return base_->Close(); }
      Status Flush() override { return base_->Flush(); }
      Status Sync() override {
276
        ++env_->sync_counter_;
I
Igor Canadi 已提交
277
        if (env_->manifest_sync_error_.load(std::memory_order_acquire)) {
278 279 280 281 282
          return Status::IOError("simulated sync error");
        } else {
          return base_->Sync();
        }
      }
I
Igor Sugak 已提交
283
      uint64_t GetFileSize() override { return base_->GetFileSize(); }
284
    };
I
Igor Canadi 已提交
285
    class WalFile : public WritableFile {
I
Igor Canadi 已提交
286 287 288 289
     private:
      SpecialEnv* env_;
      unique_ptr<WritableFile> base_;
     public:
I
Igor Canadi 已提交
290 291
      WalFile(SpecialEnv* env, unique_ptr<WritableFile>&& b)
          : env_(env), base_(std::move(b)) {}
I
Igor Sugak 已提交
292
      Status Append(const Slice& data) override {
I
Igor Canadi 已提交
293
        if (env_->log_write_error_.load(std::memory_order_acquire)) {
I
Igor Canadi 已提交
294 295
          return Status::IOError("simulated writer error");
        } else {
296 297 298 299 300
          int slowdown =
              env_->log_write_slowdown_.load(std::memory_order_acquire);
          if (slowdown > 0) {
            env_->SleepForMicroseconds(slowdown);
          }
I
Igor Canadi 已提交
301 302 303
          return base_->Append(data);
        }
      }
I
Igor Sugak 已提交
304 305 306
      Status Close() override { return base_->Close(); }
      Status Flush() override { return base_->Flush(); }
      Status Sync() override {
307 308 309
        ++env_->sync_counter_;
        return base_->Sync();
      }
I
Igor Canadi 已提交
310
    };
311

312
    if (non_writeable_rate_.load(std::memory_order_acquire) > 0) {
S
sdong 已提交
313 314 315 316 317
      uint32_t random_number;
      {
        MutexLock l(&rnd_mutex_);
        random_number = rnd_.Uniform(100);
      }
318 319 320 321 322 323 324
      if (random_number < non_writeable_rate_.load()) {
        return Status::IOError("simulated random write error");
      }
    }

    new_writable_count_++;

325 326 327
    if (non_writable_count_.load() > 0) {
      non_writable_count_--;
      return Status::IOError("simulated write error");
328
    }
329

330
    Status s = target()->NewWritableFile(f, r, soptions);
331
    if (s.ok()) {
A
Abhishek Kona 已提交
332
      if (strstr(f.c_str(), ".sst") != nullptr) {
333
        r->reset(new SSTableFile(this, std::move(*r)));
A
Abhishek Kona 已提交
334
      } else if (strstr(f.c_str(), "MANIFEST") != nullptr) {
335
        r->reset(new ManifestFile(this, std::move(*r)));
I
Igor Canadi 已提交
336
      } else if (strstr(f.c_str(), "log") != nullptr) {
I
Igor Canadi 已提交
337
        r->reset(new WalFile(this, std::move(*r)));
338 339 340 341
      }
    }
    return s;
  }
S
Sanjay Ghemawat 已提交
342

343
  Status NewRandomAccessFile(const std::string& f,
344
                             unique_ptr<RandomAccessFile>* r,
I
Igor Sugak 已提交
345
                             const EnvOptions& soptions) override {
S
Sanjay Ghemawat 已提交
346 347
    class CountingFile : public RandomAccessFile {
     private:
348
      unique_ptr<RandomAccessFile> target_;
349
      anon::AtomicCounter* counter_;
S
Sanjay Ghemawat 已提交
350
     public:
351 352 353
      CountingFile(unique_ptr<RandomAccessFile>&& target,
                   anon::AtomicCounter* counter)
          : target_(std::move(target)), counter_(counter) {
S
Sanjay Ghemawat 已提交
354 355
      }
      virtual Status Read(uint64_t offset, size_t n, Slice* result,
I
Igor Sugak 已提交
356
                          char* scratch) const override {
S
Sanjay Ghemawat 已提交
357 358 359 360 361
        counter_->Increment();
        return target_->Read(offset, n, result, scratch);
      }
    };

362
    Status s = target()->NewRandomAccessFile(f, r, soptions);
S
Sanjay Ghemawat 已提交
363
    if (s.ok() && count_random_reads_) {
364
      r->reset(new CountingFile(std::move(*r), &random_read_counter_));
S
Sanjay Ghemawat 已提交
365 366 367
    }
    return s;
  }
368

I
Igor Canadi 已提交
369
  Status NewSequentialFile(const std::string& f, unique_ptr<SequentialFile>* r,
I
Igor Sugak 已提交
370
                           const EnvOptions& soptions) override {
I
Igor Canadi 已提交
371 372 373 374 375 376 377 378 379
    class CountingFile : public SequentialFile {
     private:
      unique_ptr<SequentialFile> target_;
      anon::AtomicCounter* counter_;

     public:
      CountingFile(unique_ptr<SequentialFile>&& target,
                   anon::AtomicCounter* counter)
          : target_(std::move(target)), counter_(counter) {}
I
Igor Sugak 已提交
380
      virtual Status Read(size_t n, Slice* result, char* scratch) override {
I
Igor Canadi 已提交
381 382 383
        counter_->Increment();
        return target_->Read(n, result, scratch);
      }
I
Igor Sugak 已提交
384
      virtual Status Skip(uint64_t n) override { return target_->Skip(n); }
I
Igor Canadi 已提交
385 386 387 388 389 390 391 392 393
    };

    Status s = target()->NewSequentialFile(f, r, soptions);
    if (s.ok() && count_sequential_reads_) {
      r->reset(new CountingFile(std::move(*r), &sequential_read_counter_));
    }
    return s;
  }

I
Igor Sugak 已提交
394
  virtual void SleepForMicroseconds(int micros) override {
395
    sleep_counter_.Increment();
S
sdong 已提交
396 397 398 399 400
    if (no_sleep_) {
      addon_time_.fetch_add(micros);
    } else {
      target()->SleepForMicroseconds(micros);
    }
401
  }
402 403 404 405

  virtual Status GetCurrentTime(int64_t* unix_time) override {
    Status s = target()->GetCurrentTime(unix_time);
    if (s.ok()) {
S
sdong 已提交
406
      *unix_time += addon_time_.load();
407 408 409
    }
    return s;
  }
410 411

  virtual uint64_t NowNanos() override {
S
sdong 已提交
412 413 414 415 416
    return target()->NowNanos() + addon_time_.load() * 1000;
  }

  virtual uint64_t NowMicros() override {
    return target()->NowMicros() + addon_time_.load();
417
  }
418 419
};

I
Igor Sugak 已提交
420
class DBTest : public testing::Test {
J
Jim Paton 已提交
421
 protected:
S
Sanjay Ghemawat 已提交
422 423
  // Sequence of option configurations to try
  enum OptionConfig {
S
Stanislau Hlebik 已提交
424 425 426 427
    kDefault = 0,
    kBlockBasedTableWithPrefixHashIndex = 1,
    kBlockBasedTableWithWholeKeyHashIndex = 2,
    kPlainTableFirstBytePrefix = 3,
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
    kPlainTableCappedPrefix = 4,
    kPlainTableAllBytesPrefix = 5,
    kVectorRep = 6,
    kHashLinkList = 7,
    kHashCuckoo = 8,
    kMergePut = 9,
    kFilter = 10,
    kFullFilter = 11,
    kUncompressed = 12,
    kNumLevel_3 = 13,
    kDBLogDir = 14,
    kWalDirAndMmapReads = 15,
    kManifestFileSize = 16,
    kCompactOnFlush = 17,
    kPerfOptions = 18,
    kDeletesFilterFirst = 19,
    kHashSkipList = 20,
    kUniversalCompaction = 21,
S
sdong 已提交
446 447 448 449 450 451
    kUniversalCompactionMultiLevel = 22,
    kCompressedBlockCache = 23,
    kInfiniteMaxOpenFiles = 24,
    kxxHashChecksum = 25,
    kFIFOCompaction = 26,
    kOptimizeFiltersForHits = 27,
452 453
    kRowCache = 28,
    kEnd = 29
S
Sanjay Ghemawat 已提交
454 455 456
  };
  int option_config_;

J
jorlow@chromium.org 已提交
457 458
 public:
  std::string dbname_;
459
  std::string alternative_wal_dir_;
460
  MockEnv* mem_env_;
461
  SpecialEnv* env_;
J
jorlow@chromium.org 已提交
462
  DB* db_;
463
  std::vector<ColumnFamilyHandle*> handles_;
J
jorlow@chromium.org 已提交
464 465 466

  Options last_options_;

467 468 469 470 471
  // Skip some options, as they may not be applicable to a specific test.
  // To add more skip constants, use values 4, 8, 16, etc.
  enum OptionSkip {
    kNoSkip = 0,
    kSkipDeletesFilterFirst = 1,
472
    kSkipUniversalCompaction = 2,
473
    kSkipMergePut = 4,
474
    kSkipPlainTable = 8,
475
    kSkipHashIndex = 16,
476
    kSkipNoSeekToLast = 32,
I
Igor Canadi 已提交
477 478
    kSkipHashCuckoo = 64,
    kSkipFIFOCompaction = 128,
I
Igor Canadi 已提交
479
    kSkipMmapReads = 256,
480 481
  };

482

S
Sanjay Ghemawat 已提交
483
  DBTest() : option_config_(kDefault),
484 485 486
             mem_env_(!getenv("MEM_ENV") ? nullptr :
                                           new MockEnv(Env::Default())),
             env_(new SpecialEnv(mem_env_ ? mem_env_ : Env::Default())) {
487 488
    env_->SetBackgroundThreads(1, Env::LOW);
    env_->SetBackgroundThreads(1, Env::HIGH);
489
    dbname_ = test::TmpDir(env_) + "/db_test";
490
    alternative_wal_dir_ = dbname_ + "/wal";
491
    auto options = CurrentOptions();
492 493 494 495
    auto delete_options = options;
    delete_options.wal_dir = alternative_wal_dir_;
    EXPECT_OK(DestroyDB(dbname_, delete_options));
    // Destroy it for not alternative WAL dir is used.
496
    EXPECT_OK(DestroyDB(dbname_, options));
A
Abhishek Kona 已提交
497
    db_ = nullptr;
L
Lei Jin 已提交
498
    Reopen(options);
J
jorlow@chromium.org 已提交
499 500 501
  }

  ~DBTest() {
502 503 504
    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
    rocksdb::SyncPoint::GetInstance()->LoadDependency({});
    rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
505
    Close();
506
    Options options;
507 508 509 510
    options.db_paths.emplace_back(dbname_, 0);
    options.db_paths.emplace_back(dbname_ + "_2", 0);
    options.db_paths.emplace_back(dbname_ + "_3", 0);
    options.db_paths.emplace_back(dbname_ + "_4", 0);
511
    EXPECT_OK(DestroyDB(dbname_, options));
512
    delete env_;
S
Sanjay Ghemawat 已提交
513 514 515 516
  }

  // Switch to a fresh database with the next option configuration to
  // test.  Return false if there are no more configurations to test.
517
  bool ChangeOptions(int skip_mask = kNoSkip) {
518 519 520 521 522 523
    for(option_config_++; option_config_ < kEnd; option_config_++) {
      if ((skip_mask & kSkipDeletesFilterFirst) &&
          option_config_ == kDeletesFilterFirst) {
        continue;
      }
      if ((skip_mask & kSkipUniversalCompaction) &&
S
sdong 已提交
524 525
          (option_config_ == kUniversalCompaction ||
           option_config_ == kUniversalCompactionMultiLevel)) {
526 527 528 529 530
        continue;
      }
      if ((skip_mask & kSkipMergePut) && option_config_ == kMergePut) {
        continue;
      }
531 532 533 534 535
      if ((skip_mask & kSkipNoSeekToLast) &&
          (option_config_ == kHashLinkList ||
           option_config_ == kHashSkipList)) {;
        continue;
      }
536 537 538 539
      if ((skip_mask & kSkipPlainTable) &&
          (option_config_ == kPlainTableAllBytesPrefix ||
           option_config_ == kPlainTableFirstBytePrefix ||
           option_config_ == kPlainTableCappedPrefix)) {
540 541
        continue;
      }
S
Stanislau Hlebik 已提交
542
      if ((skip_mask & kSkipHashIndex) &&
543 544 545 546
          (option_config_ == kBlockBasedTableWithPrefixHashIndex ||
           option_config_ == kBlockBasedTableWithWholeKeyHashIndex)) {
        continue;
      }
547 548 549
      if ((skip_mask & kSkipHashCuckoo) && (option_config_ == kHashCuckoo)) {
        continue;
      }
I
Igor Canadi 已提交
550 551 552 553
      if ((skip_mask & kSkipFIFOCompaction) &&
          option_config_ == kFIFOCompaction) {
        continue;
      }
I
Igor Canadi 已提交
554 555 556 557
      if ((skip_mask & kSkipMmapReads) &&
          option_config_ == kWalDirAndMmapReads) {
        continue;
      }
558
      break;
559
    }
560

H
heyongqiang 已提交
561
    if (option_config_ >= kEnd) {
L
Lei Jin 已提交
562
      Destroy(last_options_);
S
Sanjay Ghemawat 已提交
563 564
      return false;
    } else {
L
Lei Jin 已提交
565 566 567
      auto options = CurrentOptions();
      options.create_if_missing = true;
      DestroyAndReopen(options);
S
Sanjay Ghemawat 已提交
568 569 570 571
      return true;
    }
  }

572
  // Switch between different compaction styles (we have only 2 now).
573
  bool ChangeCompactOptions() {
574 575
    if (option_config_ == kDefault) {
      option_config_ = kUniversalCompaction;
576
      Destroy(last_options_);
L
Lei Jin 已提交
577 578
      auto options = CurrentOptions();
      options.create_if_missing = true;
L
Lei Jin 已提交
579
      TryReopen(options);
580
      return true;
S
sdong 已提交
581 582 583 584 585 586 587
    } else if (option_config_ == kUniversalCompaction) {
      option_config_ = kUniversalCompactionMultiLevel;
      Destroy(last_options_);
      auto options = CurrentOptions();
      options.create_if_missing = true;
      TryReopen(options);
      return true;
588 589 590 591 592
    } else {
      return false;
    }
  }

593 594
  // Switch between different filter policy
  // Jump from kDefault to kFilter to kFullFilter
595
  bool ChangeFilterOptions() {
596 597 598 599 600 601 602
    if (option_config_ == kDefault) {
      option_config_ = kFilter;
    } else if (option_config_ == kFilter) {
      option_config_ = kFullFilter;
    } else {
      return false;
    }
603
    Destroy(last_options_);
L
Lei Jin 已提交
604 605 606

    auto options = CurrentOptions();
    options.create_if_missing = true;
L
Lei Jin 已提交
607
    TryReopen(options);
L
Lei Jin 已提交
608
    return true;
609 610
  }

S
Sanjay Ghemawat 已提交
611
  // Return the current option configuration.
612 613
  Options CurrentOptions(
      const anon::OptionsOverride& options_override = anon::OptionsOverride()) {
S
Sanjay Ghemawat 已提交
614
    Options options;
615
    return CurrentOptions(options, options_override);
616 617
  }

618 619 620
  Options CurrentOptions(
      const Options& defaultOptions,
      const anon::OptionsOverride& options_override = anon::OptionsOverride()) {
621 622
    // this redudant copy is to minimize code change w/o having lint error.
    Options options = defaultOptions;
623 624 625
    XFUNC_TEST("", "dbtest_options", inplace_options1, GetXFTestOptions,
               reinterpret_cast<Options*>(&options),
               options_override.skip_policy);
626 627
    BlockBasedTableOptions table_options;
    bool set_block_based_table_factory = true;
S
Sanjay Ghemawat 已提交
628
    switch (option_config_) {
I
Igor Canadi 已提交
629
      case kHashSkipList:
630
        options.prefix_extractor.reset(NewFixedPrefixTransform(1));
631 632
        options.memtable_factory.reset(
            NewHashSkipListRepFactory(16));
J
Jim Paton 已提交
633
        break;
634 635
      case kPlainTableFirstBytePrefix:
        options.table_factory.reset(new PlainTableFactory());
636
        options.prefix_extractor.reset(NewFixedPrefixTransform(1));
637 638
        options.allow_mmap_reads = true;
        options.max_sequential_skip_in_iterations = 999999;
639
        set_block_based_table_factory = false;
640 641 642 643 644 645 646
        break;
      case kPlainTableCappedPrefix:
        options.table_factory.reset(new PlainTableFactory());
        options.prefix_extractor.reset(NewCappedPrefixTransform(8));
        options.allow_mmap_reads = true;
        options.max_sequential_skip_in_iterations = 999999;
        set_block_based_table_factory = false;
647 648 649
        break;
      case kPlainTableAllBytesPrefix:
        options.table_factory.reset(new PlainTableFactory());
650
        options.prefix_extractor.reset(NewNoopTransform());
651 652
        options.allow_mmap_reads = true;
        options.max_sequential_skip_in_iterations = 999999;
653
        set_block_based_table_factory = false;
654
        break;
655
      case kMergePut:
656
        options.merge_operator = MergeOperators::CreatePutOperator();
657
        break;
S
Sanjay Ghemawat 已提交
658
      case kFilter:
659 660 661 662
        table_options.filter_policy.reset(NewBloomFilterPolicy(10, true));
        break;
      case kFullFilter:
        table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
S
Sanjay Ghemawat 已提交
663
        break;
H
heyongqiang 已提交
664
      case kUncompressed:
H
heyongqiang 已提交
665 666
        options.compression = kNoCompression;
        break;
667
      case kNumLevel_3:
H
heyongqiang 已提交
668 669 670
        options.num_levels = 3;
        break;
      case kDBLogDir:
671
        options.db_log_dir = test::TmpDir(env_);
H
heyongqiang 已提交
672
        break;
I
Igor Canadi 已提交
673
      case kWalDirAndMmapReads:
674
        options.wal_dir = alternative_wal_dir_;
I
Igor Canadi 已提交
675 676 677
        // mmap reads should be orthogonal to WalDir setting, so we piggyback to
        // this option config to test mmap reads as well
        options.allow_mmap_reads = true;
678
        break;
A
Abhishek Kona 已提交
679 680
      case kManifestFileSize:
        options.max_manifest_file_size = 50; // 50 bytes
681
      case kCompactOnFlush:
N
Naman Gupta 已提交
682 683
        options.purge_redundant_kvs_while_flush =
          !options.purge_redundant_kvs_while_flush;
684 685
        break;
      case kPerfOptions:
S
sdong 已提交
686 687
        options.soft_rate_limit = 2.0;
        options.delayed_write_rate = 8 * 1024 * 1024;
688 689
        // TODO -- test more options
        break;
690
      case kDeletesFilterFirst:
691
        options.filter_deletes = true;
692
        break;
J
Jim Paton 已提交
693
      case kVectorRep:
694
        options.memtable_factory.reset(new VectorRepFactory(100));
J
Jim Paton 已提交
695
        break;
696
      case kHashLinkList:
697
        options.prefix_extractor.reset(NewFixedPrefixTransform(1));
698 699
        options.memtable_factory.reset(
            NewHashLinkListRepFactory(4, 0, 3, true, 4));
700
        break;
701 702 703 704
      case kHashCuckoo:
        options.memtable_factory.reset(
            NewHashCuckooRepFactory(options.write_buffer_size));
        break;
705 706
      case kUniversalCompaction:
        options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
707 708 709 710 711
        options.num_levels = 1;
        break;
      case kUniversalCompactionMultiLevel:
        options.compaction_style = kCompactionStyleUniversal;
        options.num_levels = 8;
712
        break;
713
      case kCompressedBlockCache:
S
sdong 已提交
714
        options.allow_mmap_writes = true;
715
        table_options.block_cache_compressed = NewLRUCache(8*1024*1024);
716
        break;
717 718 719
      case kInfiniteMaxOpenFiles:
        options.max_open_files = -1;
        break;
I
xxHash  
Igor Canadi 已提交
720 721 722 723
      case kxxHashChecksum: {
        table_options.checksum = kxxHash;
        break;
      }
I
Igor Canadi 已提交
724 725 726 727
      case kFIFOCompaction: {
        options.compaction_style = kCompactionStyleFIFO;
        break;
      }
728 729 730 731 732 733 734 735 736 737
      case kBlockBasedTableWithPrefixHashIndex: {
        table_options.index_type = BlockBasedTableOptions::kHashSearch;
        options.prefix_extractor.reset(NewFixedPrefixTransform(1));
        break;
      }
      case kBlockBasedTableWithWholeKeyHashIndex: {
        table_options.index_type = BlockBasedTableOptions::kHashSearch;
        options.prefix_extractor.reset(NewNoopTransform());
        break;
      }
738 739 740 741 742
      case kOptimizeFiltersForHits: {
        options.optimize_filters_for_hits = true;
        set_block_based_table_factory = true;
        break;
      }
743 744 745 746
      case kRowCache: {
        options.row_cache = NewLRUCache(1024 * 1024);
        break;
      }
747

S
Sanjay Ghemawat 已提交
748 749 750
      default:
        break;
    }
751 752 753 754 755 756 757

    if (options_override.filter_policy) {
      table_options.filter_policy = options_override.filter_policy;
    }
    if (set_block_based_table_factory) {
      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
    }
758 759
    options.env = env_;
    options.create_if_missing = true;
S
Sanjay Ghemawat 已提交
760
    return options;
J
jorlow@chromium.org 已提交
761 762 763 764 765 766
  }

  DBImpl* dbfull() {
    return reinterpret_cast<DBImpl*>(db_);
  }

767
  void CreateColumnFamilies(const std::vector<std::string>& cfs,
L
Lei Jin 已提交
768 769
                            const Options& options) {
    ColumnFamilyOptions cf_opts(options);
770
    size_t cfi = handles_.size();
771 772 773 774 775 776 777
    handles_.resize(cfi + cfs.size());
    for (auto cf : cfs) {
      ASSERT_OK(db_->CreateColumnFamily(cf_opts, cf, &handles_[cfi++]));
    }
  }

  void CreateAndReopenWithCF(const std::vector<std::string>& cfs,
L
Lei Jin 已提交
778
                             const Options& options) {
779 780
    CreateColumnFamilies(cfs, options);
    std::vector<std::string> cfs_plus_default = cfs;
781
    cfs_plus_default.insert(cfs_plus_default.begin(), kDefaultColumnFamilyName);
L
Lei Jin 已提交
782
    ReopenWithColumnFamilies(cfs_plus_default, options);
783 784
  }

785
  void ReopenWithColumnFamilies(const std::vector<std::string>& cfs,
L
Lei Jin 已提交
786
                                const std::vector<Options>& options) {
787 788 789
    ASSERT_OK(TryReopenWithColumnFamilies(cfs, options));
  }

790
  void ReopenWithColumnFamilies(const std::vector<std::string>& cfs,
L
Lei Jin 已提交
791
                                const Options& options) {
792 793 794 795 796
    ASSERT_OK(TryReopenWithColumnFamilies(cfs, options));
  }

  Status TryReopenWithColumnFamilies(
      const std::vector<std::string>& cfs,
L
Lei Jin 已提交
797
      const std::vector<Options>& options) {
798
    Close();
799
    EXPECT_EQ(cfs.size(), options.size());
800 801
    std::vector<ColumnFamilyDescriptor> column_families;
    for (size_t i = 0; i < cfs.size(); ++i) {
L
Lei Jin 已提交
802
      column_families.push_back(ColumnFamilyDescriptor(cfs[i], options[i]));
803
    }
L
Lei Jin 已提交
804
    DBOptions db_opts = DBOptions(options[0]);
805 806 807 808
    return DB::Open(db_opts, dbname_, column_families, &handles_, &db_);
  }

  Status TryReopenWithColumnFamilies(const std::vector<std::string>& cfs,
L
Lei Jin 已提交
809
                                     const Options& options) {
810
    Close();
L
Lei Jin 已提交
811
    std::vector<Options> v_opts(cfs.size(), options);
812 813 814
    return TryReopenWithColumnFamilies(cfs, v_opts);
  }

L
Lei Jin 已提交
815
  void Reopen(const Options& options) {
L
Lei Jin 已提交
816
    ASSERT_OK(TryReopen(options));
J
jorlow@chromium.org 已提交
817 818
  }

S
Sanjay Ghemawat 已提交
819
  void Close() {
820 821 822 823
    for (auto h : handles_) {
      delete h;
    }
    handles_.clear();
S
Sanjay Ghemawat 已提交
824
    delete db_;
A
Abhishek Kona 已提交
825
    db_ = nullptr;
S
Sanjay Ghemawat 已提交
826 827
  }

L
Lei Jin 已提交
828
  void DestroyAndReopen(const Options& options) {
N
Naman Gupta 已提交
829
    //Destroy using last options
L
Lei Jin 已提交
830
    Destroy(last_options_);
L
Lei Jin 已提交
831
    ASSERT_OK(TryReopen(options));
N
Naman Gupta 已提交
832 833
  }

L
Lei Jin 已提交
834
  void Destroy(const Options& options) {
835
    Close();
L
Lei Jin 已提交
836
    ASSERT_OK(DestroyDB(dbname_, options));
J
jorlow@chromium.org 已提交
837 838
  }

839 840
  Status ReadOnlyReopen(const Options& options) {
    return DB::OpenForReadOnly(options, dbname_, &db_);
841 842
  }

L
Lei Jin 已提交
843
  Status TryReopen(const Options& options) {
844
    Close();
L
Lei Jin 已提交
845 846
    last_options_ = options;
    return DB::Open(options, dbname_, &db_);
J
jorlow@chromium.org 已提交
847 848
  }

849 850 851 852 853 854 855 856
  Status Flush(int cf = 0) {
    if (cf == 0) {
      return db_->Flush(FlushOptions());
    } else {
      return db_->Flush(FlushOptions(), handles_[cf]);
    }
  }

857
  Status Put(const Slice& k, const Slice& v, WriteOptions wo = WriteOptions()) {
858
    if (kMergePut == option_config_ ) {
859
      return db_->Merge(wo, k, v);
860
    } else {
861
      return db_->Put(wo, k, v);
862
    }
J
jorlow@chromium.org 已提交
863 864
  }

865 866 867 868 869 870 871 872 873
  Status Put(int cf, const Slice& k, const Slice& v,
             WriteOptions wo = WriteOptions()) {
    if (kMergePut == option_config_) {
      return db_->Merge(wo, handles_[cf], k, v);
    } else {
      return db_->Put(wo, handles_[cf], k, v);
    }
  }

J
jorlow@chromium.org 已提交
874
  Status Delete(const std::string& k) {
875
    return db_->Delete(WriteOptions(), k);
J
jorlow@chromium.org 已提交
876 877
  }

878 879 880 881
  Status Delete(int cf, const std::string& k) {
    return db_->Delete(WriteOptions(), handles_[cf], k);
  }

A
Abhishek Kona 已提交
882
  std::string Get(const std::string& k, const Snapshot* snapshot = nullptr) {
J
jorlow@chromium.org 已提交
883
    ReadOptions options;
884
    options.verify_checksums = true;
J
jorlow@chromium.org 已提交
885 886 887 888 889 890 891 892 893 894 895
    options.snapshot = snapshot;
    std::string result;
    Status s = db_->Get(options, k, &result);
    if (s.IsNotFound()) {
      result = "NOT_FOUND";
    } else if (!s.ok()) {
      result = s.ToString();
    }
    return result;
  }

896 897 898 899 900 901 902 903 904 905 906 907 908 909 910
  std::string Get(int cf, const std::string& k,
                  const Snapshot* snapshot = nullptr) {
    ReadOptions options;
    options.verify_checksums = true;
    options.snapshot = snapshot;
    std::string result;
    Status s = db_->Get(options, handles_[cf], k, &result);
    if (s.IsNotFound()) {
      result = "NOT_FOUND";
    } else if (!s.ok()) {
      result = s.ToString();
    }
    return result;
  }

911 912
  uint64_t GetNumSnapshots() {
    uint64_t int_num;
913
    EXPECT_TRUE(dbfull()->GetIntProperty("rocksdb.num-snapshots", &int_num));
914 915 916 917 918
    return int_num;
  }

  uint64_t GetTimeOldestSnapshots() {
    uint64_t int_num;
919
    EXPECT_TRUE(
920 921 922 923
        dbfull()->GetIntProperty("rocksdb.oldest-snapshot-time", &int_num));
    return int_num;
  }

H
Hans Wennborg 已提交
924 925
  // Return a string that contains all key,value pairs in order,
  // formatted like "(k1->v1)(k2->v2)".
926
  std::string Contents(int cf = 0) {
H
Hans Wennborg 已提交
927 928
    std::vector<std::string> forward;
    std::string result;
929 930
    Iterator* iter = (cf == 0) ? db_->NewIterator(ReadOptions())
                               : db_->NewIterator(ReadOptions(), handles_[cf]);
H
Hans Wennborg 已提交
931 932 933 934 935 936 937 938 939
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      std::string s = IterStatus(iter);
      result.push_back('(');
      result.append(s);
      result.push_back(')');
      forward.push_back(s);
    }

    // Check reverse iteration results are the reverse of forward results
940
    unsigned int matched = 0;
H
Hans Wennborg 已提交
941
    for (iter->SeekToLast(); iter->Valid(); iter->Prev()) {
942 943
      EXPECT_LT(matched, forward.size());
      EXPECT_EQ(IterStatus(iter), forward[forward.size() - matched - 1]);
H
Hans Wennborg 已提交
944 945
      matched++;
    }
946
    EXPECT_EQ(matched, forward.size());
H
Hans Wennborg 已提交
947 948 949 950 951

    delete iter;
    return result;
  }

952
  std::string AllEntriesFor(const Slice& user_key, int cf = 0) {
953
    Arena arena;
954
    ScopedArenaIterator iter;
955
    if (cf == 0) {
956
      iter.set(dbfull()->TEST_NewInternalIterator(&arena));
957
    } else {
958
      iter.set(dbfull()->TEST_NewInternalIterator(&arena, handles_[cf]));
959
    }
J
jorlow@chromium.org 已提交
960 961 962 963 964 965 966 967 968
    InternalKey target(user_key, kMaxSequenceNumber, kTypeValue);
    iter->Seek(target.Encode());
    std::string result;
    if (!iter->status().ok()) {
      result = iter->status().ToString();
    } else {
      result = "[ ";
      bool first = true;
      while (iter->Valid()) {
I
Igor Canadi 已提交
969
        ParsedInternalKey ikey(Slice(), 0, kTypeValue);
J
jorlow@chromium.org 已提交
970 971 972
        if (!ParseInternalKey(iter->key(), &ikey)) {
          result += "CORRUPTED";
        } else {
S
Sanjay Ghemawat 已提交
973
          if (last_options_.comparator->Compare(ikey.user_key, user_key) != 0) {
J
jorlow@chromium.org 已提交
974 975 976 977 978 979 980 981 982 983
            break;
          }
          if (!first) {
            result += ", ";
          }
          first = false;
          switch (ikey.type) {
            case kTypeValue:
              result += iter->value().ToString();
              break;
984 985 986 987
            case kTypeMerge:
              // keep it the same as kTypeValue for testing kMergePut
              result += iter->value().ToString();
              break;
J
jorlow@chromium.org 已提交
988 989 990
            case kTypeDeletion:
              result += "DEL";
              break;
991
            default:
J
Jim Paton 已提交
992 993
              assert(false);
              break;
J
jorlow@chromium.org 已提交
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
          }
        }
        iter->Next();
      }
      if (!first) {
        result += " ";
      }
      result += "]";
    }
    return result;
  }

S
sdong 已提交
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
  int NumSortedRuns(int cf = 0) {
    ColumnFamilyMetaData cf_meta;
    if (cf == 0) {
      db_->GetColumnFamilyMetaData(&cf_meta);
    } else {
      db_->GetColumnFamilyMetaData(handles_[cf], &cf_meta);
    }
    int num_sr = static_cast<int>(cf_meta.levels[0].files.size());
    for (size_t i = 1U; i < cf_meta.levels.size(); i++) {
      if (cf_meta.levels[i].files.size() > 0) {
        num_sr++;
      }
    }
    return num_sr;
  }

  uint64_t TotalSize(int cf = 0) {
    ColumnFamilyMetaData cf_meta;
    if (cf == 0) {
      db_->GetColumnFamilyMetaData(&cf_meta);
    } else {
      db_->GetColumnFamilyMetaData(handles_[cf], &cf_meta);
    }
    return cf_meta.size;
  }

1032
  int NumTableFilesAtLevel(int level, int cf = 0) {
1033
    std::string property;
1034 1035
    if (cf == 0) {
      // default cfd
1036
      EXPECT_TRUE(db_->GetProperty(
1037 1038
          "rocksdb.num-files-at-level" + NumberToString(level), &property));
    } else {
1039
      EXPECT_TRUE(db_->GetProperty(
1040 1041 1042
          handles_[cf], "rocksdb.num-files-at-level" + NumberToString(level),
          &property));
    }
1043
    return atoi(property.c_str());
J
jorlow@chromium.org 已提交
1044 1045
  }

1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
  uint64_t SizeAtLevel(int level) {
    std::vector<LiveFileMetaData> metadata;
    db_->GetLiveFilesMetaData(&metadata);
    uint64_t sum = 0;
    for (const auto& m : metadata) {
      if (m.level == level) {
        sum += m.size;
      }
    }
    return sum;
  }

S
sdong 已提交
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
  int TotalLiveFiles(int cf = 0) {
    ColumnFamilyMetaData cf_meta;
    if (cf == 0) {
      db_->GetColumnFamilyMetaData(&cf_meta);
    } else {
      db_->GetColumnFamilyMetaData(handles_[cf], &cf_meta);
    }
    int num_files = 0;
    for (auto& level : cf_meta.levels) {
      num_files += level.files.size();
    }
    return num_files;
  }

1072 1073 1074 1075
  int TotalTableFiles(int cf = 0, int levels = -1) {
    if (levels == -1) {
      levels = CurrentOptions().num_levels;
    }
1076
    int result = 0;
1077 1078
    for (int level = 0; level < levels; level++) {
      result += NumTableFilesAtLevel(level, cf);
1079 1080 1081 1082
    }
    return result;
  }

G
Gabor Cselle 已提交
1083
  // Return spread of files per level
1084 1085 1086
  std::string FilesPerLevel(int cf = 0) {
    int num_levels =
        (cf == 0) ? db_->NumberLevels() : db_->NumberLevels(handles_[1]);
G
Gabor Cselle 已提交
1087
    std::string result;
1088
    size_t last_non_zero_offset = 0;
1089 1090
    for (int level = 0; level < num_levels; level++) {
      int f = NumTableFilesAtLevel(level, cf);
G
Gabor Cselle 已提交
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
      char buf[100];
      snprintf(buf, sizeof(buf), "%s%d", (level ? "," : ""), f);
      result += buf;
      if (f > 0) {
        last_non_zero_offset = result.size();
      }
    }
    result.resize(last_non_zero_offset);
    return result;
  }

1102
  size_t CountFiles() {
1103 1104
    std::vector<std::string> files;
    env_->GetChildren(dbname_, &files);
1105 1106 1107 1108 1109 1110

    std::vector<std::string> logfiles;
    if (dbname_ != last_options_.wal_dir) {
      env_->GetChildren(last_options_.wal_dir, &logfiles);
    }

1111
    return files.size() + logfiles.size();
1112 1113
  }

1114
  size_t CountLiveFiles() {
1115 1116 1117
    std::vector<LiveFileMetaData> metadata;
    db_->GetLiveFilesMetaData(&metadata);
    return metadata.size();
1118 1119
  }

1120
  uint64_t Size(const Slice& start, const Slice& limit, int cf = 0) {
J
jorlow@chromium.org 已提交
1121 1122
    Range r(start, limit);
    uint64_t size;
1123 1124 1125 1126 1127
    if (cf == 0) {
      db_->GetApproximateSizes(&r, 1, &size);
    } else {
      db_->GetApproximateSizes(handles_[1], &r, 1, &size);
    }
J
jorlow@chromium.org 已提交
1128 1129 1130
    return size;
  }

1131 1132
  void Compact(int cf, const Slice& start, const Slice& limit,
               uint32_t target_path_id) {
1133 1134 1135
    CompactRangeOptions compact_options;
    compact_options.target_path_id = target_path_id;
    ASSERT_OK(db_->CompactRange(compact_options, handles_[cf], &start, &limit));
1136 1137
  }

1138
  void Compact(int cf, const Slice& start, const Slice& limit) {
1139 1140
    ASSERT_OK(
        db_->CompactRange(CompactRangeOptions(), handles_[cf], &start, &limit));
1141 1142
  }

1143
  void Compact(const Slice& start, const Slice& limit) {
1144
    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, &limit));
G
Gabor Cselle 已提交
1145 1146 1147 1148
  }

  // Do n memtable compactions, each of which produces an sstable
  // covering the range [small,large].
1149 1150
  void MakeTables(int n, const std::string& small, const std::string& large,
                  int cf = 0) {
G
Gabor Cselle 已提交
1151
    for (int i = 0; i < n; i++) {
1152 1153 1154
      ASSERT_OK(Put(cf, small, "begin"));
      ASSERT_OK(Put(cf, large, "end"));
      ASSERT_OK(Flush(cf));
1155 1156 1157
    }
  }

1158 1159
  // Prevent pushing of new sstables into deeper levels by adding
  // tables that cover a specified range to all levels.
1160 1161 1162
  void FillLevels(const std::string& smallest, const std::string& largest,
                  int cf) {
    MakeTables(db_->NumberLevels(handles_[cf]), smallest, largest, cf);
1163 1164
  }

1165 1166 1167 1168 1169
  void DumpFileCounts(const char* label) {
    fprintf(stderr, "---\n%s:\n", label);
    fprintf(stderr, "maxoverlap: %lld\n",
            static_cast<long long>(
                dbfull()->TEST_MaxNextLevelOverlappingBytes()));
1170
    for (int level = 0; level < db_->NumberLevels(); level++) {
1171 1172 1173 1174 1175 1176
      int num = NumTableFilesAtLevel(level);
      if (num > 0) {
        fprintf(stderr, "  level %3d : %d files\n", level, num);
      }
    }
  }
J
jorlow@chromium.org 已提交
1177

G
Gabor Cselle 已提交
1178 1179
  std::string DumpSSTableList() {
    std::string property;
1180
    db_->GetProperty("rocksdb.sstables", &property);
G
Gabor Cselle 已提交
1181 1182 1183
    return property;
  }

1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
  int GetSstFileCount(std::string path) {
    std::vector<std::string> files;
    env_->GetChildren(path, &files);

    int sst_count = 0;
    uint64_t number;
    FileType type;
    for (size_t i = 0; i < files.size(); i++) {
      if (ParseFileName(files[i], &number, &type) && type == kTableFile) {
        sst_count++;
      }
    }
    return sst_count;
  }

1199
  // this will generate non-overlapping files since it keeps increasing key_idx
1200
  void GenerateNewFile(Random* rnd, int* key_idx, bool nowait = false) {
1201 1202 1203 1204
    for (int i = 0; i < 11; i++) {
      ASSERT_OK(Put(Key(*key_idx), RandomString(rnd, (i == 10) ? 1 : 10000)));
      (*key_idx)++;
    }
1205 1206 1207 1208
    if (!nowait) {
      dbfull()->TEST_WaitForFlushMemTable();
      dbfull()->TEST_WaitForCompact();
    }
1209 1210
  }

1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
  void GenerateNewRandomFile(Random* rnd, bool nowait = false) {
    for (int i = 0; i < 100; i++) {
      ASSERT_OK(Put("key" + RandomString(rnd, 7), RandomString(rnd, 1000)));
    }
    ASSERT_OK(Put("key" + RandomString(rnd, 7), RandomString(rnd, 1)));
    if (!nowait) {
      dbfull()->TEST_WaitForFlushMemTable();
      dbfull()->TEST_WaitForCompact();
    }
  }

J
jorlow@chromium.org 已提交
1222 1223 1224 1225 1226 1227 1228 1229 1230
  std::string IterStatus(Iterator* iter) {
    std::string result;
    if (iter->Valid()) {
      result = iter->key().ToString() + "->" + iter->value().ToString();
    } else {
      result = "(invalid)";
    }
    return result;
  }
1231 1232 1233 1234 1235 1236 1237 1238 1239

  Options OptionsForLogIterTest() {
    Options options = CurrentOptions();
    options.create_if_missing = true;
    options.WAL_ttl_seconds = 1000;
    return options;
  }

  std::unique_ptr<TransactionLogIterator> OpenTransactionLogIter(
1240
      const SequenceNumber seq) {
1241 1242
    unique_ptr<TransactionLogIterator> iter;
    Status status = dbfull()->GetUpdatesSince(seq, &iter);
1243 1244
    EXPECT_OK(status);
    EXPECT_TRUE(iter->Valid());
1245 1246 1247 1248 1249 1250
    return std::move(iter);
  }

  std::string DummyString(size_t len, char c = 'a') {
    return std::string(len, c);
  }
1251

1252 1253
  void VerifyIterLast(std::string expected_key, int cf = 0) {
    Iterator* iter;
1254
    ReadOptions ro;
1255
    if (cf == 0) {
1256
      iter = db_->NewIterator(ro);
1257
    } else {
1258
      iter = db_->NewIterator(ro, handles_[cf]);
1259
    }
1260 1261 1262 1263
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), expected_key);
    delete iter;
  }
I
Igor Canadi 已提交
1264

1265 1266 1267 1268 1269
  // Used to test InplaceUpdate

  // If previous value is nullptr or delta is > than previous value,
  //   sets newValue with delta
  // If previous value is not empty,
1270 1271 1272 1273 1274
  //   updates previous value with 'b' string of previous value size - 1.
  static UpdateStatus
      updateInPlaceSmallerSize(char* prevValue, uint32_t* prevSize,
                               Slice delta, std::string* newValue) {
    if (prevValue == nullptr) {
1275
      *newValue = std::string(delta.size(), 'c');
1276
      return UpdateStatus::UPDATED;
1277
    } else {
1278 1279
      *prevSize = *prevSize - 1;
      std::string str_b = std::string(*prevSize, 'b');
1280
      memcpy(prevValue, str_b.c_str(), str_b.size());
1281
      return UpdateStatus::UPDATED_INPLACE;
1282 1283 1284
    }
  }

1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
  static UpdateStatus
      updateInPlaceSmallerVarintSize(char* prevValue, uint32_t* prevSize,
                                     Slice delta, std::string* newValue) {
    if (prevValue == nullptr) {
      *newValue = std::string(delta.size(), 'c');
      return UpdateStatus::UPDATED;
    } else {
      *prevSize = 1;
      std::string str_b = std::string(*prevSize, 'b');
      memcpy(prevValue, str_b.c_str(), str_b.size());
      return UpdateStatus::UPDATED_INPLACE;
    }
  }

  static UpdateStatus
      updateInPlaceLargerSize(char* prevValue, uint32_t* prevSize,
                              Slice delta, std::string* newValue) {
    *newValue = std::string(delta.size(), 'c');
    return UpdateStatus::UPDATED;
  }

  static UpdateStatus
      updateInPlaceNoAction(char* prevValue, uint32_t* prevSize,
                            Slice delta, std::string* newValue) {
    return UpdateStatus::UPDATE_FAILED;
  }

  // Utility method to test InplaceUpdate
1313
  void validateNumberOfEntries(int numValues, int cf = 0) {
1314 1315
    ScopedArenaIterator iter;
    Arena arena;
1316
    if (cf != 0) {
1317
      iter.set(dbfull()->TEST_NewInternalIterator(&arena, handles_[cf]));
1318
    } else {
1319
      iter.set(dbfull()->TEST_NewInternalIterator(&arena));
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
    }
    iter->SeekToFirst();
    ASSERT_EQ(iter->status().ok(), true);
    int seq = numValues;
    while (iter->Valid()) {
      ParsedInternalKey ikey;
      ikey.sequence = -1;
      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);

      // checks sequence number for updates
      ASSERT_EQ(ikey.sequence, (unsigned)seq--);
      iter->Next();
    }
    ASSERT_EQ(0, seq);
1334
  }
K
Kai Liu 已提交
1335

I
Igor Canadi 已提交
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
  void CopyFile(const std::string& source, const std::string& destination,
                uint64_t size = 0) {
    const EnvOptions soptions;
    unique_ptr<SequentialFile> srcfile;
    ASSERT_OK(env_->NewSequentialFile(source, &srcfile, soptions));
    unique_ptr<WritableFile> destfile;
    ASSERT_OK(env_->NewWritableFile(destination, &destfile, soptions));

    if (size == 0) {
      // default argument means copy everything
      ASSERT_OK(env_->GetFileSize(source, &size));
    }

    char buffer[4096];
    Slice slice;
    while (size > 0) {
      uint64_t one = std::min(uint64_t(sizeof(buffer)), size);
      ASSERT_OK(srcfile->Read(one, &slice, buffer));
      ASSERT_OK(destfile->Append(slice));
      size -= slice.size();
    }
    ASSERT_OK(destfile->Close());
  }

J
jorlow@chromium.org 已提交
1360 1361
};

I
Igor Canadi 已提交
1362 1363 1364 1365
static long TestGetTickerCount(const Options& options, Tickers ticker_type) {
  return options.statistics->getTickerCount(ticker_type);
}

1366 1367
// A helper function that ensures the table properties returned in
// `GetPropertiesOfAllTablesTest` is correct.
C
clark.kang 已提交
1368
// This test assumes entries size is different for each of the tables.
I
Igor Canadi 已提交
1369
namespace {
1370 1371 1372 1373
void VerifyTableProperties(DB* db, uint64_t expected_entries_size) {
  TablePropertiesCollection props;
  ASSERT_OK(db->GetPropertiesOfAllTables(&props));

I
Igor Canadi 已提交
1374
  ASSERT_EQ(4U, props.size());
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
  std::unordered_set<uint64_t> unique_entries;

  // Indirect test
  uint64_t sum = 0;
  for (const auto& item : props) {
    unique_entries.insert(item.second->num_entries);
    sum += item.second->num_entries;
  }

  ASSERT_EQ(props.size(), unique_entries.size());
  ASSERT_EQ(expected_entries_size, sum);
}
I
Igor Canadi 已提交
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397

uint64_t GetNumberOfSstFilesForColumnFamily(DB* db,
                                            std::string column_family_name) {
  std::vector<LiveFileMetaData> metadata;
  db->GetLiveFilesMetaData(&metadata);
  uint64_t result = 0;
  for (auto& fileMetadata : metadata) {
    result += (fileMetadata.column_family_name == column_family_name);
  }
  return result;
}
I
Igor Canadi 已提交
1398
}  // namespace
1399

I
Igor Sugak 已提交
1400
TEST_F(DBTest, Empty) {
S
Sanjay Ghemawat 已提交
1401
  do {
1402
    Options options;
K
kailiu 已提交
1403 1404
    options.env = env_;
    options.write_buffer_size = 100000;  // Small write buffer
1405
    options = CurrentOptions(options);
L
Lei Jin 已提交
1406
    CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
1407

1408 1409 1410 1411 1412
    std::string num;
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ("0", num);

1413 1414
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_EQ("v1", Get(1, "foo"));
1415 1416 1417
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ("1", num);
K
kailiu 已提交
1418

I
Igor Canadi 已提交
1419 1420
    // Block sync calls
    env_->delay_sstable_sync_.store(true, std::memory_order_release);
1421
    Put(1, "k1", std::string(100000, 'x'));         // Fill memtable
1422 1423 1424 1425
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ("2", num);

1426
    Put(1, "k2", std::string(100000, 'y'));         // Trigger compaction
1427 1428 1429 1430
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ("1", num);

1431
    ASSERT_EQ("v1", Get(1, "foo"));
I
Igor Canadi 已提交
1432 1433
    // Release sync calls
    env_->delay_sstable_sync_.store(false, std::memory_order_release);
1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458

    ASSERT_OK(db_->DisableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("1", num);

    ASSERT_OK(db_->DisableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("2", num);

    ASSERT_OK(db_->DisableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("3", num);

    ASSERT_OK(db_->EnableFileDeletions(false));
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("2", num);

    ASSERT_OK(db_->EnableFileDeletions());
    ASSERT_TRUE(
        dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
    ASSERT_EQ("0", num);
S
Sanjay Ghemawat 已提交
1459
  } while (ChangeOptions());
J
jorlow@chromium.org 已提交
1460 1461
}

I
Igor Sugak 已提交
1462
TEST_F(DBTest, WriteEmptyBatch) {
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
  Options options;
  options.env = env_;
  options.write_buffer_size = 100000;
  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  ASSERT_OK(Put(1, "foo", "bar"));
  env_->sync_counter_.store(0);
  WriteOptions wo;
  wo.sync = true;
  wo.disableWAL = false;
  WriteBatch empty_batch;
  ASSERT_OK(dbfull()->Write(wo, &empty_batch));
  ASSERT_GE(env_->sync_counter_.load(), 1);

  // make sure we can re-open it.
  ASSERT_OK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
  ASSERT_EQ("bar", Get(1, "foo"));
}

I
Igor Sugak 已提交
1483
TEST_F(DBTest, ReadOnlyDB) {
1484 1485 1486 1487 1488
  ASSERT_OK(Put("foo", "v1"));
  ASSERT_OK(Put("bar", "v2"));
  ASSERT_OK(Put("foo", "v3"));
  Close();

1489 1490 1491
  auto options = CurrentOptions();
  assert(options.env = env_);
  ASSERT_OK(ReadOnlyReopen(options));
1492 1493 1494 1495 1496 1497 1498 1499 1500 1501
  ASSERT_EQ("v3", Get("foo"));
  ASSERT_EQ("v2", Get("bar"));
  Iterator* iter = db_->NewIterator(ReadOptions());
  int count = 0;
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    ASSERT_OK(iter->status());
    ++count;
  }
  ASSERT_EQ(count, 2);
  delete iter;
1502 1503 1504
  Close();

  // Reopen and flush memtable.
L
Lei Jin 已提交
1505
  Reopen(options);
1506 1507 1508
  Flush();
  Close();
  // Now check keys in read only mode.
1509
  ASSERT_OK(ReadOnlyReopen(options));
1510 1511
  ASSERT_EQ("v3", Get("foo"));
  ASSERT_EQ("v2", Get("bar"));
1512 1513
}

I
Igor Sugak 已提交
1514
TEST_F(DBTest, CompactedDB) {
L
Lei Jin 已提交
1515 1516 1517 1518 1519 1520 1521 1522
  const uint64_t kFileSize = 1 << 20;
  Options options;
  options.disable_auto_compactions = true;
  options.max_mem_compaction_level = 0;
  options.write_buffer_size = kFileSize;
  options.target_file_size_base = kFileSize;
  options.max_bytes_for_level_base = 1 << 30;
  options.compression = kNoCompression;
1523
  options = CurrentOptions(options);
L
Lei Jin 已提交
1524
  Reopen(options);
L
Lei Jin 已提交
1525 1526 1527 1528
  // 1 L0 file, use CompactedDB if max_open_files = -1
  ASSERT_OK(Put("aaa", DummyString(kFileSize / 2, '1')));
  Flush();
  Close();
1529
  ASSERT_OK(ReadOnlyReopen(options));
L
Lei Jin 已提交
1530 1531 1532 1533 1534 1535
  Status s = Put("new", "value");
  ASSERT_EQ(s.ToString(),
            "Not implemented: Not supported operation in read only mode.");
  ASSERT_EQ(DummyString(kFileSize / 2, '1'), Get("aaa"));
  Close();
  options.max_open_files = -1;
1536
  ASSERT_OK(ReadOnlyReopen(options));
L
Lei Jin 已提交
1537 1538 1539 1540 1541
  s = Put("new", "value");
  ASSERT_EQ(s.ToString(),
            "Not implemented: Not supported in compacted db mode.");
  ASSERT_EQ(DummyString(kFileSize / 2, '1'), Get("aaa"));
  Close();
L
Lei Jin 已提交
1542
  Reopen(options);
L
Lei Jin 已提交
1543 1544 1545 1546 1547 1548
  // Add more L0 files
  ASSERT_OK(Put("bbb", DummyString(kFileSize / 2, '2')));
  Flush();
  ASSERT_OK(Put("aaa", DummyString(kFileSize / 2, 'a')));
  Flush();
  ASSERT_OK(Put("bbb", DummyString(kFileSize / 2, 'b')));
1549
  ASSERT_OK(Put("eee", DummyString(kFileSize / 2, 'e')));
L
Lei Jin 已提交
1550 1551 1552
  Flush();
  Close();

1553
  ASSERT_OK(ReadOnlyReopen(options));
L
Lei Jin 已提交
1554 1555 1556 1557 1558 1559 1560
  // Fallback to read-only DB
  s = Put("new", "value");
  ASSERT_EQ(s.ToString(),
            "Not implemented: Not supported operation in read only mode.");
  Close();

  // Full compaction
L
Lei Jin 已提交
1561
  Reopen(options);
L
Lei Jin 已提交
1562 1563 1564 1565 1566
  // Add more keys
  ASSERT_OK(Put("fff", DummyString(kFileSize / 2, 'f')));
  ASSERT_OK(Put("hhh", DummyString(kFileSize / 2, 'h')));
  ASSERT_OK(Put("iii", DummyString(kFileSize / 2, 'i')));
  ASSERT_OK(Put("jjj", DummyString(kFileSize / 2, 'j')));
1567
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
1568 1569 1570 1571
  ASSERT_EQ(3, NumTableFilesAtLevel(1));
  Close();

  // CompactedDB
1572
  ASSERT_OK(ReadOnlyReopen(options));
L
Lei Jin 已提交
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
  s = Put("new", "value");
  ASSERT_EQ(s.ToString(),
            "Not implemented: Not supported in compacted db mode.");
  ASSERT_EQ("NOT_FOUND", Get("abc"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'a'), Get("aaa"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'b'), Get("bbb"));
  ASSERT_EQ("NOT_FOUND", Get("ccc"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'e'), Get("eee"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'f'), Get("fff"));
  ASSERT_EQ("NOT_FOUND", Get("ggg"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'h'), Get("hhh"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'i'), Get("iii"));
  ASSERT_EQ(DummyString(kFileSize / 2, 'j'), Get("jjj"));
  ASSERT_EQ("NOT_FOUND", Get("kkk"));
1587 1588 1589 1590 1591 1592 1593

  // MultiGet
  std::vector<std::string> values;
  std::vector<Status> status_list = dbfull()->MultiGet(ReadOptions(),
      std::vector<Slice>({Slice("aaa"), Slice("ccc"), Slice("eee"),
                          Slice("ggg"), Slice("iii"), Slice("kkk")}),
      &values);
1594 1595
  ASSERT_EQ(status_list.size(), static_cast<uint64_t>(6));
  ASSERT_EQ(values.size(), static_cast<uint64_t>(6));
1596 1597 1598 1599 1600 1601 1602 1603 1604
  ASSERT_OK(status_list[0]);
  ASSERT_EQ(DummyString(kFileSize / 2, 'a'), values[0]);
  ASSERT_TRUE(status_list[1].IsNotFound());
  ASSERT_OK(status_list[2]);
  ASSERT_EQ(DummyString(kFileSize / 2, 'e'), values[2]);
  ASSERT_TRUE(status_list[3].IsNotFound());
  ASSERT_OK(status_list[4]);
  ASSERT_EQ(DummyString(kFileSize / 2, 'i'), values[4]);
  ASSERT_TRUE(status_list[5].IsNotFound());
L
Lei Jin 已提交
1605 1606
}

K
Kai Liu 已提交
1607 1608
// Make sure that when options.block_cache is set, after a new table is
// created its index/filter blocks are added to block cache.
I
Igor Sugak 已提交
1609
TEST_F(DBTest, IndexAndFilterBlocksOfNewTableAddedToCache) {
K
Kai Liu 已提交
1610 1611 1612
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
1613 1614
  BlockBasedTableOptions table_options;
  table_options.cache_index_and_filter_blocks = true;
1615
  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
1616
  options.table_factory.reset(new BlockBasedTableFactory(table_options));
L
Lei Jin 已提交
1617
  CreateAndReopenWithCF({"pikachu"}, options);
K
Kai Liu 已提交
1618

1619 1620 1621
  ASSERT_OK(Put(1, "key", "val"));
  // Create a new table.
  ASSERT_OK(Flush(1));
K
Kai Liu 已提交
1622 1623

  // index/filter blocks added to block cache right after table creation.
I
Igor Canadi 已提交
1624 1625
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
K
Kai Liu 已提交
1626
  ASSERT_EQ(2, /* only index/filter were added */
I
Igor Canadi 已提交
1627 1628
            TestGetTickerCount(options, BLOCK_CACHE_ADD));
  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_MISS));
1629 1630 1631 1632
  uint64_t int_num;
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_EQ(int_num, 0U);
K
Kai Liu 已提交
1633 1634 1635 1636

  // Make sure filter block is in cache.
  std::string value;
  ReadOptions ropt;
1637
  db_->KeyMayExist(ReadOptions(), handles_[1], "key", &value);
K
Kai Liu 已提交
1638 1639

  // Miss count should remain the same.
I
Igor Canadi 已提交
1640 1641
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
K
Kai Liu 已提交
1642

1643
  db_->KeyMayExist(ReadOptions(), handles_[1], "key", &value);
I
Igor Canadi 已提交
1644 1645
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
  ASSERT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
K
Kai Liu 已提交
1646 1647

  // Make sure index block is in cache.
I
Igor Canadi 已提交
1648
  auto index_block_hit = TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT);
1649
  value = Get(1, "key");
I
Igor Canadi 已提交
1650
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
K
Kai Liu 已提交
1651
  ASSERT_EQ(index_block_hit + 1,
I
Igor Canadi 已提交
1652
            TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
K
Kai Liu 已提交
1653

1654
  value = Get(1, "key");
I
Igor Canadi 已提交
1655
  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
K
Kai Liu 已提交
1656
  ASSERT_EQ(index_block_hit + 2,
I
Igor Canadi 已提交
1657
            TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
K
Kai Liu 已提交
1658 1659
}

1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
TEST_F(DBTest, ParanoidFileChecks) {
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
  options.level0_file_num_compaction_trigger = 2;
  options.paranoid_file_checks = true;
  BlockBasedTableOptions table_options;
  table_options.cache_index_and_filter_blocks = false;
  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
  options.table_factory.reset(new BlockBasedTableFactory(table_options));
  CreateAndReopenWithCF({"pikachu"}, options);

  ASSERT_OK(Put(1, "1_key", "val"));
  ASSERT_OK(Put(1, "9_key", "val"));
  // Create a new table.
  ASSERT_OK(Flush(1));
  ASSERT_EQ(1, /* read and cache data block */
            TestGetTickerCount(options, BLOCK_CACHE_ADD));

  ASSERT_OK(Put(1, "1_key2", "val2"));
  ASSERT_OK(Put(1, "9_key2", "val2"));
  // Create a new SST file. This will further trigger a compaction
  // and generate another file.
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ(3, /* Totally 3 files created up to now */
            TestGetTickerCount(options, BLOCK_CACHE_ADD));

  // After disabling options.paranoid_file_checks. NO further block
  // is added after generating a new file.
  ASSERT_OK(
      dbfull()->SetOptions(handles_[1], {{"paranoid_file_checks", "false"}}));

  ASSERT_OK(Put(1, "1_key3", "val3"));
  ASSERT_OK(Put(1, "9_key3", "val3"));
  ASSERT_OK(Flush(1));
  ASSERT_OK(Put(1, "1_key4", "val4"));
  ASSERT_OK(Put(1, "9_key4", "val4"));
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ(3, /* Totally 3 files created up to now */
            TestGetTickerCount(options, BLOCK_CACHE_ADD));
}

I
Igor Sugak 已提交
1704
TEST_F(DBTest, GetPropertiesOfAllTablesTest) {
1705
  Options options = CurrentOptions();
I
Igor Canadi 已提交
1706
  options.max_background_flushes = 0;
L
Lei Jin 已提交
1707
  Reopen(options);
1708 1709 1710
  // Create 4 tables
  for (int table = 0; table < 4; ++table) {
    for (int i = 0; i < 10 + table; ++i) {
1711
      db_->Put(WriteOptions(), ToString(table * 100 + i), "val");
1712 1713 1714 1715 1716
    }
    db_->Flush(FlushOptions());
  }

  // 1. Read table properties directly from file
L
Lei Jin 已提交
1717
  Reopen(options);
1718 1719 1720
  VerifyTableProperties(db_, 10 + 11 + 12 + 13);

  // 2. Put two tables to table cache and
L
Lei Jin 已提交
1721
  Reopen(options);
1722 1723 1724
  // fetch key from 1st and 2nd table, which will internally place that table to
  // the table cache.
  for (int i = 0; i < 2; ++i) {
1725
    Get(ToString(i * 100 + 0));
1726 1727 1728 1729 1730
  }

  VerifyTableProperties(db_, 10 + 11 + 12 + 13);

  // 3. Put all tables to table cache
L
Lei Jin 已提交
1731
  Reopen(options);
1732 1733 1734
  // fetch key from 1st and 2nd table, which will internally place that table to
  // the table cache.
  for (int i = 0; i < 4; ++i) {
1735
    Get(ToString(i * 100 + 0));
1736 1737 1738 1739
  }
  VerifyTableProperties(db_, 10 + 11 + 12 + 13);
}

1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811
class CoutingUserTblPropCollector : public TablePropertiesCollector {
 public:
  const char* Name() const override { return "CoutingUserTblPropCollector"; }

  Status Finish(UserCollectedProperties* properties) override {
    std::string encoded;
    PutVarint32(&encoded, count_);
    *properties = UserCollectedProperties{
        {"CoutingUserTblPropCollector", message_}, {"Count", encoded},
    };
    return Status::OK();
  }

  Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type,
                    SequenceNumber seq, uint64_t file_size) override {
    ++count_;
    return Status::OK();
  }

  virtual UserCollectedProperties GetReadableProperties() const override {
    return UserCollectedProperties{};
  }

 private:
  std::string message_ = "Rocksdb";
  uint32_t count_ = 0;
};

class CoutingUserTblPropCollectorFactory
    : public TablePropertiesCollectorFactory {
 public:
  virtual TablePropertiesCollector* CreateTablePropertiesCollector() override {
    return new CoutingUserTblPropCollector();
  }
  const char* Name() const override {
    return "CoutingUserTblPropCollectorFactory";
  }
};

TEST_F(DBTest, GetUserDefinedTablaProperties) {
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
  options.table_properties_collector_factories.resize(1);
  options.table_properties_collector_factories[0] =
      std::make_shared<CoutingUserTblPropCollectorFactory>();
  Reopen(options);
  // Create 4 tables
  for (int table = 0; table < 4; ++table) {
    for (int i = 0; i < 10 + table; ++i) {
      db_->Put(WriteOptions(), ToString(table * 100 + i), "val");
    }
    db_->Flush(FlushOptions());
  }

  TablePropertiesCollection props;
  ASSERT_OK(db_->GetPropertiesOfAllTables(&props));
  ASSERT_EQ(4U, props.size());
  uint32_t sum = 0;
  for (const auto& item : props) {
    auto& user_collected = item.second->user_collected_properties;
    ASSERT_TRUE(user_collected.find("CoutingUserTblPropCollector") !=
                user_collected.end());
    ASSERT_EQ(user_collected.at("CoutingUserTblPropCollector"), "Rocksdb");
    ASSERT_TRUE(user_collected.find("Count") != user_collected.end());
    Slice key(user_collected.at("Count"));
    uint32_t count;
    ASSERT_TRUE(GetVarint32(&key, &count));
    sum += count;
  }
  ASSERT_EQ(10u + 11u + 12u + 13u, sum);
}

I
Igor Sugak 已提交
1812
TEST_F(DBTest, LevelLimitReopen) {
1813
  Options options = CurrentOptions();
L
Lei Jin 已提交
1814
  CreateAndReopenWithCF({"pikachu"}, options);
1815 1816 1817

  const std::string value(1024 * 1024, ' ');
  int i = 0;
1818 1819
  while (NumTableFilesAtLevel(2, 1) == 0) {
    ASSERT_OK(Put(1, Key(i++), value));
1820 1821 1822
  }

  options.num_levels = 1;
1823
  options.max_bytes_for_level_multiplier_additional.resize(1, 1);
L
Lei Jin 已提交
1824
  Status s = TryReopenWithColumnFamilies({"default", "pikachu"}, options);
1825
  ASSERT_EQ(s.IsInvalidArgument(), true);
1826
  ASSERT_EQ(s.ToString(),
1827
            "Invalid argument: db has more levels than options.num_levels");
1828 1829

  options.num_levels = 10;
1830
  options.max_bytes_for_level_multiplier_additional.resize(10, 1);
L
Lei Jin 已提交
1831
  ASSERT_OK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
1832 1833
}

I
Igor Sugak 已提交
1834
TEST_F(DBTest, PutDeleteGet) {
S
Sanjay Ghemawat 已提交
1835
  do {
L
Lei Jin 已提交
1836
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1837 1838 1839 1840 1841 1842
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_OK(Put(1, "foo", "v2"));
    ASSERT_EQ("v2", Get(1, "foo"));
    ASSERT_OK(Delete(1, "foo"));
    ASSERT_EQ("NOT_FOUND", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
1843
  } while (ChangeOptions());
J
jorlow@chromium.org 已提交
1844 1845
}

I
Igor Sugak 已提交
1846
TEST_F(DBTest, GetFromImmutableLayer) {
S
Sanjay Ghemawat 已提交
1847
  do {
1848
    Options options;
S
Sanjay Ghemawat 已提交
1849 1850
    options.env = env_;
    options.write_buffer_size = 100000;  // Small write buffer
1851
    options = CurrentOptions(options);
L
Lei Jin 已提交
1852
    CreateAndReopenWithCF({"pikachu"}, options);
1853

1854 1855
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_EQ("v1", Get(1, "foo"));
1856

I
Igor Canadi 已提交
1857 1858
    // Block sync calls
    env_->delay_sstable_sync_.store(true, std::memory_order_release);
1859 1860 1861 1862
    Put(1, "k1", std::string(100000, 'x'));          // Fill memtable
    Put(1, "k2", std::string(100000, 'y'));          // Trigger flush
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("NOT_FOUND", Get(0, "foo"));
I
Igor Canadi 已提交
1863 1864
    // Release sync calls
    env_->delay_sstable_sync_.store(false, std::memory_order_release);
S
Sanjay Ghemawat 已提交
1865
  } while (ChangeOptions());
1866 1867
}

I
Igor Sugak 已提交
1868
TEST_F(DBTest, GetFromVersions) {
S
Sanjay Ghemawat 已提交
1869
  do {
L
Lei Jin 已提交
1870
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1871 1872 1873 1874
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Flush(1));
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("NOT_FOUND", Get(0, "foo"));
S
Sanjay Ghemawat 已提交
1875
  } while (ChangeOptions());
1876 1877
}

I
Igor Sugak 已提交
1878
TEST_F(DBTest, GetSnapshot) {
1879 1880
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
S
Sanjay Ghemawat 已提交
1881
  do {
1882
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions(options_override));
S
Sanjay Ghemawat 已提交
1883 1884 1885
    // Try with both a short key and a long key
    for (int i = 0; i < 2; i++) {
      std::string key = (i == 0) ? std::string("foo") : std::string(200, 'x');
1886
      ASSERT_OK(Put(1, key, "v1"));
S
Sanjay Ghemawat 已提交
1887
      const Snapshot* s1 = db_->GetSnapshot();
S
sdong 已提交
1888 1889 1890 1891 1892
      if (option_config_ == kHashCuckoo) {
        // NOt supported case.
        ASSERT_TRUE(s1 == nullptr);
        break;
      }
1893 1894 1895 1896 1897 1898
      ASSERT_OK(Put(1, key, "v2"));
      ASSERT_EQ("v2", Get(1, key));
      ASSERT_EQ("v1", Get(1, key, s1));
      ASSERT_OK(Flush(1));
      ASSERT_EQ("v2", Get(1, key));
      ASSERT_EQ("v1", Get(1, key, s1));
S
Sanjay Ghemawat 已提交
1899 1900
      db_->ReleaseSnapshot(s1);
    }
S
sdong 已提交
1901
  } while (ChangeOptions());
1902 1903
}

I
Igor Sugak 已提交
1904
TEST_F(DBTest, GetLevel0Ordering) {
S
Sanjay Ghemawat 已提交
1905
  do {
L
Lei Jin 已提交
1906
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
S
Sanjay Ghemawat 已提交
1907 1908 1909 1910
    // Check that we process level-0 files in correct order.  The code
    // below generates two level-0 files where the earlier one comes
    // before the later one in the level-0 file list since the earlier
    // one has a smaller "smallest" key.
1911 1912 1913 1914 1915 1916
    ASSERT_OK(Put(1, "bar", "b"));
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Flush(1));
    ASSERT_OK(Put(1, "foo", "v2"));
    ASSERT_OK(Flush(1));
    ASSERT_EQ("v2", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
1917
  } while (ChangeOptions());
1918 1919
}

I
Igor Sugak 已提交
1920
TEST_F(DBTest, WrongLevel0Config) {
1921 1922 1923 1924 1925 1926 1927 1928 1929
  Options options = CurrentOptions();
  Close();
  ASSERT_OK(DestroyDB(dbname_, options));
  options.level0_stop_writes_trigger = 1;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_file_num_compaction_trigger = 3;
  ASSERT_OK(DB::Open(options, dbname_, &db_));
}

I
Igor Sugak 已提交
1930
TEST_F(DBTest, GetOrderedByLevels) {
S
Sanjay Ghemawat 已提交
1931
  do {
L
Lei Jin 已提交
1932
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
1933 1934 1935 1936 1937 1938 1939
    ASSERT_OK(Put(1, "foo", "v1"));
    Compact(1, "a", "z");
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_OK(Put(1, "foo", "v2"));
    ASSERT_EQ("v2", Get(1, "foo"));
    ASSERT_OK(Flush(1));
    ASSERT_EQ("v2", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
1940
  } while (ChangeOptions());
1941 1942
}

I
Igor Sugak 已提交
1943
TEST_F(DBTest, GetPicksCorrectFile) {
S
Sanjay Ghemawat 已提交
1944
  do {
L
Lei Jin 已提交
1945
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
S
Sanjay Ghemawat 已提交
1946
    // Arrange to have multiple files in a non-level-0 level.
1947 1948 1949 1950 1951 1952 1953 1954 1955
    ASSERT_OK(Put(1, "a", "va"));
    Compact(1, "a", "b");
    ASSERT_OK(Put(1, "x", "vx"));
    Compact(1, "x", "y");
    ASSERT_OK(Put(1, "f", "vf"));
    Compact(1, "f", "g");
    ASSERT_EQ("va", Get(1, "a"));
    ASSERT_EQ("vf", Get(1, "f"));
    ASSERT_EQ("vx", Get(1, "x"));
S
Sanjay Ghemawat 已提交
1956
  } while (ChangeOptions());
1957 1958
}

I
Igor Sugak 已提交
1959
TEST_F(DBTest, GetEncountersEmptyLevel) {
S
Sanjay Ghemawat 已提交
1960
  do {
I
Igor Canadi 已提交
1961 1962 1963
    Options options = CurrentOptions();
    options.max_background_flushes = 0;
    options.disableDataSync = true;
L
Lei Jin 已提交
1964
    CreateAndReopenWithCF({"pikachu"}, options);
S
Sanjay Ghemawat 已提交
1965 1966 1967 1968 1969 1970
    // Arrange for the following to happen:
    //   * sstable A in level 0
    //   * nothing in level 1
    //   * sstable B in level 2
    // Then do enough Get() calls to arrange for an automatic compaction
    // of sstable A.  A bug would cause the compaction to be marked as
C
clark.kang 已提交
1971
    // occurring at level 1 (instead of the correct level 0).
S
Sanjay Ghemawat 已提交
1972 1973 1974

    // Step 1: First place sstables in levels 0 and 2
    int compaction_count = 0;
1975
    while (NumTableFilesAtLevel(0, 1) == 0 || NumTableFilesAtLevel(2, 1) == 0) {
S
Sanjay Ghemawat 已提交
1976 1977
      ASSERT_LE(compaction_count, 100) << "could not fill levels 0 and 2";
      compaction_count++;
1978 1979 1980
      Put(1, "a", "begin");
      Put(1, "z", "end");
      ASSERT_OK(Flush(1));
S
Sanjay Ghemawat 已提交
1981
    }
1982

S
Sanjay Ghemawat 已提交
1983
    // Step 2: clear level 1 if necessary.
1984 1985 1986 1987
    dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 1);
    ASSERT_EQ(NumTableFilesAtLevel(1, 1), 0);
    ASSERT_EQ(NumTableFilesAtLevel(2, 1), 1);
S
Sanjay Ghemawat 已提交
1988

H
heyongqiang 已提交
1989 1990
    // Step 3: read a bunch of times
    for (int i = 0; i < 1000; i++) {
1991
      ASSERT_EQ("NOT_FOUND", Get(1, "missing"));
S
Sanjay Ghemawat 已提交
1992
    }
H
heyongqiang 已提交
1993 1994 1995 1996

    // Step 4: Wait for compaction to finish
    env_->SleepForMicroseconds(1000000);

1997
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 1);  // XXX
I
Igor Canadi 已提交
1998
  } while (ChangeOptions(kSkipUniversalCompaction | kSkipFIFOCompaction));
1999 2000
}

2001 2002 2003
// KeyMayExist can lead to a few false positives, but not false negatives.
// To make test deterministic, use a much larger number of bits per key-20 than
// bits in the key, so that false positives are eliminated
I
Igor Sugak 已提交
2004
TEST_F(DBTest, KeyMayExist) {
2005
  do {
2006 2007
    ReadOptions ropts;
    std::string value;
2008 2009 2010
    anon::OptionsOverride options_override;
    options_override.filter_policy.reset(NewBloomFilterPolicy(20));
    Options options = CurrentOptions(options_override);
2011
    options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
2012
    CreateAndReopenWithCF({"pikachu"}, options);
2013

2014
    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "a", &value));
2015

2016
    ASSERT_OK(Put(1, "a", "b"));
2017
    bool value_found = false;
2018 2019
    ASSERT_TRUE(
        db_->KeyMayExist(ropts, handles_[1], "a", &value, &value_found));
2020 2021
    ASSERT_TRUE(value_found);
    ASSERT_EQ("b", value);
2022

2023
    ASSERT_OK(Flush(1));
2024
    value.clear();
2025

I
Igor Canadi 已提交
2026 2027
    long numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    long cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
2028 2029
    ASSERT_TRUE(
        db_->KeyMayExist(ropts, handles_[1], "a", &value, &value_found));
M
Mayank Agarwal 已提交
2030
    ASSERT_TRUE(!value_found);
2031 2032
    // assert that no new files were opened and no new blocks were
    // read into block cache.
I
Igor Canadi 已提交
2033 2034
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
2035

2036
    ASSERT_OK(Delete(1, "a"));
2037

I
Igor Canadi 已提交
2038 2039
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
2040
    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "a", &value));
I
Igor Canadi 已提交
2041 2042
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
2043

2044
    ASSERT_OK(Flush(1));
2045 2046
    dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1],
                                true /* disallow trivial move */);
2047

I
Igor Canadi 已提交
2048 2049
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
2050
    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "a", &value));
I
Igor Canadi 已提交
2051 2052
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
2053

2054
    ASSERT_OK(Delete(1, "c"));
2055

I
Igor Canadi 已提交
2056 2057
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
2058
    ASSERT_TRUE(!db_->KeyMayExist(ropts, handles_[1], "c", &value));
I
Igor Canadi 已提交
2059 2060
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
2061

2062 2063
    // KeyMayExist function only checks data in block caches, which is not used
    // by plain table format.
I
Igor Canadi 已提交
2064 2065
  } while (
      ChangeOptions(kSkipPlainTable | kSkipHashIndex | kSkipFIFOCompaction));
2066 2067
}

I
Igor Sugak 已提交
2068
TEST_F(DBTest, NonBlockingIteration) {
2069 2070 2071
  do {
    ReadOptions non_blocking_opts, regular_opts;
    Options options = CurrentOptions();
2072
    options.statistics = rocksdb::CreateDBStatistics();
2073
    non_blocking_opts.read_tier = kBlockCacheTier;
L
Lei Jin 已提交
2074
    CreateAndReopenWithCF({"pikachu"}, options);
2075
    // write one kv to the database.
2076
    ASSERT_OK(Put(1, "a", "b"));
2077 2078 2079

    // scan using non-blocking iterator. We should find it because
    // it is in memtable.
2080
    Iterator* iter = db_->NewIterator(non_blocking_opts, handles_[1]);
2081 2082
    int count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
N
Naman Gupta 已提交
2083
      ASSERT_OK(iter->status());
2084 2085 2086 2087 2088 2089 2090
      count++;
    }
    ASSERT_EQ(count, 1);
    delete iter;

    // flush memtable to storage. Now, the key should not be in the
    // memtable neither in the block cache.
2091
    ASSERT_OK(Flush(1));
2092 2093 2094

    // verify that a non-blocking iterator does not find any
    // kvs. Neither does it do any IOs to storage.
I
Igor Canadi 已提交
2095 2096
    long numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    long cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
2097
    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
2098 2099 2100 2101 2102 2103
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      count++;
    }
    ASSERT_EQ(count, 0);
    ASSERT_TRUE(iter->status().IsIncomplete());
I
Igor Canadi 已提交
2104 2105
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
2106 2107 2108
    delete iter;

    // read in the specified block via a regular get
2109
    ASSERT_EQ(Get(1, "a"), "b");
2110 2111

    // verify that we can find it via a non-blocking scan
I
Igor Canadi 已提交
2112 2113
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
2114
    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
2115 2116
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
N
Naman Gupta 已提交
2117
      ASSERT_OK(iter->status());
2118 2119 2120
      count++;
    }
    ASSERT_EQ(count, 1);
I
Igor Canadi 已提交
2121 2122
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
2123 2124
    delete iter;

2125 2126
    // This test verifies block cache behaviors, which is not used by plain
    // table format.
2127
    // Exclude kHashCuckoo as it does not support iteration currently
I
Igor Canadi 已提交
2128 2129
  } while (ChangeOptions(kSkipPlainTable | kSkipNoSeekToLast | kSkipHashCuckoo |
                         kSkipMmapReads));
2130 2131
}

I
Igor Sugak 已提交
2132
TEST_F(DBTest, ManagedNonBlockingIteration) {
V
Venkatesh Radhakrishnan 已提交
2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196
  do {
    ReadOptions non_blocking_opts, regular_opts;
    Options options = CurrentOptions();
    options.statistics = rocksdb::CreateDBStatistics();
    non_blocking_opts.read_tier = kBlockCacheTier;
    non_blocking_opts.managed = true;
    CreateAndReopenWithCF({"pikachu"}, options);
    // write one kv to the database.
    ASSERT_OK(Put(1, "a", "b"));

    // scan using non-blocking iterator. We should find it because
    // it is in memtable.
    Iterator* iter = db_->NewIterator(non_blocking_opts, handles_[1]);
    int count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      ASSERT_OK(iter->status());
      count++;
    }
    ASSERT_EQ(count, 1);
    delete iter;

    // flush memtable to storage. Now, the key should not be in the
    // memtable neither in the block cache.
    ASSERT_OK(Flush(1));

    // verify that a non-blocking iterator does not find any
    // kvs. Neither does it do any IOs to storage.
    int64_t numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    int64_t cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      count++;
    }
    ASSERT_EQ(count, 0);
    ASSERT_TRUE(iter->status().IsIncomplete());
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
    delete iter;

    // read in the specified block via a regular get
    ASSERT_EQ(Get(1, "a"), "b");

    // verify that we can find it via a non-blocking scan
    numopen = TestGetTickerCount(options, NO_FILE_OPENS);
    cache_added = TestGetTickerCount(options, BLOCK_CACHE_ADD);
    iter = db_->NewIterator(non_blocking_opts, handles_[1]);
    count = 0;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      ASSERT_OK(iter->status());
      count++;
    }
    ASSERT_EQ(count, 1);
    ASSERT_EQ(numopen, TestGetTickerCount(options, NO_FILE_OPENS));
    ASSERT_EQ(cache_added, TestGetTickerCount(options, BLOCK_CACHE_ADD));
    delete iter;

    // This test verifies block cache behaviors, which is not used by plain
    // table format.
    // Exclude kHashCuckoo as it does not support iteration currently
  } while (ChangeOptions(kSkipPlainTable | kSkipNoSeekToLast | kSkipHashCuckoo |
                         kSkipMmapReads));
}

2197 2198
// A delete is skipped for key if KeyMayExist(key) returns False
// Tests Writebatch consistency and proper delete behaviour
I
Igor Sugak 已提交
2199
TEST_F(DBTest, FilterDeletes) {
2200
  do {
2201 2202 2203
    anon::OptionsOverride options_override;
    options_override.filter_policy.reset(NewBloomFilterPolicy(20));
    Options options = CurrentOptions(options_override);
2204
    options.filter_deletes = true;
L
Lei Jin 已提交
2205
    CreateAndReopenWithCF({"pikachu"}, options);
2206 2207
    WriteBatch batch;

I
Igor Canadi 已提交
2208
    batch.Delete(handles_[1], "a");
2209
    dbfull()->Write(WriteOptions(), &batch);
2210
    ASSERT_EQ(AllEntriesFor("a", 1), "[ ]");  // Delete skipped
2211 2212
    batch.Clear();

I
Igor Canadi 已提交
2213 2214
    batch.Put(handles_[1], "a", "b");
    batch.Delete(handles_[1], "a");
2215
    dbfull()->Write(WriteOptions(), &batch);
2216 2217
    ASSERT_EQ(Get(1, "a"), "NOT_FOUND");
    ASSERT_EQ(AllEntriesFor("a", 1), "[ DEL, b ]");  // Delete issued
2218 2219
    batch.Clear();

I
Igor Canadi 已提交
2220 2221
    batch.Delete(handles_[1], "c");
    batch.Put(handles_[1], "c", "d");
2222
    dbfull()->Write(WriteOptions(), &batch);
2223 2224
    ASSERT_EQ(Get(1, "c"), "d");
    ASSERT_EQ(AllEntriesFor("c", 1), "[ d ]");  // Delete skipped
2225 2226
    batch.Clear();

2227
    ASSERT_OK(Flush(1));  // A stray Flush
2228

I
Igor Canadi 已提交
2229
    batch.Delete(handles_[1], "c");
2230
    dbfull()->Write(WriteOptions(), &batch);
2231
    ASSERT_EQ(AllEntriesFor("c", 1), "[ DEL, d ]");  // Delete issued
2232 2233
    batch.Clear();
  } while (ChangeCompactOptions());
2234 2235
}

I
Igor Sugak 已提交
2236
TEST_F(DBTest, GetFilterByPrefixBloom) {
2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270
  Options options = last_options_;
  options.prefix_extractor.reset(NewFixedPrefixTransform(8));
  options.statistics = rocksdb::CreateDBStatistics();
  BlockBasedTableOptions bbto;
  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
  bbto.whole_key_filtering = false;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  DestroyAndReopen(options);

  WriteOptions wo;
  ReadOptions ro;
  FlushOptions fo;
  fo.wait = true;
  std::string value;

  ASSERT_OK(dbfull()->Put(wo, "barbarbar", "foo"));
  ASSERT_OK(dbfull()->Put(wo, "barbarbar2", "foo2"));
  ASSERT_OK(dbfull()->Put(wo, "foofoofoo", "bar"));

  dbfull()->Flush(fo);

  ASSERT_EQ("foo", Get("barbarbar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
  ASSERT_EQ("foo2", Get("barbarbar2"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
  ASSERT_EQ("NOT_FOUND", Get("barbarbar3"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);

  ASSERT_EQ("NOT_FOUND", Get("barfoofoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);

  ASSERT_EQ("NOT_FOUND", Get("foobarbar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 2);
}
I
Igor Canadi 已提交
2271

I
Igor Sugak 已提交
2272
TEST_F(DBTest, WholeKeyFilterProp) {
2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324
  Options options = last_options_;
  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
  options.statistics = rocksdb::CreateDBStatistics();

  BlockBasedTableOptions bbto;
  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
  bbto.whole_key_filtering = false;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  DestroyAndReopen(options);

  WriteOptions wo;
  ReadOptions ro;
  FlushOptions fo;
  fo.wait = true;
  std::string value;

  ASSERT_OK(dbfull()->Put(wo, "foobar", "foo"));
  // Needs insert some keys to make sure files are not filtered out by key
  // ranges.
  ASSERT_OK(dbfull()->Put(wo, "aaa", ""));
  ASSERT_OK(dbfull()->Put(wo, "zzz", ""));
  dbfull()->Flush(fo);

  Reopen(options);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);

  // Reopen with whole key filtering enabled and prefix extractor
  // NULL. Bloom filter should be off for both of whole key and
  // prefix bloom.
  bbto.whole_key_filtering = true;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  options.prefix_extractor.reset();
  Reopen(options);

  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  // Write DB with only full key filtering.
  ASSERT_OK(dbfull()->Put(wo, "foobar", "foo"));
  // Needs insert some keys to make sure files are not filtered out by key
  // ranges.
  ASSERT_OK(dbfull()->Put(wo, "aaa", ""));
  ASSERT_OK(dbfull()->Put(wo, "zzz", ""));
2325
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347

  // Reopen with both of whole key off and prefix extractor enabled.
  // Still no bloom filter should be used.
  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
  bbto.whole_key_filtering = false;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  Reopen(options);

  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);

  // Try to create a DB with mixed files:
  ASSERT_OK(dbfull()->Put(wo, "foobar", "foo"));
  // Needs insert some keys to make sure files are not filtered out by key
  // ranges.
  ASSERT_OK(dbfull()->Put(wo, "aaa", ""));
  ASSERT_OK(dbfull()->Put(wo, "zzz", ""));
2348
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420

  options.prefix_extractor.reset();
  bbto.whole_key_filtering = true;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  Reopen(options);

  // Try to create a DB with mixed files.
  ASSERT_OK(dbfull()->Put(wo, "barfoo", "bar"));
  // In this case needs insert some keys to make sure files are
  // not filtered out by key ranges.
  ASSERT_OK(dbfull()->Put(wo, "aaa", ""));
  ASSERT_OK(dbfull()->Put(wo, "zzz", ""));
  Flush();

  // Now we have two files:
  // File 1: An older file with prefix bloom.
  // File 2: A newer file with whole bloom filter.
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 1);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 2);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 3);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 4);
  ASSERT_EQ("bar", Get("barfoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 4);

  // Reopen with the same setting: only whole key is used
  Reopen(options);
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 4);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 5);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 6);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 7);
  ASSERT_EQ("bar", Get("barfoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 7);

  // Restart with both filters are allowed
  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
  bbto.whole_key_filtering = true;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  Reopen(options);
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 7);
  // File 1 will has it filtered out.
  // File 2 will not, as prefix `foo` exists in the file.
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 8);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 10);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 11);
  ASSERT_EQ("bar", Get("barfoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 11);

  // Restart with only prefix bloom is allowed.
  options.prefix_extractor.reset(NewFixedPrefixTransform(3));
  bbto.whole_key_filtering = false;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  Reopen(options);
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 11);
  ASSERT_EQ("NOT_FOUND", Get("foo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 11);
  ASSERT_EQ("NOT_FOUND", Get("bar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 12);
  ASSERT_EQ("foo", Get("foobar"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 12);
  ASSERT_EQ("bar", Get("barfoo"));
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 12);
}

I
Igor Sugak 已提交
2421
TEST_F(DBTest, IterSeekBeforePrev) {
I
Igor Canadi 已提交
2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("0", "f"));
  ASSERT_OK(Put("1", "h"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("2", "j"));
  auto iter = db_->NewIterator(ReadOptions());
  iter->Seek(Slice("c"));
  iter->Prev();
  iter->Seek(Slice("a"));
  iter->Prev();
  delete iter;
}

I
Igor Canadi 已提交
2437
namespace {
2438 2439 2440
std::string MakeLongKey(size_t length, char c) {
  return std::string(length, c);
}
I
Igor Canadi 已提交
2441
}  // namespace
2442

I
Igor Sugak 已提交
2443
TEST_F(DBTest, IterLongKeys) {
2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475
  ASSERT_OK(Put(MakeLongKey(20, 0), "0"));
  ASSERT_OK(Put(MakeLongKey(32, 2), "2"));
  ASSERT_OK(Put("a", "b"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put(MakeLongKey(50, 1), "1"));
  ASSERT_OK(Put(MakeLongKey(127, 3), "3"));
  ASSERT_OK(Put(MakeLongKey(64, 4), "4"));
  auto iter = db_->NewIterator(ReadOptions());

  // Create a key that needs to be skipped for Seq too new
  iter->Seek(MakeLongKey(20, 0));
  ASSERT_EQ(IterStatus(iter), MakeLongKey(20, 0) + "->0");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(50, 1) + "->1");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(32, 2) + "->2");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(127, 3) + "->3");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(64, 4) + "->4");
  delete iter;

  iter = db_->NewIterator(ReadOptions());
  iter->Seek(MakeLongKey(50, 1));
  ASSERT_EQ(IterStatus(iter), MakeLongKey(50, 1) + "->1");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(32, 2) + "->2");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), MakeLongKey(127, 3) + "->3");
  delete iter;
}

I
Igor Sugak 已提交
2476
TEST_F(DBTest, IterNextWithNewerSeq) {
S
sdong 已提交
2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496
  ASSERT_OK(Put("0", "0"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  ASSERT_OK(Put("d", "e"));
  auto iter = db_->NewIterator(ReadOptions());

  // Create a key that needs to be skipped for Seq too new
  for (uint64_t i = 0; i < last_options_.max_sequential_skip_in_iterations + 1;
       i++) {
    ASSERT_OK(Put("b", "f"));
  }

  iter->Seek(Slice("a"));
  ASSERT_EQ(IterStatus(iter), "a->b");
  iter->Next();
  ASSERT_EQ(IterStatus(iter), "c->d");
  delete iter;
}

I
Igor Sugak 已提交
2497
TEST_F(DBTest, IterPrevWithNewerSeq) {
S
sdong 已提交
2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521
  ASSERT_OK(Put("0", "0"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  ASSERT_OK(Put("d", "e"));
  auto iter = db_->NewIterator(ReadOptions());

  // Create a key that needs to be skipped for Seq too new
  for (uint64_t i = 0; i < last_options_.max_sequential_skip_in_iterations + 1;
       i++) {
    ASSERT_OK(Put("b", "f"));
  }

  iter->Seek(Slice("d"));
  ASSERT_EQ(IterStatus(iter), "d->e");
  iter->Prev();
  ASSERT_EQ(IterStatus(iter), "c->d");
  iter->Prev();
  ASSERT_EQ(IterStatus(iter), "a->b");

  iter->Prev();
  delete iter;
}

I
Igor Sugak 已提交
2522
TEST_F(DBTest, IterPrevWithNewerSeq2) {
S
sdong 已提交
2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544
  ASSERT_OK(Put("0", "0"));
  dbfull()->Flush(FlushOptions());
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  ASSERT_OK(Put("d", "e"));
  auto iter = db_->NewIterator(ReadOptions());
  iter->Seek(Slice("c"));
  ASSERT_EQ(IterStatus(iter), "c->d");

  // Create a key that needs to be skipped for Seq too new
  for (uint64_t i = 0; i < last_options_.max_sequential_skip_in_iterations + 1;
      i++) {
    ASSERT_OK(Put("b", "f"));
  }

  iter->Prev();
  ASSERT_EQ(IterStatus(iter), "a->b");

  iter->Prev();
  delete iter;
}

I
Igor Sugak 已提交
2545
TEST_F(DBTest, IterEmpty) {
2546
  do {
L
Lei Jin 已提交
2547
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
2548
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
2549

2550 2551
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
2552

2553 2554
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
2555

2556 2557
    iter->Seek("foo");
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
2558

2559 2560
    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
2561 2562
}

I
Igor Sugak 已提交
2563
TEST_F(DBTest, IterSingle) {
2564
  do {
L
Lei Jin 已提交
2565
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
2566 2567
    ASSERT_OK(Put(1, "a", "va"));
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
2568

2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
2591

2592 2593 2594 2595 2596 2597 2598 2599 2600 2601
    iter->Seek("a");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("b");
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
2602 2603
}

I
Igor Sugak 已提交
2604
TEST_F(DBTest, IterMulti) {
2605
  do {
L
Lei Jin 已提交
2606
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
2607 2608 2609 2610
    ASSERT_OK(Put(1, "a", "va"));
    ASSERT_OK(Put(1, "b", "vb"));
    ASSERT_OK(Put(1, "c", "vc"));
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
2611

2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
2624

2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    iter->Seek("");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Seek("a");
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Seek("ax");
    ASSERT_EQ(IterStatus(iter), "b->vb");
2644

2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664
    iter->Seek("b");
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Seek("z");
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    // Switch from reverse to forward
    iter->SeekToLast();
    iter->Prev();
    iter->Prev();
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->vb");

    // Switch from forward to reverse
    iter->SeekToFirst();
    iter->Next();
    iter->Next();
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->vb");

    // Make sure iter stays at snapshot
2665 2666 2667 2668 2669
    ASSERT_OK(Put(1, "a", "va2"));
    ASSERT_OK(Put(1, "a2", "va3"));
    ASSERT_OK(Put(1, "b", "vb2"));
    ASSERT_OK(Put(1, "c", "vc2"));
    ASSERT_OK(Delete(1, "b"));
2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->vb");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
2689 2690
}

2691 2692
// Check that we can skip over a run of user keys
// by using reseek rather than sequential scan
I
Igor Sugak 已提交
2693
TEST_F(DBTest, IterReseek) {
2694 2695 2696
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
  Options options = CurrentOptions(options_override);
2697 2698
  options.max_sequential_skip_in_iterations = 3;
  options.create_if_missing = true;
2699
  options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
2700
  DestroyAndReopen(options);
L
Lei Jin 已提交
2701
  CreateAndReopenWithCF({"pikachu"}, options);
2702 2703 2704 2705

  // insert two keys with same userkey and verify that
  // reseek is not invoked. For each of these test cases,
  // verify that we can find the next key "b".
2706 2707 2708 2709
  ASSERT_OK(Put(1, "a", "one"));
  ASSERT_OK(Put(1, "a", "two"));
  ASSERT_OK(Put(1, "b", "bone"));
  Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
2710
  iter->SeekToFirst();
I
Igor Canadi 已提交
2711
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
2712 2713
  ASSERT_EQ(IterStatus(iter), "a->two");
  iter->Next();
I
Igor Canadi 已提交
2714
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
2715 2716 2717 2718 2719
  ASSERT_EQ(IterStatus(iter), "b->bone");
  delete iter;

  // insert a total of three keys with same userkey and verify
  // that reseek is still not invoked.
2720 2721
  ASSERT_OK(Put(1, "a", "three"));
  iter = db_->NewIterator(ReadOptions(), handles_[1]);
2722 2723 2724
  iter->SeekToFirst();
  ASSERT_EQ(IterStatus(iter), "a->three");
  iter->Next();
I
Igor Canadi 已提交
2725
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
2726 2727 2728 2729 2730
  ASSERT_EQ(IterStatus(iter), "b->bone");
  delete iter;

  // insert a total of four keys with same userkey and verify
  // that reseek is invoked.
2731 2732
  ASSERT_OK(Put(1, "a", "four"));
  iter = db_->NewIterator(ReadOptions(), handles_[1]);
2733 2734
  iter->SeekToFirst();
  ASSERT_EQ(IterStatus(iter), "a->four");
I
Igor Canadi 已提交
2735
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 0);
2736
  iter->Next();
I
Igor Canadi 已提交
2737
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION), 1);
2738 2739 2740 2741 2742 2743
  ASSERT_EQ(IterStatus(iter), "b->bone");
  delete iter;

  // Testing reverse iterator
  // At this point, we have three versions of "a" and one version of "b".
  // The reseek statistics is already at 1.
I
Igor Canadi 已提交
2744 2745
  int num_reseeks =
      (int)TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION);
2746 2747

  // Insert another version of b and assert that reseek is not invoked
2748 2749
  ASSERT_OK(Put(1, "b", "btwo"));
  iter = db_->NewIterator(ReadOptions(), handles_[1]);
2750 2751
  iter->SeekToLast();
  ASSERT_EQ(IterStatus(iter), "b->btwo");
I
Igor Canadi 已提交
2752 2753
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
            num_reseeks);
2754
  iter->Prev();
I
Igor Canadi 已提交
2755 2756
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
            num_reseeks + 1);
2757 2758 2759 2760 2761
  ASSERT_EQ(IterStatus(iter), "a->four");
  delete iter;

  // insert two more versions of b. This makes a total of 4 versions
  // of b and 4 versions of a.
2762 2763 2764
  ASSERT_OK(Put(1, "b", "bthree"));
  ASSERT_OK(Put(1, "b", "bfour"));
  iter = db_->NewIterator(ReadOptions(), handles_[1]);
2765 2766
  iter->SeekToLast();
  ASSERT_EQ(IterStatus(iter), "b->bfour");
I
Igor Canadi 已提交
2767 2768
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
            num_reseeks + 2);
2769 2770 2771
  iter->Prev();

  // the previous Prev call should have invoked reseek
I
Igor Canadi 已提交
2772 2773
  ASSERT_EQ(TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION),
            num_reseeks + 3);
2774 2775 2776 2777
  ASSERT_EQ(IterStatus(iter), "a->four");
  delete iter;
}

I
Igor Sugak 已提交
2778
TEST_F(DBTest, IterSmallAndLargeMix) {
2779
  do {
L
Lei Jin 已提交
2780
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
2781 2782 2783 2784 2785
    ASSERT_OK(Put(1, "a", "va"));
    ASSERT_OK(Put(1, "b", std::string(100000, 'b')));
    ASSERT_OK(Put(1, "c", "vc"));
    ASSERT_OK(Put(1, "d", std::string(100000, 'd')));
    ASSERT_OK(Put(1, "e", std::string(100000, 'e')));
J
jorlow@chromium.org 已提交
2786

2787
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
2788

2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
    iter->SeekToFirst();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "b->" + std::string(100000, 'b'));
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "d->" + std::string(100000, 'd'));
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "e->" + std::string(100000, 'e'));
    iter->Next();
    ASSERT_EQ(IterStatus(iter), "(invalid)");
J
jorlow@chromium.org 已提交
2801

2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816
    iter->SeekToLast();
    ASSERT_EQ(IterStatus(iter), "e->" + std::string(100000, 'e'));
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "d->" + std::string(100000, 'd'));
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "c->vc");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "b->" + std::string(100000, 'b'));
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "a->va");
    iter->Prev();
    ASSERT_EQ(IterStatus(iter), "(invalid)");

    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
2817 2818
}

I
Igor Sugak 已提交
2819
TEST_F(DBTest, IterMultiWithDelete) {
S
Sanjay Ghemawat 已提交
2820
  do {
L
Lei Jin 已提交
2821
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
2822 2823 2824 2825 2826
    ASSERT_OK(Put(1, "ka", "va"));
    ASSERT_OK(Put(1, "kb", "vb"));
    ASSERT_OK(Put(1, "kc", "vc"));
    ASSERT_OK(Delete(1, "kb"));
    ASSERT_EQ("NOT_FOUND", Get(1, "kb"));
2827 2828

    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
2829 2830
    iter->Seek("kc");
    ASSERT_EQ(IterStatus(iter), "kc->vc");
2831 2832
    if (!CurrentOptions().merge_operator) {
      // TODO: merge operator does not support backward iteration yet
2833 2834 2835 2836 2837 2838
      if (kPlainTableAllBytesPrefix != option_config_&&
          kBlockBasedTableWithWholeKeyHashIndex != option_config_ &&
          kHashLinkList != option_config_) {
        iter->Prev();
        ASSERT_EQ(IterStatus(iter), "ka->va");
      }
2839
    }
S
Sanjay Ghemawat 已提交
2840 2841
    delete iter;
  } while (ChangeOptions());
2842 2843
}

I
Igor Sugak 已提交
2844
TEST_F(DBTest, IterPrevMaxSkip) {
2845
  do {
L
Lei Jin 已提交
2846
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
2847
    for (int i = 0; i < 2; i++) {
2848 2849 2850 2851 2852
      ASSERT_OK(Put(1, "key1", "v1"));
      ASSERT_OK(Put(1, "key2", "v2"));
      ASSERT_OK(Put(1, "key3", "v3"));
      ASSERT_OK(Put(1, "key4", "v4"));
      ASSERT_OK(Put(1, "key5", "v5"));
2853 2854
    }

2855
    VerifyIterLast("key5->v5", 1);
2856

2857 2858
    ASSERT_OK(Delete(1, "key5"));
    VerifyIterLast("key4->v4", 1);
2859

2860 2861
    ASSERT_OK(Delete(1, "key4"));
    VerifyIterLast("key3->v3", 1);
2862

2863 2864
    ASSERT_OK(Delete(1, "key3"));
    VerifyIterLast("key2->v2", 1);
2865

2866 2867
    ASSERT_OK(Delete(1, "key2"));
    VerifyIterLast("key1->v1", 1);
2868

2869 2870
    ASSERT_OK(Delete(1, "key1"));
    VerifyIterLast("(invalid)", 1);
2871
  } while (ChangeOptions(kSkipMergePut | kSkipNoSeekToLast));
2872 2873
}

I
Igor Sugak 已提交
2874
TEST_F(DBTest, IterWithSnapshot) {
2875 2876
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
2877
  do {
2878
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions(options_override));
2879 2880 2881 2882 2883
    ASSERT_OK(Put(1, "key1", "val1"));
    ASSERT_OK(Put(1, "key2", "val2"));
    ASSERT_OK(Put(1, "key3", "val3"));
    ASSERT_OK(Put(1, "key4", "val4"));
    ASSERT_OK(Put(1, "key5", "val5"));
2884 2885 2886 2887

    const Snapshot *snapshot = db_->GetSnapshot();
    ReadOptions options;
    options.snapshot = snapshot;
2888
    Iterator* iter = db_->NewIterator(options, handles_[1]);
2889 2890

    // Put more values after the snapshot
2891 2892
    ASSERT_OK(Put(1, "key100", "val100"));
    ASSERT_OK(Put(1, "key101", "val101"));
2893 2894 2895 2896 2897

    iter->Seek("key5");
    ASSERT_EQ(IterStatus(iter), "key5->val5");
    if (!CurrentOptions().merge_operator) {
      // TODO: merge operator does not support backward iteration yet
2898 2899 2900 2901 2902 2903 2904
      if (kPlainTableAllBytesPrefix != option_config_&&
        kBlockBasedTableWithWholeKeyHashIndex != option_config_ &&
        kHashLinkList != option_config_) {
        iter->Prev();
        ASSERT_EQ(IterStatus(iter), "key4->val4");
        iter->Prev();
        ASSERT_EQ(IterStatus(iter), "key3->val3");
2905

2906 2907 2908 2909 2910
        iter->Next();
        ASSERT_EQ(IterStatus(iter), "key4->val4");
        iter->Next();
        ASSERT_EQ(IterStatus(iter), "key5->val5");
      }
2911 2912 2913 2914 2915
      iter->Next();
      ASSERT_TRUE(!iter->Valid());
    }
    db_->ReleaseSnapshot(snapshot);
    delete iter;
2916 2917
    // skip as HashCuckooRep does not support snapshot
  } while (ChangeOptions(kSkipHashCuckoo));
2918 2919
}

I
Igor Sugak 已提交
2920
TEST_F(DBTest, Recover) {
S
Sanjay Ghemawat 已提交
2921
  do {
L
Lei Jin 已提交
2922
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
2923 2924 2925
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Put(1, "baz", "v5"));

L
Lei Jin 已提交
2926
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
2927 2928 2929 2930 2931 2932 2933
    ASSERT_EQ("v1", Get(1, "foo"));

    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("v5", Get(1, "baz"));
    ASSERT_OK(Put(1, "bar", "v2"));
    ASSERT_OK(Put(1, "foo", "v3"));

L
Lei Jin 已提交
2934
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
2935 2936 2937 2938 2939
    ASSERT_EQ("v3", Get(1, "foo"));
    ASSERT_OK(Put(1, "foo", "v4"));
    ASSERT_EQ("v4", Get(1, "foo"));
    ASSERT_EQ("v2", Get(1, "bar"));
    ASSERT_EQ("v5", Get(1, "baz"));
S
Sanjay Ghemawat 已提交
2940
  } while (ChangeOptions());
J
jorlow@chromium.org 已提交
2941 2942
}

I
Igor Sugak 已提交
2943
TEST_F(DBTest, RecoverWithTableHandle) {
2944
  do {
2945
    Options options;
2946 2947 2948
    options.create_if_missing = true;
    options.write_buffer_size = 100;
    options.disable_auto_compactions = true;
2949
    options = CurrentOptions(options);
L
Lei Jin 已提交
2950
    DestroyAndReopen(options);
L
Lei Jin 已提交
2951
    CreateAndReopenWithCF({"pikachu"}, options);
2952

2953 2954 2955 2956 2957 2958 2959
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Put(1, "bar", "v2"));
    ASSERT_OK(Flush(1));
    ASSERT_OK(Put(1, "foo", "v3"));
    ASSERT_OK(Put(1, "bar", "v4"));
    ASSERT_OK(Flush(1));
    ASSERT_OK(Put(1, "big", std::string(100, 'a')));
L
Lei Jin 已提交
2960
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
2961 2962

    std::vector<std::vector<FileMetaData>> files;
2963
    dbfull()->TEST_GetFilesMetaData(handles_[1], &files);
2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980
    int total_files = 0;
    for (const auto& level : files) {
      total_files += level.size();
    }
    ASSERT_EQ(total_files, 3);
    for (const auto& level : files) {
      for (const auto& file : level) {
        if (kInfiniteMaxOpenFiles == option_config_) {
          ASSERT_TRUE(file.table_reader_handle != nullptr);
        } else {
          ASSERT_TRUE(file.table_reader_handle == nullptr);
        }
      }
    }
  } while (ChangeOptions());
}

I
Igor Sugak 已提交
2981
TEST_F(DBTest, IgnoreRecoveredLog) {
I
Igor Canadi 已提交
2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
  std::string backup_logs = dbname_ + "/backup_logs";

  // delete old files in backup_logs directory
  env_->CreateDirIfMissing(backup_logs);
  std::vector<std::string> old_files;
  env_->GetChildren(backup_logs, &old_files);
  for (auto& file : old_files) {
    if (file != "." && file != "..") {
      env_->DeleteFile(backup_logs + "/" + file);
    }
  }

  do {
    Options options = CurrentOptions();
    options.create_if_missing = true;
    options.merge_operator = MergeOperators::CreateUInt64AddOperator();
2998 2999
    options.wal_dir = dbname_ + "/logs";
    DestroyAndReopen(options);
I
Igor Canadi 已提交
3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018

    // fill up the DB
    std::string one, two;
    PutFixed64(&one, 1);
    PutFixed64(&two, 2);
    ASSERT_OK(db_->Merge(WriteOptions(), Slice("foo"), Slice(one)));
    ASSERT_OK(db_->Merge(WriteOptions(), Slice("foo"), Slice(one)));
    ASSERT_OK(db_->Merge(WriteOptions(), Slice("bar"), Slice(one)));

    // copy the logs to backup
    std::vector<std::string> logs;
    env_->GetChildren(options.wal_dir, &logs);
    for (auto& log : logs) {
      if (log != ".." && log != ".") {
        CopyFile(options.wal_dir + "/" + log, backup_logs + "/" + log);
      }
    }

    // recover the DB
L
Lei Jin 已提交
3019
    Reopen(options);
I
Igor Canadi 已提交
3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032
    ASSERT_EQ(two, Get("foo"));
    ASSERT_EQ(one, Get("bar"));
    Close();

    // copy the logs from backup back to wal dir
    for (auto& log : logs) {
      if (log != ".." && log != ".") {
        CopyFile(backup_logs + "/" + log, options.wal_dir + "/" + log);
      }
    }
    // this should ignore the log files, recovery should not happen again
    // if the recovery happens, the same merge operator would be called twice,
    // leading to incorrect results
L
Lei Jin 已提交
3033
    Reopen(options);
I
Igor Canadi 已提交
3034 3035 3036
    ASSERT_EQ(two, Get("foo"));
    ASSERT_EQ(one, Get("bar"));
    Close();
L
Lei Jin 已提交
3037
    Destroy(options);
L
Lei Jin 已提交
3038
    Reopen(options);
3039
    Close();
I
Igor Canadi 已提交
3040 3041 3042 3043 3044 3045 3046 3047 3048 3049

    // copy the logs from backup back to wal dir
    env_->CreateDirIfMissing(options.wal_dir);
    for (auto& log : logs) {
      if (log != ".." && log != ".") {
        CopyFile(backup_logs + "/" + log, options.wal_dir + "/" + log);
      }
    }
    // assert that we successfully recovered only from logs, even though we
    // destroyed the DB
L
Lei Jin 已提交
3050
    Reopen(options);
I
Igor Canadi 已提交
3051 3052
    ASSERT_EQ(two, Get("foo"));
    ASSERT_EQ(one, Get("bar"));
3053 3054

    // Recovery will fail if DB directory doesn't exist.
L
Lei Jin 已提交
3055
    Destroy(options);
3056 3057 3058 3059 3060 3061 3062 3063 3064
    // copy the logs from backup back to wal dir
    env_->CreateDirIfMissing(options.wal_dir);
    for (auto& log : logs) {
      if (log != ".." && log != ".") {
        CopyFile(backup_logs + "/" + log, options.wal_dir + "/" + log);
        // we won't be needing this file no more
        env_->DeleteFile(backup_logs + "/" + log);
      }
    }
L
Lei Jin 已提交
3065
    Status s = TryReopen(options);
3066
    ASSERT_TRUE(!s.ok());
3067
  } while (ChangeOptions(kSkipHashCuckoo));
I
Igor Canadi 已提交
3068 3069
}

I
Igor Sugak 已提交
3070
TEST_F(DBTest, RollLog) {
H
heyongqiang 已提交
3071
  do {
L
Lei Jin 已提交
3072
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
3073 3074
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Put(1, "baz", "v5"));
H
heyongqiang 已提交
3075

L
Lei Jin 已提交
3076
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
H
heyongqiang 已提交
3077
    for (int i = 0; i < 10; i++) {
L
Lei Jin 已提交
3078
      ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
H
heyongqiang 已提交
3079
    }
3080
    ASSERT_OK(Put(1, "foo", "v4"));
H
heyongqiang 已提交
3081
    for (int i = 0; i < 10; i++) {
L
Lei Jin 已提交
3082
      ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
H
heyongqiang 已提交
3083 3084 3085 3086
    }
  } while (ChangeOptions());
}

I
Igor Sugak 已提交
3087
TEST_F(DBTest, WAL) {
3088
  do {
L
Lei Jin 已提交
3089
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
3090 3091
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
3092 3093
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v1"));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v1"));
H
heyongqiang 已提交
3094

L
Lei Jin 已提交
3095
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
3096 3097
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("v1", Get(1, "bar"));
H
heyongqiang 已提交
3098

3099
    writeOpt.disableWAL = false;
3100
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v2"));
3101
    writeOpt.disableWAL = true;
3102
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v2"));
H
heyongqiang 已提交
3103

L
Lei Jin 已提交
3104
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
3105
    // Both value's should be present.
3106 3107
    ASSERT_EQ("v2", Get(1, "bar"));
    ASSERT_EQ("v2", Get(1, "foo"));
H
heyongqiang 已提交
3108

3109
    writeOpt.disableWAL = true;
3110
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v3"));
3111
    writeOpt.disableWAL = false;
3112
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v3"));
H
heyongqiang 已提交
3113

L
Lei Jin 已提交
3114
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
3115
    // again both values should be present.
3116 3117
    ASSERT_EQ("v3", Get(1, "foo"));
    ASSERT_EQ("v3", Get(1, "bar"));
3118
  } while (ChangeCompactOptions());
H
heyongqiang 已提交
3119 3120
}

I
Igor Sugak 已提交
3121
TEST_F(DBTest, CheckLock) {
3122 3123 3124
  do {
    DB* localdb;
    Options options = CurrentOptions();
L
Lei Jin 已提交
3125
    ASSERT_OK(TryReopen(options));
3126 3127

    // second open should fail
3128
    ASSERT_TRUE(!(DB::Open(options, dbname_, &localdb)).ok());
3129
  } while (ChangeCompactOptions());
3130 3131
}

I
Igor Sugak 已提交
3132
TEST_F(DBTest, FlushMultipleMemtable) {
3133 3134 3135 3136 3137 3138
  do {
    Options options = CurrentOptions();
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
    options.max_write_buffer_number = 4;
    options.min_write_buffer_number_to_merge = 3;
3139
    options.max_write_buffer_number_to_maintain = -1;
L
Lei Jin 已提交
3140
    CreateAndReopenWithCF({"pikachu"}, options);
3141 3142 3143 3144 3145 3146 3147
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v1"));
    ASSERT_OK(Flush(1));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v1"));

    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("v1", Get(1, "bar"));
    ASSERT_OK(Flush(1));
3148 3149 3150
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
3151
TEST_F(DBTest, NumImmutableMemTable) {
3152 3153 3154 3155 3156 3157
  do {
    Options options = CurrentOptions();
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
    options.max_write_buffer_number = 4;
    options.min_write_buffer_number_to_merge = 3;
3158
    options.max_write_buffer_number_to_maintain = 0;
3159
    options.write_buffer_size = 1000000;
L
Lei Jin 已提交
3160
    CreateAndReopenWithCF({"pikachu"}, options);
3161

3162
    std::string big_value(1000000 * 2, 'x');
3163
    std::string num;
3164
    SetPerfLevel(kEnableTime);;
3165
    ASSERT_TRUE(GetPerfLevel() == kEnableTime);
3166

3167 3168 3169
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k1", big_value));
    ASSERT_TRUE(dbfull()->GetProperty(handles_[1],
                                      "rocksdb.num-immutable-mem-table", &num));
3170
    ASSERT_EQ(num, "0");
3171 3172 3173
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ(num, "1");
3174
    perf_context.Reset();
3175
    Get(1, "k1");
3176
    ASSERT_EQ(1, (int) perf_context.get_from_memtable_count);
3177

3178 3179 3180
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k2", big_value));
    ASSERT_TRUE(dbfull()->GetProperty(handles_[1],
                                      "rocksdb.num-immutable-mem-table", &num));
3181
    ASSERT_EQ(num, "1");
3182 3183 3184 3185 3186 3187 3188
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ(num, "1");
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-imm-mem-tables", &num));
    ASSERT_EQ(num, "1");

3189
    perf_context.Reset();
3190
    Get(1, "k1");
3191 3192
    ASSERT_EQ(2, (int) perf_context.get_from_memtable_count);
    perf_context.Reset();
3193
    Get(1, "k2");
3194
    ASSERT_EQ(1, (int) perf_context.get_from_memtable_count);
3195

3196
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k3", big_value));
3197 3198
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.cur-size-active-mem-table", &num));
3199 3200
    ASSERT_TRUE(dbfull()->GetProperty(handles_[1],
                                      "rocksdb.num-immutable-mem-table", &num));
3201
    ASSERT_EQ(num, "2");
3202 3203 3204 3205 3206 3207
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &num));
    ASSERT_EQ(num, "1");
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.num-entries-imm-mem-tables", &num));
    ASSERT_EQ(num, "2");
3208
    perf_context.Reset();
3209
    Get(1, "k2");
3210 3211
    ASSERT_EQ(2, (int) perf_context.get_from_memtable_count);
    perf_context.Reset();
3212
    Get(1, "k3");
3213 3214
    ASSERT_EQ(1, (int) perf_context.get_from_memtable_count);
    perf_context.Reset();
3215
    Get(1, "k1");
3216
    ASSERT_EQ(3, (int) perf_context.get_from_memtable_count);
3217

3218 3219 3220
    ASSERT_OK(Flush(1));
    ASSERT_TRUE(dbfull()->GetProperty(handles_[1],
                                      "rocksdb.num-immutable-mem-table", &num));
3221
    ASSERT_EQ(num, "0");
3222 3223
    ASSERT_TRUE(dbfull()->GetProperty(
        handles_[1], "rocksdb.cur-size-active-mem-table", &num));
S
sdong 已提交
3224
    // "200" is the size of the metadata of an empty skiplist, this would
3225
    // break if we change the default skiplist implementation
S
sdong 已提交
3226
    ASSERT_EQ(num, "200");
3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255

    uint64_t int_num;
    uint64_t base_total_size;
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.estimate-num-keys", &base_total_size));

    ASSERT_OK(dbfull()->Delete(writeOpt, handles_[1], "k2"));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k3", ""));
    ASSERT_OK(dbfull()->Delete(writeOpt, handles_[1], "k3"));
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.num-deletes-active-mem-table", &int_num));
    ASSERT_EQ(int_num, 2U);
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.num-entries-active-mem-table", &int_num));
    ASSERT_EQ(int_num, 3U);

    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k2", big_value));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "k2", big_value));
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.num-entries-imm-mem-tables", &int_num));
    ASSERT_EQ(int_num, 4U);
    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.num-deletes-imm-mem-tables", &int_num));
    ASSERT_EQ(int_num, 2U);

    ASSERT_TRUE(dbfull()->GetIntProperty(
        handles_[1], "rocksdb.estimate-num-keys", &int_num));
    ASSERT_EQ(int_num, base_total_size + 1);

3256
    SetPerfLevel(kDisable);
3257
    ASSERT_TRUE(GetPerfLevel() == kDisable);
3258 3259 3260
  } while (ChangeCompactOptions());
}

3261 3262
class SleepingBackgroundTask {
 public:
I
Igor Canadi 已提交
3263 3264
  SleepingBackgroundTask()
      : bg_cv_(&mutex_), should_sleep_(true), done_with_sleep_(false) {}
3265 3266 3267 3268 3269
  void DoSleep() {
    MutexLock l(&mutex_);
    while (should_sleep_) {
      bg_cv_.Wait();
    }
I
Igor Canadi 已提交
3270 3271
    done_with_sleep_ = true;
    bg_cv_.SignalAll();
3272 3273 3274 3275 3276 3277
  }
  void WakeUp() {
    MutexLock l(&mutex_);
    should_sleep_ = false;
    bg_cv_.SignalAll();
  }
I
Igor Canadi 已提交
3278 3279 3280 3281 3282 3283
  void WaitUntilDone() {
    MutexLock l(&mutex_);
    while (!done_with_sleep_) {
      bg_cv_.Wait();
    }
  }
3284 3285 3286 3287 3288 3289 3290 3291 3292

  static void DoSleepTask(void* arg) {
    reinterpret_cast<SleepingBackgroundTask*>(arg)->DoSleep();
  }

 private:
  port::Mutex mutex_;
  port::CondVar bg_cv_;  // Signalled when background work finishes
  bool should_sleep_;
I
Igor Canadi 已提交
3293
  bool done_with_sleep_;
3294 3295
};

I
Igor Sugak 已提交
3296
TEST_F(DBTest, FlushEmptyColumnFamily) {
3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313
  // Block flush thread and disable compaction thread
  env_->SetBackgroundThreads(1, Env::HIGH);
  env_->SetBackgroundThreads(1, Env::LOW);
  SleepingBackgroundTask sleeping_task_low;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
                 Env::Priority::LOW);
  SleepingBackgroundTask sleeping_task_high;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_high,
                 Env::Priority::HIGH);

  Options options = CurrentOptions();
  // disable compaction
  options.disable_auto_compactions = true;
  WriteOptions writeOpt = WriteOptions();
  writeOpt.disableWAL = true;
  options.max_write_buffer_number = 2;
  options.min_write_buffer_number_to_merge = 1;
3314
  options.max_write_buffer_number_to_maintain = 1;
L
Lei Jin 已提交
3315
  CreateAndReopenWithCF({"pikachu"}, options);
3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339

  // Compaction can still go through even if no thread can flush the
  // mem table.
  ASSERT_OK(Flush(0));
  ASSERT_OK(Flush(1));

  // Insert can go through
  ASSERT_OK(dbfull()->Put(writeOpt, handles_[0], "foo", "v1"));
  ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v1"));

  ASSERT_EQ("v1", Get(0, "foo"));
  ASSERT_EQ("v1", Get(1, "bar"));

  sleeping_task_high.WakeUp();
  sleeping_task_high.WaitUntilDone();

  // Flush can still go through.
  ASSERT_OK(Flush(0));
  ASSERT_OK(Flush(1));

  sleeping_task_low.WakeUp();
  sleeping_task_low.WaitUntilDone();
}

I
Igor Sugak 已提交
3340
TEST_F(DBTest, GetProperty) {
3341 3342 3343
  // Set sizes to both background thread pool to be 1 and block them.
  env_->SetBackgroundThreads(1, Env::HIGH);
  env_->SetBackgroundThreads(1, Env::LOW);
I
Igor Canadi 已提交
3344
  SleepingBackgroundTask sleeping_task_low;
3345 3346
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
                 Env::Priority::LOW);
I
Igor Canadi 已提交
3347
  SleepingBackgroundTask sleeping_task_high;
3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_high,
                 Env::Priority::HIGH);

  Options options = CurrentOptions();
  WriteOptions writeOpt = WriteOptions();
  writeOpt.disableWAL = true;
  options.compaction_style = kCompactionStyleUniversal;
  options.level0_file_num_compaction_trigger = 1;
  options.compaction_options_universal.size_ratio = 50;
  options.max_background_compactions = 1;
  options.max_background_flushes = 1;
  options.max_write_buffer_number = 10;
  options.min_write_buffer_number_to_merge = 1;
3361
  options.max_write_buffer_number_to_maintain = 0;
3362
  options.write_buffer_size = 1000000;
L
Lei Jin 已提交
3363
  Reopen(options);
3364 3365 3366

  std::string big_value(1000000 * 2, 'x');
  std::string num;
3367
  uint64_t int_num;
3368 3369
  SetPerfLevel(kEnableTime);

3370 3371 3372 3373
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_EQ(int_num, 0U);

3374 3375 3376 3377 3378 3379 3380
  ASSERT_OK(dbfull()->Put(writeOpt, "k1", big_value));
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
  ASSERT_EQ(num, "0");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.mem-table-flush-pending", &num));
  ASSERT_EQ(num, "0");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.compaction-pending", &num));
  ASSERT_EQ(num, "0");
S
sdong 已提交
3381 3382
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.estimate-num-keys", &num));
  ASSERT_EQ(num, "1");
3383 3384 3385 3386 3387
  perf_context.Reset();

  ASSERT_OK(dbfull()->Put(writeOpt, "k2", big_value));
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
  ASSERT_EQ(num, "1");
S
sdong 已提交
3388
  ASSERT_OK(dbfull()->Delete(writeOpt, "k-non-existing"));
3389 3390 3391 3392 3393 3394 3395
  ASSERT_OK(dbfull()->Put(writeOpt, "k3", big_value));
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.num-immutable-mem-table", &num));
  ASSERT_EQ(num, "2");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.mem-table-flush-pending", &num));
  ASSERT_EQ(num, "1");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.compaction-pending", &num));
  ASSERT_EQ(num, "0");
S
sdong 已提交
3396
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.estimate-num-keys", &num));
3397
  ASSERT_EQ(num, "2");
3398 3399 3400 3401 3402 3403 3404 3405
  // Verify the same set of properties through GetIntProperty
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.num-immutable-mem-table", &int_num));
  ASSERT_EQ(int_num, 2U);
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.mem-table-flush-pending", &int_num));
  ASSERT_EQ(int_num, 1U);
  ASSERT_TRUE(dbfull()->GetIntProperty("rocksdb.compaction-pending", &int_num));
3406
  ASSERT_EQ(int_num, 0U);
3407
  ASSERT_TRUE(dbfull()->GetIntProperty("rocksdb.estimate-num-keys", &int_num));
3408
  ASSERT_EQ(int_num, 2U);
3409

3410 3411 3412 3413
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_EQ(int_num, 0U);

3414
  sleeping_task_high.WakeUp();
I
Igor Canadi 已提交
3415
  sleeping_task_high.WaitUntilDone();
3416 3417 3418 3419 3420 3421 3422 3423 3424
  dbfull()->TEST_WaitForFlushMemTable();

  ASSERT_OK(dbfull()->Put(writeOpt, "k4", big_value));
  ASSERT_OK(dbfull()->Put(writeOpt, "k5", big_value));
  dbfull()->TEST_WaitForFlushMemTable();
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.mem-table-flush-pending", &num));
  ASSERT_EQ(num, "0");
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.compaction-pending", &num));
  ASSERT_EQ(num, "1");
S
sdong 已提交
3425 3426
  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.estimate-num-keys", &num));
  ASSERT_EQ(num, "4");
3427 3428 3429 3430 3431

  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_GT(int_num, 0U);

3432
  sleeping_task_low.WakeUp();
I
Igor Canadi 已提交
3433
  sleeping_task_low.WaitUntilDone();
3434 3435 3436

  dbfull()->TEST_WaitForFlushMemTable();
  options.max_open_files = 10;
L
Lei Jin 已提交
3437
  Reopen(options);
3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449
  // After reopening, no table reader is loaded, so no memory for table readers
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_EQ(int_num, 0U);
  ASSERT_TRUE(dbfull()->GetIntProperty("rocksdb.estimate-num-keys", &int_num));
  ASSERT_GT(int_num, 0U);

  // After reading a key, at least one table reader is loaded.
  Get("k5");
  ASSERT_TRUE(
      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
  ASSERT_GT(int_num, 0U);
3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486

  // Test rocksdb.num-live-versions
  {
    options.level0_file_num_compaction_trigger = 20;
    Reopen(options);
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 1U);

    // Use an iterator to hold current version
    std::unique_ptr<Iterator> iter1(dbfull()->NewIterator(ReadOptions()));

    ASSERT_OK(dbfull()->Put(writeOpt, "k6", big_value));
    Flush();
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 2U);

    // Use an iterator to hold current version
    std::unique_ptr<Iterator> iter2(dbfull()->NewIterator(ReadOptions()));

    ASSERT_OK(dbfull()->Put(writeOpt, "k7", big_value));
    Flush();
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 3U);

    iter2.reset();
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 2U);

    iter1.reset();
    ASSERT_TRUE(
        dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
    ASSERT_EQ(int_num, 1U);
  }
3487 3488
}

I
Igor Sugak 已提交
3489
TEST_F(DBTest, FLUSH) {
3490
  do {
L
Lei Jin 已提交
3491
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
3492 3493
    WriteOptions writeOpt = WriteOptions();
    writeOpt.disableWAL = true;
3494
    SetPerfLevel(kEnableTime);;
3495
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v1"));
3496
    // this will now also flush the last 2 writes
3497 3498
    ASSERT_OK(Flush(1));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v1"));
H
heyongqiang 已提交
3499

3500
    perf_context.Reset();
3501
    Get(1, "foo");
3502 3503
    ASSERT_TRUE((int) perf_context.get_from_output_files_time > 0);

L
Lei Jin 已提交
3504
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
3505
    ASSERT_EQ("v1", Get(1, "foo"));
3506
    ASSERT_EQ("v1", Get(1, "bar"));
H
heyongqiang 已提交
3507

3508
    writeOpt.disableWAL = true;
3509 3510 3511
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v2"));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v2"));
    ASSERT_OK(Flush(1));
H
heyongqiang 已提交
3512

L
Lei Jin 已提交
3513
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
3514
    ASSERT_EQ("v2", Get(1, "bar"));
3515
    perf_context.Reset();
3516
    ASSERT_EQ("v2", Get(1, "foo"));
3517
    ASSERT_TRUE((int) perf_context.get_from_output_files_time > 0);
H
heyongqiang 已提交
3518

3519
    writeOpt.disableWAL = false;
3520 3521 3522
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "bar", "v3"));
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v3"));
    ASSERT_OK(Flush(1));
H
heyongqiang 已提交
3523

L
Lei Jin 已提交
3524
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
3525 3526
    // 'foo' should be there because its put
    // has WAL enabled.
3527 3528
    ASSERT_EQ("v3", Get(1, "foo"));
    ASSERT_EQ("v3", Get(1, "bar"));
3529 3530

    SetPerfLevel(kDisable);
3531
  } while (ChangeCompactOptions());
H
heyongqiang 已提交
3532 3533
}

I
Igor Sugak 已提交
3534
TEST_F(DBTest, RecoveryWithEmptyLog) {
S
Sanjay Ghemawat 已提交
3535
  do {
L
Lei Jin 已提交
3536
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
3537 3538
    ASSERT_OK(Put(1, "foo", "v1"));
    ASSERT_OK(Put(1, "foo", "v2"));
L
Lei Jin 已提交
3539 3540
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
3541
    ASSERT_OK(Put(1, "foo", "v3"));
L
Lei Jin 已提交
3542
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
3543
    ASSERT_EQ("v3", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
3544
  } while (ChangeOptions());
J
jorlow@chromium.org 已提交
3545 3546
}

3547 3548
// Check that writes done during a memtable compaction are recovered
// if the database is shutdown during the memtable compaction.
I
Igor Sugak 已提交
3549
TEST_F(DBTest, RecoverDuringMemtableCompaction) {
S
Sanjay Ghemawat 已提交
3550
  do {
3551
    Options options;
S
Sanjay Ghemawat 已提交
3552 3553
    options.env = env_;
    options.write_buffer_size = 1000000;
3554
    options = CurrentOptions(options);
L
Lei Jin 已提交
3555
    CreateAndReopenWithCF({"pikachu"}, options);
3556

S
Sanjay Ghemawat 已提交
3557
    // Trigger a long memtable compaction and reopen the database during it
3558 3559 3560 3561 3562
    ASSERT_OK(Put(1, "foo", "v1"));  // Goes to 1st log file
    ASSERT_OK(Put(1, "big1", std::string(10000000, 'x')));  // Fills memtable
    ASSERT_OK(Put(1, "big2", std::string(1000, 'y')));  // Triggers compaction
    ASSERT_OK(Put(1, "bar", "v2"));                     // Goes to new log file

L
Lei Jin 已提交
3563
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
3564 3565 3566 3567
    ASSERT_EQ("v1", Get(1, "foo"));
    ASSERT_EQ("v2", Get(1, "bar"));
    ASSERT_EQ(std::string(10000000, 'x'), Get(1, "big1"));
    ASSERT_EQ(std::string(1000, 'y'), Get(1, "big2"));
S
Sanjay Ghemawat 已提交
3568
  } while (ChangeOptions());
3569 3570
}

3571 3572 3573
// false positive TSAN report on shared_ptr --
// https://groups.google.com/forum/#!topic/thread-sanitizer/vz_s-t226Vg
#ifndef ROCKSDB_TSAN_RUN
I
Igor Sugak 已提交
3574
TEST_F(DBTest, FlushSchedule) {
I
Igor Canadi 已提交
3575 3576 3577 3578 3579
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.level0_stop_writes_trigger = 1 << 10;
  options.level0_slowdown_writes_trigger = 1 << 10;
  options.min_write_buffer_number_to_merge = 1;
3580
  options.max_write_buffer_number_to_maintain = 1;
I
Igor Canadi 已提交
3581 3582
  options.max_write_buffer_number = 2;
  options.write_buffer_size = 100 * 1000;
L
Lei Jin 已提交
3583
  CreateAndReopenWithCF({"pikachu"}, options);
I
Igor Canadi 已提交
3584 3585
  std::vector<std::thread> threads;

I
Igor Canadi 已提交
3586
  std::atomic<int> thread_num(0);
I
Igor Canadi 已提交
3587 3588 3589 3590 3591 3592
  // each column family will have 5 thread, each thread generating 2 memtables.
  // each column family should end up with 10 table files
  for (int i = 0; i < 10; ++i) {
    threads.emplace_back([&]() {
      int a = thread_num.fetch_add(1);
      Random rnd(a);
I
Igor Canadi 已提交
3593
      WriteOptions wo;
I
Igor Canadi 已提交
3594 3595
      // this should fill up 2 memtables
      for (int k = 0; k < 5000; ++k) {
I
Igor Canadi 已提交
3596
        ASSERT_OK(db_->Put(wo, handles_[a & 1], RandomString(&rnd, 13), ""));
I
Igor Canadi 已提交
3597 3598 3599 3600 3601 3602 3603 3604
      }
    });
  }

  for (auto& t : threads) {
    t.join();
  }

I
Igor Canadi 已提交
3605 3606 3607 3608 3609 3610
  auto default_tables = GetNumberOfSstFilesForColumnFamily(db_, "default");
  auto pikachu_tables = GetNumberOfSstFilesForColumnFamily(db_, "pikachu");
  ASSERT_LE(default_tables, static_cast<uint64_t>(10));
  ASSERT_GT(default_tables, static_cast<uint64_t>(0));
  ASSERT_LE(pikachu_tables, static_cast<uint64_t>(10));
  ASSERT_GT(pikachu_tables, static_cast<uint64_t>(0));
I
Igor Canadi 已提交
3611
}
3612
#endif  // enabled only if not TSAN run
I
Igor Canadi 已提交
3613

I
Igor Sugak 已提交
3614
TEST_F(DBTest, MinorCompactionsHappen) {
3615
  do {
3616
    Options options;
3617
    options.write_buffer_size = 10000;
3618
    options = CurrentOptions(options);
L
Lei Jin 已提交
3619
    CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
3620

3621
    const int N = 500;
J
jorlow@chromium.org 已提交
3622

3623
    int starting_num_tables = TotalTableFiles(1);
3624
    for (int i = 0; i < N; i++) {
3625
      ASSERT_OK(Put(1, Key(i), Key(i) + std::string(1000, 'v')));
3626
    }
3627
    int ending_num_tables = TotalTableFiles(1);
3628
    ASSERT_GT(ending_num_tables, starting_num_tables);
J
jorlow@chromium.org 已提交
3629

3630
    for (int i = 0; i < N; i++) {
3631
      ASSERT_EQ(Key(i) + std::string(1000, 'v'), Get(1, Key(i)));
3632
    }
J
jorlow@chromium.org 已提交
3633

L
Lei Jin 已提交
3634
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
J
jorlow@chromium.org 已提交
3635

3636
    for (int i = 0; i < N; i++) {
3637
      ASSERT_EQ(Key(i) + std::string(1000, 'v'), Get(1, Key(i)));
3638 3639
    }
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
3640 3641
}

I
Igor Sugak 已提交
3642
TEST_F(DBTest, ManifestRollOver) {
3643
  do {
3644
    Options options;
3645
    options.max_manifest_file_size = 10 ;  // 10 bytes
3646
    options = CurrentOptions(options);
L
Lei Jin 已提交
3647
    CreateAndReopenWithCF({"pikachu"}, options);
3648
    {
3649 3650 3651 3652 3653 3654
      ASSERT_OK(Put(1, "manifest_key1", std::string(1000, '1')));
      ASSERT_OK(Put(1, "manifest_key2", std::string(1000, '2')));
      ASSERT_OK(Put(1, "manifest_key3", std::string(1000, '3')));
      uint64_t manifest_before_flush = dbfull()->TEST_Current_Manifest_FileNo();
      ASSERT_OK(Flush(1));  // This should trigger LogAndApply.
      uint64_t manifest_after_flush = dbfull()->TEST_Current_Manifest_FileNo();
M
Mayank Agarwal 已提交
3655
      ASSERT_GT(manifest_after_flush, manifest_before_flush);
L
Lei Jin 已提交
3656
      ReopenWithColumnFamilies({"default", "pikachu"}, options);
3657
      ASSERT_GT(dbfull()->TEST_Current_Manifest_FileNo(), manifest_after_flush);
3658
      // check if a new manifest file got inserted or not.
3659 3660 3661
      ASSERT_EQ(std::string(1000, '1'), Get(1, "manifest_key1"));
      ASSERT_EQ(std::string(1000, '2'), Get(1, "manifest_key2"));
      ASSERT_EQ(std::string(1000, '3'), Get(1, "manifest_key3"));
3662 3663
    }
  } while (ChangeCompactOptions());
A
Abhishek Kona 已提交
3664 3665
}

I
Igor Sugak 已提交
3666
TEST_F(DBTest, IdentityAcrossRestarts) {
M
Mayank Agarwal 已提交
3667
  do {
3668 3669
    std::string id1;
    ASSERT_OK(db_->GetDbIdentity(id1));
M
Mayank Agarwal 已提交
3670 3671

    Options options = CurrentOptions();
L
Lei Jin 已提交
3672
    Reopen(options);
3673 3674
    std::string id2;
    ASSERT_OK(db_->GetDbIdentity(id2));
M
Mayank Agarwal 已提交
3675
    // id1 should match id2 because identity was not regenerated
3676
    ASSERT_EQ(id1.compare(id2), 0);
M
Mayank Agarwal 已提交
3677

3678
    std::string idfilename = IdentityFileName(dbname_);
M
Mayank Agarwal 已提交
3679
    ASSERT_OK(env_->DeleteFile(idfilename));
L
Lei Jin 已提交
3680
    Reopen(options);
3681 3682 3683 3684
    std::string id3;
    ASSERT_OK(db_->GetDbIdentity(id3));
    // id1 should NOT match id3 because identity was regenerated
    ASSERT_NE(id1.compare(id3), 0);
M
Mayank Agarwal 已提交
3685 3686 3687
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
3688
TEST_F(DBTest, RecoverWithLargeLog) {
3689 3690 3691
  do {
    {
      Options options = CurrentOptions();
L
Lei Jin 已提交
3692
      CreateAndReopenWithCF({"pikachu"}, options);
3693 3694 3695 3696 3697
      ASSERT_OK(Put(1, "big1", std::string(200000, '1')));
      ASSERT_OK(Put(1, "big2", std::string(200000, '2')));
      ASSERT_OK(Put(1, "small3", std::string(10, '3')));
      ASSERT_OK(Put(1, "small4", std::string(10, '4')));
      ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
3698 3699 3700 3701
    }

    // Make sure that if we re-open with a small write buffer size that
    // we flush table files in the middle of a large log file.
3702
    Options options;
3703
    options.write_buffer_size = 100000;
3704
    options = CurrentOptions(options);
L
Lei Jin 已提交
3705
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
3706 3707 3708 3709 3710 3711
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 3);
    ASSERT_EQ(std::string(200000, '1'), Get(1, "big1"));
    ASSERT_EQ(std::string(200000, '2'), Get(1, "big2"));
    ASSERT_EQ(std::string(10, '3'), Get(1, "small3"));
    ASSERT_EQ(std::string(10, '4'), Get(1, "small4"));
    ASSERT_GT(NumTableFilesAtLevel(0, 1), 1);
3712
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
3713 3714
}

I
Igor Sugak 已提交
3715
TEST_F(DBTest, CompactionsGenerateMultipleFiles) {
3716
  Options options;
J
jorlow@chromium.org 已提交
3717
  options.write_buffer_size = 100000000;        // Large write buffer
3718
  options = CurrentOptions(options);
L
Lei Jin 已提交
3719
  CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
3720 3721 3722 3723

  Random rnd(301);

  // Write 8MB (80 values, each 100K)
3724
  ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
J
jorlow@chromium.org 已提交
3725 3726 3727
  std::vector<std::string> values;
  for (int i = 0; i < 80; i++) {
    values.push_back(RandomString(&rnd, 100000));
3728
    ASSERT_OK(Put(1, Key(i), values[i]));
J
jorlow@chromium.org 已提交
3729 3730 3731
  }

  // Reopening moves updates to level-0
L
Lei Jin 已提交
3732
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
3733 3734
  dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1],
                              true /* disallow trivial move */);
J
jorlow@chromium.org 已提交
3735

3736 3737
  ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
  ASSERT_GT(NumTableFilesAtLevel(1, 1), 1);
J
jorlow@chromium.org 已提交
3738
  for (int i = 0; i < 80; i++) {
3739
    ASSERT_EQ(Get(1, Key(i)), values[i]);
J
jorlow@chromium.org 已提交
3740 3741 3742
  }
}

3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775
TEST_F(DBTest, TrivialMoveOneFile) {
  int32_t trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options;
  options.write_buffer_size = 100000000;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  int32_t num_keys = 80;
  int32_t value_size = 100 * 1024;  // 100 KB

  Random rnd(301);
  std::vector<std::string> values;
  for (int i = 0; i < num_keys; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }

  // Reopening moves updates to L0
  Reopen(options);
  ASSERT_EQ(NumTableFilesAtLevel(0, 0), 1);  // 1 file in L0
  ASSERT_EQ(NumTableFilesAtLevel(1, 0), 0);  // 0 files in L1

  std::vector<LiveFileMetaData> metadata;
  db_->GetLiveFilesMetaData(&metadata);
  ASSERT_EQ(metadata.size(), 1U);
  LiveFileMetaData level0_file = metadata[0];  // L0 file meta

  // Compaction will initiate a trivial move from L0 to L1
3776
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840

  // File moved From L0 to L1
  ASSERT_EQ(NumTableFilesAtLevel(0, 0), 0);  // 0 files in L0
  ASSERT_EQ(NumTableFilesAtLevel(1, 0), 1);  // 1 file in L1

  metadata.clear();
  db_->GetLiveFilesMetaData(&metadata);
  ASSERT_EQ(metadata.size(), 1U);
  ASSERT_EQ(metadata[0].name /* level1_file.name */, level0_file.name);
  ASSERT_EQ(metadata[0].size /* level1_file.size */, level0_file.size);

  for (int i = 0; i < num_keys; i++) {
    ASSERT_EQ(Get(Key(i)), values[i]);
  }

  ASSERT_EQ(trivial_move, 1);
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

TEST_F(DBTest, TrivialMoveNonOverlappingFiles) {
  int32_t trivial_move = 0;
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.write_buffer_size = 10 * 1024 * 1024;

  DestroyAndReopen(options);
  // non overlapping ranges
  std::vector<std::pair<int32_t, int32_t>> ranges = {
    {100, 199},
    {300, 399},
    {0, 99},
    {200, 299},
    {600, 699},
    {400, 499},
    {500, 550},
    {551, 599},
  };
  int32_t value_size = 10 * 1024;  // 10 KB

  Random rnd(301);
  std::map<int32_t, std::string> values;
  for (uint32_t i = 0; i < ranges.size(); i++) {
    for (int32_t j = ranges[i].first; j <= ranges[i].second; j++) {
      values[j] = RandomString(&rnd, value_size);
      ASSERT_OK(Put(Key(j), values[j]));
    }
    ASSERT_OK(Flush());
  }

  int32_t level0_files = NumTableFilesAtLevel(0, 0);
  ASSERT_EQ(level0_files, ranges.size());    // Multiple files in L0
  ASSERT_EQ(NumTableFilesAtLevel(1, 0), 0);  // No files in L1

  // Since data is non-overlapping we expect compaction to initiate
  // a trivial move
3841
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877
  // We expect that all the files were trivially moved from L0 to L1
  ASSERT_EQ(NumTableFilesAtLevel(0, 0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1, 0) /* level1_files */, level0_files);

  for (uint32_t i = 0; i < ranges.size(); i++) {
    for (int32_t j = ranges[i].first; j <= ranges[i].second; j++) {
      ASSERT_EQ(Get(Key(j)), values[j]);
    }
  }

  ASSERT_EQ(trivial_move, 1);
  ASSERT_EQ(non_trivial_move, 0);

  trivial_move = 0;
  non_trivial_move = 0;
  values.clear();
  DestroyAndReopen(options);
  // Same ranges as above but overlapping
  ranges = {
    {100, 199},
    {300, 399},
    {0, 99},
    {200, 299},
    {600, 699},
    {400, 499},
    {500, 560},  // this range overlap with the next one
    {551, 599},
  };
  for (uint32_t i = 0; i < ranges.size(); i++) {
    for (int32_t j = ranges[i].first; j <= ranges[i].second; j++) {
      values[j] = RandomString(&rnd, value_size);
      ASSERT_OK(Put(Key(j), values[j]));
    }
    ASSERT_OK(Flush());
  }

3878
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890

  for (uint32_t i = 0; i < ranges.size(); i++) {
    for (int32_t j = ranges[i].first; j <= ranges[i].second; j++) {
      ASSERT_EQ(Get(Key(j)), values[j]);
    }
  }
  ASSERT_EQ(trivial_move, 0);
  ASSERT_EQ(non_trivial_move, 1);

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929
TEST_F(DBTest, TrivialMoveTargetLevel) {
  int32_t trivial_move = 0;
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.write_buffer_size = 10 * 1024 * 1024;
  options.num_levels = 7;

  DestroyAndReopen(options);
  int32_t value_size = 10 * 1024;  // 10 KB

  // Add 2 non-overlapping files
  Random rnd(301);
  std::map<int32_t, std::string> values;

  // file 1 [0 => 300]
  for (int32_t i = 0; i <= 300; i++) {
    values[i] = RandomString(&rnd, value_size);
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  // file 2 [600 => 700]
  for (int32_t i = 600; i <= 700; i++) {
    values[i] = RandomString(&rnd, value_size);
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  // 2 files in L0
  ASSERT_EQ("2", FilesPerLevel(0));
3930 3931 3932 3933
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 6;
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947
  // 2 files in L6
  ASSERT_EQ("0,0,0,0,0,0,2", FilesPerLevel(0));

  ASSERT_EQ(trivial_move, 1);
  ASSERT_EQ(non_trivial_move, 0);

  for (int32_t i = 0; i <= 300; i++) {
    ASSERT_EQ(Get(Key(i)), values[i]);
  }
  for (int32_t i = 600; i <= 700; i++) {
    ASSERT_EQ(Get(Key(i)), values[i]);
  }
}

3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005
TEST_F(DBTest, TrivialMoveToLastLevelWithFiles) {
  int32_t trivial_move = 0;
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options;
  options.write_buffer_size = 100000000;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  int32_t value_size = 10 * 1024;  // 10 KB

  Random rnd(301);
  std::vector<std::string> values;
  // File with keys [ 0 => 99 ]
  for (int i = 0; i < 100; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1", FilesPerLevel(0));
  // Compaction will do L0=>L1 (trivial move) then move L1 files to L3
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 3;
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
  ASSERT_EQ("0,0,0,1", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 1);
  ASSERT_EQ(non_trivial_move, 0);

  // File with keys [ 100 => 199 ]
  for (int i = 100; i < 200; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1,0,0,1", FilesPerLevel(0));
  // Compaction will do L0=>L1 L1=>L2 L2=>L3 (3 trivial moves)
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
  ASSERT_EQ("0,0,0,2", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 4);
  ASSERT_EQ(non_trivial_move, 0);

  for (int i = 0; i < 200; i++) {
    ASSERT_EQ(Get(Key(i)), values[i]);
  }

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

I
Igor Sugak 已提交
4006
TEST_F(DBTest, CompactionTrigger) {
4007
  Options options;
4008 4009 4010 4011
  options.write_buffer_size = 100<<10; //100KB
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  options.level0_file_num_compaction_trigger = 3;
4012
  options = CurrentOptions(options);
L
Lei Jin 已提交
4013
  CreateAndReopenWithCF({"pikachu"}, options);
4014 4015 4016

  Random rnd(301);

4017
  for (int num = 0; num < options.level0_file_num_compaction_trigger - 1;
4018
       num++) {
4019 4020 4021 4022
    std::vector<std::string> values;
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      values.push_back(RandomString(&rnd, 10000));
4023
      ASSERT_OK(Put(1, Key(i), values[i]));
4024
    }
4025 4026
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), num + 1);
4027 4028 4029 4030 4031 4032
  }

  //generate one more file in level-0, and should trigger level-0 compaction
  std::vector<std::string> values;
  for (int i = 0; i < 12; i++) {
    values.push_back(RandomString(&rnd, 10000));
4033
    ASSERT_OK(Put(1, Key(i), values[i]));
4034 4035 4036
  }
  dbfull()->TEST_WaitForCompact();

4037 4038
  ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1, 1), 1);
4039 4040
}

4041 4042 4043 4044 4045 4046 4047 4048 4049
namespace {
static const int kCDTValueSize = 1000;
static const int kCDTKeysPerBuffer = 4;
static const int kCDTNumLevels = 8;
Options DeletionTriggerOptions() {
  Options options;
  options.compression = kNoCompression;
  options.write_buffer_size = kCDTKeysPerBuffer * (kCDTValueSize + 24);
  options.min_write_buffer_number_to_merge = 1;
4050
  options.max_write_buffer_number_to_maintain = 0;
4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063
  options.num_levels = kCDTNumLevels;
  options.max_mem_compaction_level = 0;
  options.level0_file_num_compaction_trigger = 1;
  options.target_file_size_base = options.write_buffer_size * 2;
  options.target_file_size_multiplier = 2;
  options.max_bytes_for_level_base =
      options.target_file_size_base * options.target_file_size_multiplier;
  options.max_bytes_for_level_multiplier = 2;
  options.disable_auto_compactions = false;
  return options;
}
}  // anonymous namespace

I
Igor Sugak 已提交
4064
TEST_F(DBTest, CompactionDeletionTrigger) {
4065 4066
  for (int tid = 0; tid < 2; ++tid) {
    uint64_t db_size[2];
4067 4068 4069 4070 4071 4072 4073
    Options options = CurrentOptions(DeletionTriggerOptions());

    if (tid == 1) {
      // second pass with universal compaction
      options.compaction_style = kCompactionStyleUniversal;
      options.num_levels = 1;
    }
4074

L
Lei Jin 已提交
4075
    DestroyAndReopen(options);
4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099
    Random rnd(301);

    const int kTestSize = kCDTKeysPerBuffer * 512;
    std::vector<std::string> values;
    for (int k = 0; k < kTestSize; ++k) {
      values.push_back(RandomString(&rnd, kCDTValueSize));
      ASSERT_OK(Put(Key(k), values[k]));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
    db_size[0] = Size(Key(0), Key(kTestSize - 1));

    for (int k = 0; k < kTestSize; ++k) {
      ASSERT_OK(Delete(Key(k)));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
    db_size[1] = Size(Key(0), Key(kTestSize - 1));

    // must have much smaller db size.
    ASSERT_GT(db_size[0] / 3, db_size[1]);
  }
}

I
Igor Sugak 已提交
4100
TEST_F(DBTest, CompactionDeletionTriggerReopen) {
4101 4102
  for (int tid = 0; tid < 2; ++tid) {
    uint64_t db_size[3];
4103
    Options options = CurrentOptions(DeletionTriggerOptions());
4104

4105 4106 4107 4108 4109 4110
    if (tid == 1) {
      // second pass with universal compaction
      options.compaction_style = kCompactionStyleUniversal;
      options.num_levels = 1;
    }

L
Lei Jin 已提交
4111
    DestroyAndReopen(options);
4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128
    Random rnd(301);

    // round 1 --- insert key/value pairs.
    const int kTestSize = kCDTKeysPerBuffer * 512;
    std::vector<std::string> values;
    for (int k = 0; k < kTestSize; ++k) {
      values.push_back(RandomString(&rnd, kCDTValueSize));
      ASSERT_OK(Put(Key(k), values[k]));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
    db_size[0] = Size(Key(0), Key(kTestSize - 1));
    Close();

    // round 2 --- disable auto-compactions and issue deletions.
    options.create_if_missing = false;
    options.disable_auto_compactions = true;
L
Lei Jin 已提交
4129
    Reopen(options);
4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142

    for (int k = 0; k < kTestSize; ++k) {
      ASSERT_OK(Delete(Key(k)));
    }
    db_size[1] = Size(Key(0), Key(kTestSize - 1));
    Close();
    // as auto_compaction is off, we shouldn't see too much reduce
    // in db size.
    ASSERT_LT(db_size[0] / 3, db_size[1]);

    // round 3 --- reopen db with auto_compaction on and see if
    // deletion compensation still work.
    options.disable_auto_compactions = false;
L
Lei Jin 已提交
4143
    Reopen(options);
4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155
    // insert relatively small amount of data to trigger auto compaction.
    for (int k = 0; k < kTestSize / 10; ++k) {
      ASSERT_OK(Put(Key(k), values[k]));
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
    db_size[2] = Size(Key(0), Key(kTestSize - 1));
    // this time we're expecting significant drop in size.
    ASSERT_GT(db_size[0] / 3, db_size[2]);
  }
}

4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184
// This is a static filter used for filtering
// kvs during the compaction process.
static int cfilter_count;
static std::string NEW_VALUE = "NewValue";

class KeepFilter : public CompactionFilter {
 public:
  virtual bool Filter(int level, const Slice& key, const Slice& value,
                      std::string* new_value, bool* value_changed) const
      override {
    cfilter_count++;
    return false;
  }

  virtual const char* Name() const override { return "KeepFilter"; }
};

class DeleteFilter : public CompactionFilter {
 public:
  virtual bool Filter(int level, const Slice& key, const Slice& value,
                      std::string* new_value, bool* value_changed) const
      override {
    cfilter_count++;
    return true;
  }

  virtual const char* Name() const override { return "DeleteFilter"; }
};

4185 4186 4187 4188 4189 4190
class DelayFilter : public CompactionFilter {
 public:
  explicit DelayFilter(DBTest* d) : db_test(d) {}
  virtual bool Filter(int level, const Slice& key, const Slice& value,
                      std::string* new_value,
                      bool* value_changed) const override {
S
sdong 已提交
4191
    db_test->env_->addon_time_.fetch_add(1000);
4192 4193 4194 4195 4196 4197 4198 4199 4200
    return true;
  }

  virtual const char* Name() const override { return "DelayFilter"; }

 private:
  DBTest* db_test;
};

4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216
class ConditionalFilter : public CompactionFilter {
 public:
  explicit ConditionalFilter(const std::string* filtered_value)
      : filtered_value_(filtered_value) {}
  virtual bool Filter(int level, const Slice& key, const Slice& value,
                      std::string* new_value,
                      bool* value_changed) const override {
    return value.ToString() == *filtered_value_;
  }

  virtual const char* Name() const override { return "ConditionalFilter"; }

 private:
  const std::string* filtered_value_;
};

4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238
class ChangeFilter : public CompactionFilter {
 public:
  explicit ChangeFilter() {}

  virtual bool Filter(int level, const Slice& key, const Slice& value,
                      std::string* new_value, bool* value_changed) const
      override {
    assert(new_value != nullptr);
    *new_value = NEW_VALUE;
    *value_changed = true;
    return false;
  }

  virtual const char* Name() const override { return "ChangeFilter"; }
};

class KeepFilterFactory : public CompactionFilterFactory {
 public:
  explicit KeepFilterFactory(bool check_context = false)
      : check_context_(check_context) {}

  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
4239
      const CompactionFilter::Context& context) override {
4240
    if (check_context_) {
4241 4242
      EXPECT_EQ(expect_full_compaction_.load(), context.is_full_compaction);
      EXPECT_EQ(expect_manual_compaction_.load(), context.is_manual_compaction);
4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255
    }
    return std::unique_ptr<CompactionFilter>(new KeepFilter());
  }

  virtual const char* Name() const override { return "KeepFilterFactory"; }
  bool check_context_;
  std::atomic_bool expect_full_compaction_;
  std::atomic_bool expect_manual_compaction_;
};

class DeleteFilterFactory : public CompactionFilterFactory {
 public:
  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
4256
      const CompactionFilter::Context& context) override {
4257 4258 4259 4260 4261 4262 4263 4264 4265 4266
    if (context.is_manual_compaction) {
      return std::unique_ptr<CompactionFilter>(new DeleteFilter());
    } else {
      return std::unique_ptr<CompactionFilter>(nullptr);
    }
  }

  virtual const char* Name() const override { return "DeleteFilterFactory"; }
};

4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280
class DelayFilterFactory : public CompactionFilterFactory {
 public:
  explicit DelayFilterFactory(DBTest* d) : db_test(d) {}
  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    return std::unique_ptr<CompactionFilter>(new DelayFilter(db_test));
  }

  virtual const char* Name() const override { return "DelayFilterFactory"; }

 private:
  DBTest* db_test;
};

4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299
class ConditionalFilterFactory : public CompactionFilterFactory {
 public:
  explicit ConditionalFilterFactory(const Slice& filtered_value)
      : filtered_value_(filtered_value.ToString()) {}

  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
      const CompactionFilter::Context& context) override {
    return std::unique_ptr<CompactionFilter>(
        new ConditionalFilter(&filtered_value_));
  }

  virtual const char* Name() const override {
    return "ConditionalFilterFactory";
  }

 private:
  std::string filtered_value_;
};

4300 4301 4302 4303 4304
class ChangeFilterFactory : public CompactionFilterFactory {
 public:
  explicit ChangeFilterFactory() {}

  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
4305
      const CompactionFilter::Context& context) override {
4306 4307 4308 4309 4310 4311
    return std::unique_ptr<CompactionFilter>(new ChangeFilter());
  }

  virtual const char* Name() const override { return "ChangeFilterFactory"; }
};

S
sdong 已提交
4312 4313 4314 4315 4316 4317 4318 4319 4320 4321
class DBTestUniversalCompactionBase
    : public DBTest,
      public ::testing::WithParamInterface<int> {
 public:
  virtual void SetUp() override { num_levels_ = GetParam(); }
  int num_levels_;
};

class DBTestUniversalCompaction : public DBTestUniversalCompactionBase {};

4322 4323
// TODO(kailiu) The tests on UniversalCompaction has some issues:
//  1. A lot of magic numbers ("11" or "12").
4324
//  2. Made assumption on the memtable flush conditions, which may change from
4325
//     time to time.
S
sdong 已提交
4326
TEST_P(DBTestUniversalCompaction, UniversalCompactionTrigger) {
4327
  Options options;
4328
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
4329 4330 4331
  options.num_levels = num_levels_;
  options.write_buffer_size = 100 << 10;     // 100KB
  options.target_file_size_base = 32 << 10;  // 32KB
4332 4333
  // trigger compaction if there are >= 4 files
  options.level0_file_num_compaction_trigger = 4;
4334 4335 4336 4337
  KeepFilterFactory* filter = new KeepFilterFactory(true);
  filter->expect_manual_compaction_.store(false);
  options.compaction_filter_factory.reset(filter);

4338
  options = CurrentOptions(options);
S
sdong 已提交
4339
  DestroyAndReopen(options);
L
Lei Jin 已提交
4340
  CreateAndReopenWithCF({"pikachu"}, options);
4341

4342 4343 4344 4345 4346 4347 4348 4349 4350 4351
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBTestWritableFile.GetPreallocationStatus", [&](void* arg) {
        ASSERT_TRUE(arg != nullptr);
        size_t preallocation_size = *(static_cast<size_t*>(arg));
        if (num_levels_ > 3) {
          ASSERT_LE(preallocation_size, options.target_file_size_base * 1.1);
        }
      });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

4352 4353 4354
  Random rnd(301);
  int key_idx = 0;

4355
  filter->expect_full_compaction_.store(true);
4356 4357 4358
  // Stage 1:
  //   Generate a set of files at level 0, but don't trigger level-0
  //   compaction.
4359
  for (int num = 0; num < options.level0_file_num_compaction_trigger - 1;
4360
       num++) {
4361
    // Write 110KB (11 values, each 10K)
4362
    for (int i = 0; i < 12; i++) {
4363
      ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4364 4365
      key_idx++;
    }
4366
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
S
sdong 已提交
4367
    ASSERT_EQ(NumSortedRuns(1), num + 1);
4368 4369 4370 4371
  }

  // Generate one more file at level-0, which should trigger level-0
  // compaction.
4372
  for (int i = 0; i < 11; i++) {
4373
    ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4374 4375 4376 4377 4378 4379
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Suppose each file flushed from mem table has size 1. Now we compact
  // (level0_file_num_compaction_trigger+1)=4 files and should have a big
  // file of size 4.
S
sdong 已提交
4380
  ASSERT_EQ(NumSortedRuns(1), 1);
4381 4382 4383 4384 4385 4386 4387 4388

  // Stage 2:
  //   Now we have one file at level 0, with size 4. We also have some data in
  //   mem table. Let's continue generating new files at level 0, but don't
  //   trigger level-0 compaction.
  //   First, clean up memtable before inserting new data. This will generate
  //   a level-0 file, with size around 0.4 (according to previously written
  //   data amount).
4389
  filter->expect_full_compaction_.store(false);
4390 4391
  ASSERT_OK(Flush(1));
  for (int num = 0; num < options.level0_file_num_compaction_trigger - 3;
4392
       num++) {
4393 4394
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4395
      ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4396 4397
      key_idx++;
    }
4398
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
S
sdong 已提交
4399
    ASSERT_EQ(NumSortedRuns(1), num + 3);
4400 4401 4402 4403
  }

  // Generate one more file at level-0, which should trigger level-0
  // compaction.
4404
  for (int i = 0; i < 11; i++) {
4405
    ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4406 4407 4408 4409
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Before compaction, we have 4 files at level 0, with size 4, 0.4, 1, 1.
4410
  // After compaction, we should have 2 files, with size 4, 2.4.
S
sdong 已提交
4411
  ASSERT_EQ(NumSortedRuns(1), 2);
4412 4413 4414 4415

  // Stage 3:
  //   Now we have 2 files at level 0, with size 4 and 2.4. Continue
  //   generating new files at level 0.
4416
  for (int num = 0; num < options.level0_file_num_compaction_trigger - 3;
4417
       num++) {
4418 4419
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4420
      ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4421 4422
      key_idx++;
    }
4423
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
S
sdong 已提交
4424
    ASSERT_EQ(NumSortedRuns(1), num + 3);
4425 4426 4427 4428 4429
  }

  // Generate one more file at level-0, which should trigger level-0
  // compaction.
  for (int i = 0; i < 12; i++) {
4430
    ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4431 4432 4433 4434
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Before compaction, we have 4 files at level 0, with size 4, 2.4, 1, 1.
4435
  // After compaction, we should have 3 files, with size 4, 2.4, 2.
S
sdong 已提交
4436
  ASSERT_EQ(NumSortedRuns(1), 3);
4437 4438 4439 4440

  // Stage 4:
  //   Now we have 3 files at level 0, with size 4, 2.4, 2. Let's generate a
  //   new file of size 1.
4441
  for (int i = 0; i < 11; i++) {
4442
    ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4443 4444 4445 4446
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Level-0 compaction is triggered, but no file will be picked up.
S
sdong 已提交
4447
  ASSERT_EQ(NumSortedRuns(1), 4);
4448 4449 4450 4451

  // Stage 5:
  //   Now we have 4 files at level 0, with size 4, 2.4, 2, 1. Let's generate
  //   a new file of size 1.
4452
  filter->expect_full_compaction_.store(true);
4453
  for (int i = 0; i < 11; i++) {
4454
    ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4455 4456 4457 4458
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // All files at level 0 will be compacted into a single one.
S
sdong 已提交
4459
  ASSERT_EQ(NumSortedRuns(1), 1);
4460 4461

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
4462 4463
}

S
sdong 已提交
4464
TEST_P(DBTestUniversalCompaction, UniversalCompactionSizeAmplification) {
4465
  Options options;
4466
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
4467 4468 4469
  options.num_levels = num_levels_;
  options.write_buffer_size = 100 << 10;     // 100KB
  options.target_file_size_base = 32 << 10;  // 32KB
4470
  options.level0_file_num_compaction_trigger = 3;
4471
  options = CurrentOptions(options);
S
sdong 已提交
4472
  DestroyAndReopen(options);
L
Lei Jin 已提交
4473
  CreateAndReopenWithCF({"pikachu"}, options);
4474 4475

  // Trigger compaction if size amplification exceeds 110%
4476
  options.compaction_options_universal.max_size_amplification_percent = 110;
4477
  options = CurrentOptions(options);
L
Lei Jin 已提交
4478
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
4479 4480 4481 4482 4483

  Random rnd(301);
  int key_idx = 0;

  //   Generate two files in Level 0. Both files are approx the same size.
4484
  for (int num = 0; num < options.level0_file_num_compaction_trigger - 1;
4485
       num++) {
4486 4487
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4488
      ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4489 4490
      key_idx++;
    }
4491
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
S
sdong 已提交
4492
    ASSERT_EQ(NumSortedRuns(1), num + 1);
4493
  }
S
sdong 已提交
4494
  ASSERT_EQ(NumSortedRuns(1), 2);
4495 4496 4497 4498

  // Flush whatever is remaining in memtable. This is typically
  // small, which should not trigger size ratio based compaction
  // but will instead trigger size amplification.
4499
  ASSERT_OK(Flush(1));
4500

4501 4502
  dbfull()->TEST_WaitForCompact();

4503
  // Verify that size amplification did occur
S
sdong 已提交
4504
  ASSERT_EQ(NumSortedRuns(1), 1);
4505 4506
}

S
sdong 已提交
4507 4508 4509 4510
class DBTestUniversalCompactionMultiLevels
    : public DBTestUniversalCompactionBase {};

TEST_P(DBTestUniversalCompactionMultiLevels, UniversalCompactionMultiLevels) {
4511
  Options options;
4512
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537
  options.num_levels = num_levels_;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 8;
  options.max_background_compactions = 3;
  options.target_file_size_base = 32 * 1024;
  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  // Trigger compaction if size amplification exceeds 110%
  options.compaction_options_universal.max_size_amplification_percent = 110;
  options = CurrentOptions(options);
  ReopenWithColumnFamilies({"default", "pikachu"}, options);

  Random rnd(301);
  int num_keys = 100000;
  for (int i = 0; i < num_keys * 2; i++) {
    ASSERT_OK(Put(1, Key(i % num_keys), Key(i)));
  }

  dbfull()->TEST_WaitForCompact();

  for (int i = num_keys; i < num_keys * 2; i++) {
    ASSERT_EQ(Get(1, Key(i % num_keys)), Key(i));
  }
}
4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548
// Tests universal compaction with trivial move enabled
TEST_P(DBTestUniversalCompactionMultiLevels, UniversalCompactionTrivialMove) {
  int32_t trivial_move = 0;
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
S
sdong 已提交
4549

4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581
  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.compaction_options_universal.allow_trivial_move = true;
  options.num_levels = 3;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 3;
  options.max_background_compactions = 1;
  options.target_file_size_base = 32 * 1024;
  options = CurrentOptions(options);
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  // Trigger compaction if size amplification exceeds 110%
  options.compaction_options_universal.max_size_amplification_percent = 110;
  options = CurrentOptions(options);
  ReopenWithColumnFamilies({"default", "pikachu"}, options);

  Random rnd(301);
  int num_keys = 15000;
  for (int i = 0; i < num_keys; i++) {
    ASSERT_OK(Put(1, Key(i), Key(i)));
  }
  std::vector<std::string> values;

  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();

  ASSERT_GT(trivial_move, 0);
  ASSERT_EQ(non_trivial_move, 0);

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}
S
sdong 已提交
4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606
INSTANTIATE_TEST_CASE_P(DBTestUniversalCompactionMultiLevels,
                        DBTestUniversalCompactionMultiLevels,
                        ::testing::Values(3, 20));

class DBTestUniversalCompactionParallel : public DBTestUniversalCompactionBase {
};

TEST_P(DBTestUniversalCompactionParallel, UniversalCompactionParallel) {
  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = num_levels_;
  options.write_buffer_size = 1 << 10;  // 1KB
  options.level0_file_num_compaction_trigger = 3;
  options.max_background_compactions = 3;
  options.max_background_flushes = 3;
  options.target_file_size_base = 1 * 1024;
  options.compaction_options_universal.max_size_amplification_percent = 110;
  options = CurrentOptions(options);
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  // Delay every compaction so multiple compactions will happen.
  std::atomic<int> num_compactions_running(0);
  std::atomic<bool> has_parallel(false);
  rocksdb::SyncPoint::GetInstance()->SetCallBack("CompactionJob::Run():Start",
4607
                                                 [&](void* arg) {
S
sdong 已提交
4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621
    if (num_compactions_running.fetch_add(1) > 0) {
      has_parallel.store(true);
      return;
    }
    for (int nwait = 0; nwait < 20000; nwait++) {
      if (has_parallel.load() || num_compactions_running.load() > 1) {
        has_parallel.store(true);
        break;
      }
      env_->SleepForMicroseconds(1000);
    }
  });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "CompactionJob::Run():End",
4622
      [&](void* arg) { num_compactions_running.fetch_add(-1); });
S
sdong 已提交
4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  options = CurrentOptions(options);
  ReopenWithColumnFamilies({"default", "pikachu"}, options);

  Random rnd(301);
  int num_keys = 30000;
  for (int i = 0; i < num_keys * 2; i++) {
    ASSERT_OK(Put(1, Key(i % num_keys), Key(i)));
  }
  dbfull()->TEST_WaitForCompact();

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  ASSERT_EQ(num_compactions_running.load(), 0);
  ASSERT_TRUE(has_parallel.load());

  for (int i = num_keys; i < num_keys * 2; i++) {
    ASSERT_EQ(Get(1, Key(i % num_keys)), Key(i));
  }

  // Reopen and check.
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
  for (int i = num_keys; i < num_keys * 2; i++) {
    ASSERT_EQ(Get(1, Key(i % num_keys)), Key(i));
  }
}

INSTANTIATE_TEST_CASE_P(DBTestUniversalCompactionParallel,
                        DBTestUniversalCompactionParallel,
                        ::testing::Values(1, 10));

TEST_P(DBTestUniversalCompaction, UniversalCompactionOptions) {
  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;     // 100KB
  options.target_file_size_base = 32 << 10;  // 32KB
4659
  options.level0_file_num_compaction_trigger = 4;
S
sdong 已提交
4660
  options.num_levels = num_levels_;
4661
  options.compaction_options_universal.compression_size_percent = -1;
4662
  options = CurrentOptions(options);
S
sdong 已提交
4663
  DestroyAndReopen(options);
L
Lei Jin 已提交
4664
  CreateAndReopenWithCF({"pikachu"}, options);
4665 4666 4667 4668

  Random rnd(301);
  int key_idx = 0;

4669
  for (int num = 0; num < options.level0_file_num_compaction_trigger; num++) {
4670 4671
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4672
      ASSERT_OK(Put(1, Key(key_idx), RandomString(&rnd, 10000)));
4673 4674
      key_idx++;
    }
4675
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
4676 4677

    if (num < options.level0_file_num_compaction_trigger - 1) {
S
sdong 已提交
4678
      ASSERT_EQ(NumSortedRuns(1), num + 1);
4679 4680 4681 4682
    }
  }

  dbfull()->TEST_WaitForCompact();
S
sdong 已提交
4683
  ASSERT_EQ(NumSortedRuns(1), 1);
4684 4685
}

S
sdong 已提交
4686
TEST_P(DBTestUniversalCompaction, UniversalCompactionStopStyleSimilarSize) {
4687 4688
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
4689 4690
  options.write_buffer_size = 100 << 10;     // 100KB
  options.target_file_size_base = 32 << 10;  // 32KB
4691 4692 4693
  // trigger compaction if there are >= 4 files
  options.level0_file_num_compaction_trigger = 4;
  options.compaction_options_universal.size_ratio = 10;
S
sdong 已提交
4694 4695 4696 4697
  options.compaction_options_universal.stop_style =
      kCompactionStopStyleSimilarSize;
  options.num_levels = num_levels_;
  DestroyAndReopen(options);
4698 4699 4700 4701 4702 4703 4704

  Random rnd(301);
  int key_idx = 0;

  // Stage 1:
  //   Generate a set of files at level 0, but don't trigger level-0
  //   compaction.
S
sdong 已提交
4705
  for (int num = 0; num < options.level0_file_num_compaction_trigger - 1;
4706
       num++) {
4707 4708
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4709 4710 4711 4712
      ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
S
sdong 已提交
4713
    ASSERT_EQ(NumSortedRuns(), num + 1);
4714 4715 4716 4717
  }

  // Generate one more file at level-0, which should trigger level-0
  // compaction.
4718
  for (int i = 0; i < 11; i++) {
4719 4720 4721 4722 4723 4724 4725
    ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Suppose each file flushed from mem table has size 1. Now we compact
  // (level0_file_num_compaction_trigger+1)=4 files and should have a big
  // file of size 4.
S
sdong 已提交
4726
  ASSERT_EQ(NumSortedRuns(), 1);
4727 4728 4729 4730 4731 4732 4733 4734 4735

  // Stage 2:
  //   Now we have one file at level 0, with size 4. We also have some data in
  //   mem table. Let's continue generating new files at level 0, but don't
  //   trigger level-0 compaction.
  //   First, clean up memtable before inserting new data. This will generate
  //   a level-0 file, with size around 0.4 (according to previously written
  //   data amount).
  dbfull()->Flush(FlushOptions());
S
sdong 已提交
4736
  for (int num = 0; num < options.level0_file_num_compaction_trigger - 3;
4737
       num++) {
4738 4739
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4740 4741 4742 4743
      ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
S
sdong 已提交
4744
    ASSERT_EQ(NumSortedRuns(), num + 3);
4745 4746 4747 4748
  }

  // Generate one more file at level-0, which should trigger level-0
  // compaction.
4749
  for (int i = 0; i < 11; i++) {
4750 4751 4752 4753 4754 4755
    ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Before compaction, we have 4 files at level 0, with size 4, 0.4, 1, 1.
  // After compaction, we should have 3 files, with size 4, 0.4, 2.
S
sdong 已提交
4756
  ASSERT_EQ(NumSortedRuns(), 3);
4757 4758 4759
  // Stage 3:
  //   Now we have 3 files at level 0, with size 4, 0.4, 2. Generate one
  //   more file at level-0, which should trigger level-0 compaction.
4760
  for (int i = 0; i < 11; i++) {
4761 4762 4763 4764 4765
    ASSERT_OK(Put(Key(key_idx), RandomString(&rnd, 10000)));
    key_idx++;
  }
  dbfull()->TEST_WaitForCompact();
  // Level-0 compaction is triggered, but no file will be picked up.
S
sdong 已提交
4766
  ASSERT_EQ(NumSortedRuns(), 4);
4767 4768
}

I
Igor Sugak 已提交
4769
TEST_F(DBTest, CompressedCache) {
I
Igor Canadi 已提交
4770
  if (!Snappy_Supported()) {
4771 4772
    return;
  }
4773 4774 4775 4776 4777 4778
  int num_iter = 80;

  // Run this test three iterations.
  // Iteration 1: only a uncompressed block cache
  // Iteration 2: only a compressed block cache
  // Iteration 3: both block cache and compressed cache
I
Igor Canadi 已提交
4779 4780 4781
  // Iteration 4: both block cache and compressed cache, but DB is not
  // compressed
  for (int iter = 0; iter < 4; iter++) {
4782
    Options options;
4783 4784
    options.write_buffer_size = 64*1024;        // small write buffer
    options.statistics = rocksdb::CreateDBStatistics();
4785
    options = CurrentOptions(options);
4786

4787
    BlockBasedTableOptions table_options;
4788 4789 4790
    switch (iter) {
      case 0:
        // only uncompressed block cache
4791 4792 4793
        table_options.block_cache = NewLRUCache(8*1024);
        table_options.block_cache_compressed = nullptr;
        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
4794 4795 4796
        break;
      case 1:
        // no block cache, only compressed cache
4797 4798 4799 4800
        table_options.no_block_cache = true;
        table_options.block_cache = nullptr;
        table_options.block_cache_compressed = NewLRUCache(8*1024);
        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
4801 4802 4803
        break;
      case 2:
        // both compressed and uncompressed block cache
4804 4805 4806
        table_options.block_cache = NewLRUCache(1024);
        table_options.block_cache_compressed = NewLRUCache(8*1024);
        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
4807
        break;
I
Igor Canadi 已提交
4808 4809 4810
      case 3:
        // both block cache and compressed cache, but DB is not compressed
        // also, make block cache sizes bigger, to trigger block cache hits
4811 4812 4813
        table_options.block_cache = NewLRUCache(1024 * 1024);
        table_options.block_cache_compressed = NewLRUCache(8 * 1024 * 1024);
        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
I
Igor Canadi 已提交
4814 4815
        options.compression = kNoCompression;
        break;
4816 4817 4818
      default:
        ASSERT_TRUE(false);
    }
L
Lei Jin 已提交
4819
    CreateAndReopenWithCF({"pikachu"}, options);
4820 4821 4822
    // default column family doesn't have block cache
    Options no_block_cache_opts;
    no_block_cache_opts.statistics = options.statistics;
4823
    no_block_cache_opts = CurrentOptions(no_block_cache_opts);
4824 4825 4826 4827
    BlockBasedTableOptions table_options_no_bc;
    table_options_no_bc.no_block_cache = true;
    no_block_cache_opts.table_factory.reset(
        NewBlockBasedTableFactory(table_options_no_bc));
4828
    ReopenWithColumnFamilies({"default", "pikachu"},
L
Lei Jin 已提交
4829
        std::vector<Options>({no_block_cache_opts, options}));
4830 4831 4832 4833

    Random rnd(301);

    // Write 8MB (80 values, each 100K)
4834
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
4835 4836 4837 4838 4839 4840 4841
    std::vector<std::string> values;
    std::string str;
    for (int i = 0; i < num_iter; i++) {
      if (i % 4 == 0) {        // high compression ratio
        str = RandomString(&rnd, 1000);
      }
      values.push_back(str);
4842
      ASSERT_OK(Put(1, Key(i), values[i]));
4843 4844 4845
    }

    // flush all data from memtable so that reads are from block cache
4846
    ASSERT_OK(Flush(1));
4847 4848

    for (int i = 0; i < num_iter; i++) {
4849
      ASSERT_EQ(Get(1, Key(i)), values[i]);
4850 4851 4852 4853 4854 4855
    }

    // check that we triggered the appropriate code paths in the cache
    switch (iter) {
      case 0:
        // only uncompressed block cache
I
Igor Canadi 已提交
4856 4857
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
4858 4859 4860
        break;
      case 1:
        // no block cache, only compressed cache
I
Igor Canadi 已提交
4861 4862
        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
4863 4864 4865
        break;
      case 2:
        // both compressed and uncompressed block cache
I
Igor Canadi 已提交
4866 4867
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
4868
        break;
I
Igor Canadi 已提交
4869 4870 4871 4872 4873 4874 4875 4876 4877
      case 3:
        // both compressed and uncompressed block cache
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_HIT), 0);
        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
        // compressed doesn't have any hits since blocks are not compressed on
        // storage
        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_HIT), 0);
        break;
4878 4879 4880
      default:
        ASSERT_TRUE(false);
    }
4881 4882

    options.create_if_missing = true;
L
Lei Jin 已提交
4883
    DestroyAndReopen(options);
4884 4885 4886
  }
}

K
kailiu 已提交
4887 4888 4889 4890 4891 4892
static std::string CompressibleString(Random* rnd, int len) {
  std::string r;
  test::CompressibleString(rnd, 0.8, len, &r);
  return r;
}

S
sdong 已提交
4893
TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio1) {
I
Igor Canadi 已提交
4894
  if (!Snappy_Supported()) {
4895 4896
    return;
  }
S
sdong 已提交
4897

4898
  Options options;
4899
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
4900 4901
  options.write_buffer_size = 100 << 10;     // 100KB
  options.target_file_size_base = 32 << 10;  // 32KB
4902
  options.level0_file_num_compaction_trigger = 2;
S
sdong 已提交
4903
  options.num_levels = num_levels_;
4904
  options.compaction_options_universal.compression_size_percent = 70;
4905
  options = CurrentOptions(options);
S
sdong 已提交
4906
  DestroyAndReopen(options);
4907 4908 4909 4910 4911 4912

  Random rnd(301);
  int key_idx = 0;

  // The first compaction (2) is compressed.
  for (int num = 0; num < 2; num++) {
4913 4914
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4915 4916 4917 4918 4919 4920
      ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
  }
S
sdong 已提交
4921
  ASSERT_LT(TotalSize(), 110000U * 2 * 0.9);
4922 4923 4924

  // The second compaction (4) is compressed
  for (int num = 0; num < 2; num++) {
4925 4926
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4927 4928 4929 4930 4931 4932
      ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
  }
S
sdong 已提交
4933
  ASSERT_LT(TotalSize(), 110000 * 4 * 0.9);
4934 4935 4936 4937

  // The third compaction (2 4) is compressed since this time it is
  // (1 1 3.2) and 3.2/5.2 doesn't reach ratio.
  for (int num = 0; num < 2; num++) {
4938 4939
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4940 4941 4942 4943 4944 4945
      ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
  }
S
sdong 已提交
4946
  ASSERT_LT(TotalSize(), 110000 * 6 * 0.9);
4947 4948 4949 4950

  // When we start for the compaction up to (2 4 8), the latest
  // compressed is not compressed.
  for (int num = 0; num < 8; num++) {
4951 4952
    // Write 110KB (11 values, each 10K)
    for (int i = 0; i < 11; i++) {
4953 4954 4955 4956 4957 4958
      ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
  }
S
sdong 已提交
4959
  ASSERT_GT(TotalSize(), 110000 * 11 * 0.8 + 110000 * 2);
4960 4961
}

S
sdong 已提交
4962
TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio2) {
I
Igor Canadi 已提交
4963
  if (!Snappy_Supported()) {
4964 4965
    return;
  }
4966
  Options options;
4967
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
4968 4969
  options.write_buffer_size = 100 << 10;     // 100KB
  options.target_file_size_base = 32 << 10;  // 32KB
4970
  options.level0_file_num_compaction_trigger = 2;
S
sdong 已提交
4971
  options.num_levels = num_levels_;
4972
  options.compaction_options_universal.compression_size_percent = 95;
4973
  options = CurrentOptions(options);
S
sdong 已提交
4974
  DestroyAndReopen(options);
4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989

  Random rnd(301);
  int key_idx = 0;

  // When we start for the compaction up to (2 4 8), the latest
  // compressed is compressed given the size ratio to compress.
  for (int num = 0; num < 14; num++) {
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      ASSERT_OK(Put(Key(key_idx), CompressibleString(&rnd, 10000)));
      key_idx++;
    }
    dbfull()->TEST_WaitForFlushMemTable();
    dbfull()->TEST_WaitForCompact();
  }
S
sdong 已提交
4990
  ASSERT_LT(TotalSize(), 120000U * 12 * 0.8 + 120000 * 2);
4991
}
4992

S
sdong 已提交
4993 4994 4995
INSTANTIATE_TEST_CASE_P(UniversalCompactionNumLevels, DBTestUniversalCompaction,
                        ::testing::Values(1, 3, 5));

I
Igor Sugak 已提交
4996
TEST_F(DBTest, FailMoreDbPaths) {
4997
  Options options = CurrentOptions();
4998 4999 5000 5001 5002
  options.db_paths.emplace_back(dbname_, 10000000);
  options.db_paths.emplace_back(dbname_ + "_2", 1000000);
  options.db_paths.emplace_back(dbname_ + "_3", 1000000);
  options.db_paths.emplace_back(dbname_ + "_4", 1000000);
  options.db_paths.emplace_back(dbname_ + "_5", 1000000);
L
Lei Jin 已提交
5003
  ASSERT_TRUE(TryReopen(options).IsNotSupported());
5004
}
5005

I
Igor Sugak 已提交
5006
TEST_F(DBTest, UniversalCompactionSecondPathRatio) {
I
Igor Canadi 已提交
5007
  if (!Snappy_Supported()) {
5008 5009
    return;
  }
5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025
  Options options;
  options.db_paths.emplace_back(dbname_, 500 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 1024 * 1024 * 1024);
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 1;
  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
  }
  env_->DeleteDir(options.db_paths[1].path);
L
Lei Jin 已提交
5026
  Reopen(options);
5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091

  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are not going to second path.
  // After that, (100K, 200K)
  for (int num = 0; num < 3; num++) {
    GenerateNewFile(&rnd, &key_idx);
  }

  // Another 110KB triggers a compaction to 400K file to second path
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

  // (1, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1,1,4) -> (2, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 2, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(2, GetSstFileCount(dbname_));

  // (1, 1, 2, 4) -> (8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  // (1, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 1, 8) -> (2, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 2, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(2, GetSstFileCount(dbname_));

  // (1, 1, 2, 8) -> (4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(2, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  // (1, 4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(2, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

L
Lei Jin 已提交
5092
  Reopen(options);
5093 5094 5095 5096 5097 5098 5099

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

L
Lei Jin 已提交
5100
  Destroy(options);
5101 5102
}

I
Igor Sugak 已提交
5103
TEST_F(DBTest, LevelCompactionThirdPath) {
5104
  Options options = CurrentOptions();
5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215
  options.db_paths.emplace_back(dbname_, 500 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 4 * 1024 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 1024 * 1024 * 1024);
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 4;
  options.max_bytes_for_level_base = 400 * 1024;
  //  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
  }
  env_->DeleteDir(options.db_paths[1].path);
  Reopen(options);

  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are not going to second path.
  // After that, (100K, 200K)
  for (int num = 0; num < 3; num++) {
    GenerateNewFile(&rnd, &key_idx);
  }

  // Another 110KB triggers a compaction to 400K file to fill up first path
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(3, GetSstFileCount(options.db_paths[1].path));

  // (1, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4", FilesPerLevel(0));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 1)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,1", FilesPerLevel(0));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 2)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,2", FilesPerLevel(0));
  ASSERT_EQ(2, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 3)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,3", FilesPerLevel(0));
  ASSERT_EQ(3, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,4", FilesPerLevel(0));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 5)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,5", FilesPerLevel(0));
  ASSERT_EQ(5, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 6)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,6", FilesPerLevel(0));
  ASSERT_EQ(6, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 7)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,7", FilesPerLevel(0));
  ASSERT_EQ(7, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,8", FilesPerLevel(0));
  ASSERT_EQ(8, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(4, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Reopen(options);

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Destroy(options);
}

I
Igor Sugak 已提交
5216
TEST_F(DBTest, LevelCompactionPathUse) {
5217
  Options options = CurrentOptions();
5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329
  options.db_paths.emplace_back(dbname_, 500 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 4 * 1024 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 1024 * 1024 * 1024);
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 4;
  options.max_bytes_for_level_base = 400 * 1024;
  //  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
  }
  env_->DeleteDir(options.db_paths[1].path);
  Reopen(options);

  Random rnd(301);
  int key_idx = 0;

  // Always gets compacted into 1 Level1 file,
  // 0/1 Level 0 file
  for (int num = 0; num < 3; num++) {
    key_idx = 0;
    GenerateNewFile(&rnd, &key_idx);
  }

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("0,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("0,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("0,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("0,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  key_idx = 0;
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,1", FilesPerLevel(0));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Reopen(options);

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Destroy(options);
}

I
Igor Sugak 已提交
5330
TEST_F(DBTest, UniversalCompactionFourPaths) {
5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348
  Options options;
  options.db_paths.emplace_back(dbname_, 300 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 300 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 500 * 1024);
  options.db_paths.emplace_back(dbname_ + "_4", 1024 * 1024 * 1024);
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 1;
  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(options.db_paths[1].path + "/" + filenames[i]);
  }
  env_->DeleteDir(options.db_paths[1].path);
L
Lei Jin 已提交
5349
  Reopen(options);
5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417

  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are not going to second path.
  // After that, (100K, 200K)
  for (int num = 0; num < 3; num++) {
    GenerateNewFile(&rnd, &key_idx);
  }

  // Another 110KB triggers a compaction to 400K file to second path
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));

  // (1, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1,1,4) -> (2, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  // (1, 2, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 1, 2, 4) -> (8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));

  // (1, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 1, 8) -> (2, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

  // (1, 2, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  // (1, 1, 2, 8) -> (4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));

  // (1, 4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[3].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[2].path));
  ASSERT_EQ(1, GetSstFileCount(dbname_));

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

L
Lei Jin 已提交
5418
  Reopen(options);
5419 5420 5421 5422 5423 5424 5425

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

L
Lei Jin 已提交
5426
  Destroy(options);
5427
}
5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447

void CheckColumnFamilyMeta(const ColumnFamilyMetaData& cf_meta) {
  uint64_t cf_size = 0;
  uint64_t cf_csize = 0;
  size_t file_count = 0;
  for (auto level_meta : cf_meta.levels) {
    uint64_t level_size = 0;
    uint64_t level_csize = 0;
    file_count += level_meta.files.size();
    for (auto file_meta : level_meta.files) {
      level_size += file_meta.size;
    }
    ASSERT_EQ(level_meta.size, level_size);
    cf_size += level_size;
    cf_csize += level_csize;
  }
  ASSERT_EQ(cf_meta.file_count, file_count);
  ASSERT_EQ(cf_meta.size, cf_size);
}

I
Igor Sugak 已提交
5448
TEST_F(DBTest, ColumnFamilyMetaDataTest) {
5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462
  Options options = CurrentOptions();
  options.create_if_missing = true;
  DestroyAndReopen(options);

  Random rnd(301);
  int key_index = 0;
  ColumnFamilyMetaData cf_meta;
  for (int i = 0; i < 100; ++i) {
    GenerateNewFile(&rnd, &key_index);
    db_->GetColumnFamilyMetaData(&cf_meta);
    CheckColumnFamilyMeta(cf_meta);
  }
}

I
Igor Sugak 已提交
5463
TEST_F(DBTest, ConvertCompactionStyle) {
5464 5465 5466 5467 5468
  Random rnd(301);
  int max_key_level_insert = 200;
  int max_key_universal_insert = 600;

  // Stage 1: generate a db with level compaction
5469
  Options options;
5470 5471 5472 5473 5474 5475 5476
  options.write_buffer_size = 100<<10; //100KB
  options.num_levels = 4;
  options.level0_file_num_compaction_trigger = 3;
  options.max_bytes_for_level_base = 500<<10; // 500KB
  options.max_bytes_for_level_multiplier = 1;
  options.target_file_size_base = 200<<10; // 200KB
  options.target_file_size_multiplier = 1;
5477
  options = CurrentOptions(options);
L
Lei Jin 已提交
5478
  CreateAndReopenWithCF({"pikachu"}, options);
5479 5480 5481

  for (int i = 0; i <= max_key_level_insert; i++) {
    // each value is 10K
5482
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
5483
  }
5484
  ASSERT_OK(Flush(1));
5485 5486
  dbfull()->TEST_WaitForCompact();

5487
  ASSERT_GT(TotalTableFiles(1, 4), 1);
5488
  int non_level0_num_files = 0;
5489 5490
  for (int i = 1; i < options.num_levels; i++) {
    non_level0_num_files += NumTableFilesAtLevel(i, 1);
5491 5492 5493 5494 5495 5496
  }
  ASSERT_GT(non_level0_num_files, 0);

  // Stage 2: reopen with universal compaction - should fail
  options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
5497
  options.num_levels = 1;
5498
  options = CurrentOptions(options);
L
Lei Jin 已提交
5499
  Status s = TryReopenWithColumnFamilies({"default", "pikachu"}, options);
5500 5501 5502 5503 5504 5505 5506 5507 5508
  ASSERT_TRUE(s.IsInvalidArgument());

  // Stage 3: compact into a single file and move the file to level 0
  options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.target_file_size_base = INT_MAX;
  options.target_file_size_multiplier = 1;
  options.max_bytes_for_level_base = INT_MAX;
  options.max_bytes_for_level_multiplier = 1;
S
sdong 已提交
5509
  options.num_levels = 4;
5510
  options = CurrentOptions(options);
L
Lei Jin 已提交
5511
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
5512

5513 5514 5515
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 0;
5516 5517
  compact_options.bottommost_level_compaction =
      BottommostLevelCompaction::kForce;
5518
  dbfull()->CompactRange(compact_options, handles_[1], nullptr, nullptr);
5519

5520 5521
  // Only 1 file in L0
  ASSERT_EQ("1", FilesPerLevel(1));
5522 5523 5524 5525

  // Stage 4: re-open in universal compaction style and do some db operations
  options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
5526
  options.num_levels = 4;
5527 5528
  options.write_buffer_size = 100<<10; //100KB
  options.level0_file_num_compaction_trigger = 3;
5529
  options = CurrentOptions(options);
L
Lei Jin 已提交
5530
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
5531

S
sdong 已提交
5532 5533 5534
  options.num_levels = 1;
  ReopenWithColumnFamilies({"default", "pikachu"}, options);

5535
  for (int i = max_key_level_insert / 2; i <= max_key_universal_insert; i++) {
5536
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
5537 5538
  }
  dbfull()->Flush(FlushOptions());
5539
  ASSERT_OK(Flush(1));
5540 5541
  dbfull()->TEST_WaitForCompact();

5542 5543
  for (int i = 1; i < options.num_levels; i++) {
    ASSERT_EQ(NumTableFilesAtLevel(i, 1), 0);
5544 5545 5546 5547 5548
  }

  // verify keys inserted in both level compaction style and universal
  // compaction style
  std::string keys_in_db;
5549
  Iterator* iter = dbfull()->NewIterator(ReadOptions(), handles_[1]);
5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    keys_in_db.append(iter->key().ToString());
    keys_in_db.push_back(',');
  }
  delete iter;

  std::string expected_keys;
  for (int i = 0; i <= max_key_universal_insert; i++) {
    expected_keys.append(Key(i));
    expected_keys.push_back(',');
  }

  ASSERT_EQ(keys_in_db, expected_keys);
}

S
sdong 已提交
5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589
TEST_F(DBTest, IncreaseUniversalCompactionNumLevels) {
  std::function<void(int)> verify_func = [&](int num_keys_in_db) {
    std::string keys_in_db;
    Iterator* iter = dbfull()->NewIterator(ReadOptions(), handles_[1]);
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      keys_in_db.append(iter->key().ToString());
      keys_in_db.push_back(',');
    }
    delete iter;

    std::string expected_keys;
    for (int i = 0; i <= num_keys_in_db; i++) {
      expected_keys.append(Key(i));
      expected_keys.push_back(',');
    }

    ASSERT_EQ(keys_in_db, expected_keys);
  };

  Random rnd(301);
  int max_key1 = 200;
  int max_key2 = 600;
  int max_key3 = 800;

  // Stage 1: open a DB with universal compaction, num_levels=1
5590
  Options options = CurrentOptions();
S
sdong 已提交
5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = 1;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 3;
  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  for (int i = 0; i <= max_key1; i++) {
    // each value is 10K
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
  }
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();

  int non_level0_num_files = 0;
  for (int i = 1; i < options.num_levels; i++) {
    non_level0_num_files += NumTableFilesAtLevel(i, 1);
  }
  ASSERT_EQ(non_level0_num_files, 0);

  // Stage 2: reopen with universal compaction, num_levels=4
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = 4;
  options = CurrentOptions(options);
  ReopenWithColumnFamilies({"default", "pikachu"}, options);

  verify_func(max_key1);

  // Insert more keys
  for (int i = max_key1 + 1; i <= max_key2; i++) {
    // each value is 10K
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
  }
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();

  verify_func(max_key2);
  // Compaction to non-L0 has happened.
  ASSERT_GT(NumTableFilesAtLevel(options.num_levels - 1, 1), 0);

  // Stage 3: Revert it back to one level and revert to num_levels=1.
  options.num_levels = 4;
  options.target_file_size_base = INT_MAX;
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
  // Compact all to level 0
5636 5637 5638 5639
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 0;
  dbfull()->CompactRange(compact_options, handles_[1], nullptr, nullptr);
S
sdong 已提交
5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657
  // Need to restart it once to remove higher level records in manifest.
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
  // Final reopen
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = 1;
  options = CurrentOptions(options);
  ReopenWithColumnFamilies({"default", "pikachu"}, options);

  // Insert more keys
  for (int i = max_key2 + 1; i <= max_key3; i++) {
    // each value is 10K
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
  }
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();
  verify_func(max_key3);
}

I
Igor Canadi 已提交
5658
namespace {
5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671
void MinLevelHelper(DBTest* self, Options& options) {
  Random rnd(301);

  for (int num = 0;
    num < options.level0_file_num_compaction_trigger - 1;
    num++)
  {
    std::vector<std::string> values;
    // Write 120KB (12 values, each 10K)
    for (int i = 0; i < 12; i++) {
      values.push_back(RandomString(&rnd, 10000));
      ASSERT_OK(self->Put(Key(i), values[i]));
    }
5672
    self->dbfull()->TEST_WaitForFlushMemTable();
5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687
    ASSERT_EQ(self->NumTableFilesAtLevel(0), num + 1);
  }

  //generate one more file in level-0, and should trigger level-0 compaction
  std::vector<std::string> values;
  for (int i = 0; i < 12; i++) {
    values.push_back(RandomString(&rnd, 10000));
    ASSERT_OK(self->Put(Key(i), values[i]));
  }
  self->dbfull()->TEST_WaitForCompact();

  ASSERT_EQ(self->NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(self->NumTableFilesAtLevel(1), 1);
}

A
amayank 已提交
5688 5689
// returns false if the calling-Test should be skipped
bool MinLevelToCompress(CompressionType& type, Options& options, int wbits,
5690
                        int lev, int strategy) {
5691
  fprintf(stderr, "Test with compression options : window_bits = %d, level =  %d, strategy = %d}\n", wbits, lev, strategy);
5692 5693 5694 5695
  options.write_buffer_size = 100<<10; //100KB
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  options.level0_file_num_compaction_trigger = 3;
5696
  options.create_if_missing = true;
5697

I
Igor Canadi 已提交
5698
  if (Snappy_Supported()) {
5699 5700
    type = kSnappyCompression;
    fprintf(stderr, "using snappy\n");
I
Igor Canadi 已提交
5701
  } else if (Zlib_Supported()) {
5702 5703
    type = kZlibCompression;
    fprintf(stderr, "using zlib\n");
I
Igor Canadi 已提交
5704
  } else if (BZip2_Supported()) {
5705 5706
    type = kBZip2Compression;
    fprintf(stderr, "using bzip2\n");
I
Igor Canadi 已提交
5707
  } else if (LZ4_Supported()) {
A
Albert Strasheim 已提交
5708 5709
    type = kLZ4Compression;
    fprintf(stderr, "using lz4\n");
5710 5711
  } else {
    fprintf(stderr, "skipping test, compression disabled\n");
A
amayank 已提交
5712
    return false;
5713
  }
5714
  options.compression_per_level.resize(options.num_levels);
5715 5716 5717 5718 5719 5720 5721 5722

  // do not compress L0
  for (int i = 0; i < 1; i++) {
    options.compression_per_level[i] = kNoCompression;
  }
  for (int i = 1; i < options.num_levels; i++) {
    options.compression_per_level[i] = type;
  }
A
amayank 已提交
5723
  return true;
5724
}
I
Igor Canadi 已提交
5725
}  // namespace
5726

I
Igor Sugak 已提交
5727
TEST_F(DBTest, MinLevelToCompress1) {
5728
  Options options = CurrentOptions();
5729
  CompressionType type = kSnappyCompression;
A
amayank 已提交
5730 5731 5732
  if (!MinLevelToCompress(type, options, -14, -1, 0)) {
    return;
  }
L
Lei Jin 已提交
5733
  Reopen(options);
5734 5735 5736 5737 5738 5739 5740 5741 5742
  MinLevelHelper(this, options);

  // do not compress L0 and L1
  for (int i = 0; i < 2; i++) {
    options.compression_per_level[i] = kNoCompression;
  }
  for (int i = 2; i < options.num_levels; i++) {
    options.compression_per_level[i] = type;
  }
L
Lei Jin 已提交
5743
  DestroyAndReopen(options);
5744 5745 5746
  MinLevelHelper(this, options);
}

I
Igor Sugak 已提交
5747
TEST_F(DBTest, MinLevelToCompress2) {
5748
  Options options = CurrentOptions();
5749
  CompressionType type = kSnappyCompression;
A
amayank 已提交
5750 5751 5752
  if (!MinLevelToCompress(type, options, 15, -1, 0)) {
    return;
  }
L
Lei Jin 已提交
5753
  Reopen(options);
5754 5755
  MinLevelHelper(this, options);

5756 5757 5758 5759 5760 5761 5762
  // do not compress L0 and L1
  for (int i = 0; i < 2; i++) {
    options.compression_per_level[i] = kNoCompression;
  }
  for (int i = 2; i < options.num_levels; i++) {
    options.compression_per_level[i] = type;
  }
L
Lei Jin 已提交
5763
  DestroyAndReopen(options);
5764 5765
  MinLevelHelper(this, options);
}
5766

I
Igor Sugak 已提交
5767
TEST_F(DBTest, RepeatedWritesToSameKey) {
5768
  do {
5769
    Options options;
5770 5771
    options.env = env_;
    options.write_buffer_size = 100000;  // Small write buffer
5772
    options = CurrentOptions(options);
L
Lei Jin 已提交
5773
    CreateAndReopenWithCF({"pikachu"}, options);
5774

5775 5776
    // We must have at most one file per level except for level-0,
    // which may have up to kL0_StopWritesTrigger files.
5777 5778
    const int kMaxFiles =
        options.num_levels + options.level0_stop_writes_trigger;
5779

5780
    Random rnd(301);
5781 5782
    std::string value =
        RandomString(&rnd, static_cast<int>(2 * options.write_buffer_size));
5783
    for (int i = 0; i < 5 * kMaxFiles; i++) {
5784 5785
      ASSERT_OK(Put(1, "key", value));
      ASSERT_LE(TotalTableFiles(1), kMaxFiles);
5786 5787
    }
  } while (ChangeCompactOptions());
5788 5789
}

I
Igor Sugak 已提交
5790
TEST_F(DBTest, InPlaceUpdate) {
5791
  do {
5792
    Options options;
5793 5794 5795 5796
    options.create_if_missing = true;
    options.inplace_update_support = true;
    options.env = env_;
    options.write_buffer_size = 100000;
5797
    options = CurrentOptions(options);
L
Lei Jin 已提交
5798
    CreateAndReopenWithCF({"pikachu"}, options);
5799 5800 5801 5802 5803

    // Update key with values of smaller size
    int numValues = 10;
    for (int i = numValues; i > 0; i--) {
      std::string value = DummyString(i, 'a');
5804 5805
      ASSERT_OK(Put(1, "key", value));
      ASSERT_EQ(value, Get(1, "key"));
5806 5807 5808
    }

    // Only 1 instance for that key.
5809
    validateNumberOfEntries(1, 1);
5810 5811 5812 5813

  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
5814
TEST_F(DBTest, InPlaceUpdateLargeNewValue) {
5815
  do {
5816
    Options options;
5817 5818 5819 5820
    options.create_if_missing = true;
    options.inplace_update_support = true;
    options.env = env_;
    options.write_buffer_size = 100000;
5821
    options = CurrentOptions(options);
L
Lei Jin 已提交
5822
    CreateAndReopenWithCF({"pikachu"}, options);
5823 5824

    // Update key with values of larger size
5825
    int numValues = 10;
5826 5827
    for (int i = 0; i < numValues; i++) {
      std::string value = DummyString(i, 'a');
5828 5829
      ASSERT_OK(Put(1, "key", value));
      ASSERT_EQ(value, Get(1, "key"));
5830 5831 5832
    }

    // All 10 updates exist in the internal iterator
5833
    validateNumberOfEntries(numValues, 1);
5834

5835 5836 5837
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
5838
TEST_F(DBTest, InPlaceUpdateCallbackSmallerSize) {
5839
  do {
5840
    Options options;
5841 5842 5843 5844 5845 5846
    options.create_if_missing = true;
    options.inplace_update_support = true;

    options.env = env_;
    options.write_buffer_size = 100000;
    options.inplace_callback =
5847
      rocksdb::DBTest::updateInPlaceSmallerSize;
5848
    options = CurrentOptions(options);
L
Lei Jin 已提交
5849
    CreateAndReopenWithCF({"pikachu"}, options);
5850 5851 5852

    // Update key with values of smaller size
    int numValues = 10;
5853 5854
    ASSERT_OK(Put(1, "key", DummyString(numValues, 'a')));
    ASSERT_EQ(DummyString(numValues, 'c'), Get(1, "key"));
5855 5856

    for (int i = numValues; i > 0; i--) {
5857 5858
      ASSERT_OK(Put(1, "key", DummyString(i, 'a')));
      ASSERT_EQ(DummyString(i - 1, 'b'), Get(1, "key"));
5859
    }
5860 5861

    // Only 1 instance for that key.
5862
    validateNumberOfEntries(1, 1);
5863 5864 5865 5866

  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
5867
TEST_F(DBTest, InPlaceUpdateCallbackSmallerVarintSize) {
5868
  do {
5869
    Options options;
5870 5871 5872 5873 5874 5875 5876
    options.create_if_missing = true;
    options.inplace_update_support = true;

    options.env = env_;
    options.write_buffer_size = 100000;
    options.inplace_callback =
      rocksdb::DBTest::updateInPlaceSmallerVarintSize;
5877
    options = CurrentOptions(options);
L
Lei Jin 已提交
5878
    CreateAndReopenWithCF({"pikachu"}, options);
5879 5880 5881

    // Update key with values of smaller varint size
    int numValues = 265;
5882 5883
    ASSERT_OK(Put(1, "key", DummyString(numValues, 'a')));
    ASSERT_EQ(DummyString(numValues, 'c'), Get(1, "key"));
5884 5885

    for (int i = numValues; i > 0; i--) {
5886 5887
      ASSERT_OK(Put(1, "key", DummyString(i, 'a')));
      ASSERT_EQ(DummyString(1, 'b'), Get(1, "key"));
5888 5889 5890
    }

    // Only 1 instance for that key.
5891
    validateNumberOfEntries(1, 1);
5892

5893 5894 5895
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
5896
TEST_F(DBTest, InPlaceUpdateCallbackLargeNewValue) {
5897
  do {
5898
    Options options;
5899 5900 5901 5902 5903 5904
    options.create_if_missing = true;
    options.inplace_update_support = true;

    options.env = env_;
    options.write_buffer_size = 100000;
    options.inplace_callback =
5905
      rocksdb::DBTest::updateInPlaceLargerSize;
5906
    options = CurrentOptions(options);
L
Lei Jin 已提交
5907
    CreateAndReopenWithCF({"pikachu"}, options);
5908 5909 5910

    // Update key with values of larger size
    int numValues = 10;
5911
    for (int i = 0; i < numValues; i++) {
5912 5913
      ASSERT_OK(Put(1, "key", DummyString(i, 'a')));
      ASSERT_EQ(DummyString(i, 'c'), Get(1, "key"));
5914 5915 5916
    }

    // No inplace updates. All updates are puts with new seq number
5917
    // All 10 updates exist in the internal iterator
5918
    validateNumberOfEntries(numValues, 1);
5919 5920 5921 5922

  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
5923
TEST_F(DBTest, InPlaceUpdateCallbackNoAction) {
5924
  do {
5925
    Options options;
5926 5927 5928 5929 5930 5931 5932
    options.create_if_missing = true;
    options.inplace_update_support = true;

    options.env = env_;
    options.write_buffer_size = 100000;
    options.inplace_callback =
      rocksdb::DBTest::updateInPlaceNoAction;
5933
    options = CurrentOptions(options);
L
Lei Jin 已提交
5934
    CreateAndReopenWithCF({"pikachu"}, options);
5935

5936
    // Callback function requests no actions from db
5937 5938
    ASSERT_OK(Put(1, "key", DummyString(1, 'a')));
    ASSERT_EQ(Get(1, "key"), "NOT_FOUND");
5939 5940 5941 5942

  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
5943
TEST_F(DBTest, CompactionFilter) {
5944
  Options options = CurrentOptions();
5945
  options.max_open_files = -1;
5946 5947
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
5948
  options.compaction_filter_factory = std::make_shared<KeepFilterFactory>();
5949
  options = CurrentOptions(options);
L
Lei Jin 已提交
5950
  CreateAndReopenWithCF({"pikachu"}, options);
5951

5952
  // Write 100K keys, these are written to a few files in L0.
5953
  const std::string value(10, 'x');
5954
  for (int i = 0; i < 100000; i++) {
5955 5956
    char key[100];
    snprintf(key, sizeof(key), "B%010d", i);
5957
    Put(1, key, value);
5958
  }
5959
  ASSERT_OK(Flush(1));
5960 5961 5962 5963 5964

  // Push all files to the highest level L2. Verify that
  // the compaction is each level invokes the filter for
  // all the keys in that level.
  cfilter_count = 0;
5965
  dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
5966 5967
  ASSERT_EQ(cfilter_count, 100000);
  cfilter_count = 0;
5968
  dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
5969 5970
  ASSERT_EQ(cfilter_count, 100000);

5971 5972 5973
  ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1, 1), 0);
  ASSERT_NE(NumTableFilesAtLevel(2, 1), 0);
5974 5975
  cfilter_count = 0;

5976 5977 5978 5979 5980
  // All the files are in the lowest level.
  // Verify that all but the 100001st record
  // has sequence number zero. The 100001st record
  // is at the tip of this snapshot and cannot
  // be zeroed out.
5981
  // TODO: figure out sequence number squashtoo
5982 5983
  int count = 0;
  int total = 0;
5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998
  Arena arena;
  {
    ScopedArenaIterator iter(
        dbfull()->TEST_NewInternalIterator(&arena, handles_[1]));
    iter->SeekToFirst();
    ASSERT_OK(iter->status());
    while (iter->Valid()) {
      ParsedInternalKey ikey(Slice(), 0, kTypeValue);
      ikey.sequence = -1;
      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
      total++;
      if (ikey.sequence != 0) {
        count++;
      }
      iter->Next();
5999 6000
    }
  }
6001
  ASSERT_EQ(total, 100000);
6002 6003
  ASSERT_EQ(count, 1);

6004 6005
  // overwrite all the 100K keys once again.
  for (int i = 0; i < 100000; i++) {
6006 6007
    char key[100];
    snprintf(key, sizeof(key), "B%010d", i);
6008
    ASSERT_OK(Put(1, key, value));
6009
  }
6010
  ASSERT_OK(Flush(1));
6011 6012 6013 6014 6015

  // push all files to the highest level L2. This
  // means that all keys should pass at least once
  // via the compaction filter
  cfilter_count = 0;
6016
  dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
6017 6018
  ASSERT_EQ(cfilter_count, 100000);
  cfilter_count = 0;
6019
  dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
6020
  ASSERT_EQ(cfilter_count, 100000);
6021 6022 6023
  ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1, 1), 0);
  ASSERT_NE(NumTableFilesAtLevel(2, 1), 0);
6024 6025 6026

  // create a new database with the compaction
  // filter in such a way that it deletes all keys
6027
  options.compaction_filter_factory = std::make_shared<DeleteFilterFactory>();
6028
  options.create_if_missing = true;
L
Lei Jin 已提交
6029
  DestroyAndReopen(options);
L
Lei Jin 已提交
6030
  CreateAndReopenWithCF({"pikachu"}, options);
6031 6032

  // write all the keys once again.
6033
  for (int i = 0; i < 100000; i++) {
6034 6035
    char key[100];
    snprintf(key, sizeof(key), "B%010d", i);
6036
    ASSERT_OK(Put(1, key, value));
6037
  }
6038 6039 6040 6041
  ASSERT_OK(Flush(1));
  ASSERT_NE(NumTableFilesAtLevel(0, 1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1, 1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2, 1), 0);
6042 6043 6044 6045 6046 6047

  // Push all files to the highest level L2. This
  // triggers the compaction filter to delete all keys,
  // verify that at the end of the compaction process,
  // nothing is left.
  cfilter_count = 0;
6048
  dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
6049 6050
  ASSERT_EQ(cfilter_count, 100000);
  cfilter_count = 0;
6051
  dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
6052
  ASSERT_EQ(cfilter_count, 0);
6053 6054
  ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1, 1), 0);
6055

I
Igor Canadi 已提交
6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066
  {
    // Scan the entire database to ensure that nothing is left
    std::unique_ptr<Iterator> iter(
        db_->NewIterator(ReadOptions(), handles_[1]));
    iter->SeekToFirst();
    count = 0;
    while (iter->Valid()) {
      count++;
      iter->Next();
    }
    ASSERT_EQ(count, 0);
6067 6068 6069
  }

  // The sequence number of the remaining record
6070
  // is not zeroed out even though it is at the
6071
  // level Lmax because this record is at the tip
6072 6073
  // TODO: remove the following or design a different
  // test
6074
  count = 0;
6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087
  {
    ScopedArenaIterator iter(
        dbfull()->TEST_NewInternalIterator(&arena, handles_[1]));
    iter->SeekToFirst();
    ASSERT_OK(iter->status());
    while (iter->Valid()) {
      ParsedInternalKey ikey(Slice(), 0, kTypeValue);
      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
      ASSERT_NE(ikey.sequence, (unsigned)0);
      count++;
      iter->Next();
    }
    ASSERT_EQ(count, 0);
6088 6089 6090
  }
}

I
Igor Canadi 已提交
6091 6092 6093
// Tests the edge case where compaction does not produce any output -- all
// entries are deleted. The compaction should create bunch of 'DeleteFile'
// entries in VersionEdit, but none of the 'AddFile's.
I
Igor Sugak 已提交
6094
TEST_F(DBTest, CompactionFilterDeletesAll) {
I
Igor Canadi 已提交
6095 6096 6097 6098
  Options options;
  options.compaction_filter_factory = std::make_shared<DeleteFilterFactory>();
  options.disable_auto_compactions = true;
  options.create_if_missing = true;
6099
  options = CurrentOptions(options);
L
Lei Jin 已提交
6100
  DestroyAndReopen(options);
I
Igor Canadi 已提交
6101 6102 6103 6104

  // put some data
  for (int table = 0; table < 4; ++table) {
    for (int i = 0; i < 10 + table; ++i) {
6105
      Put(ToString(table * 100 + i), "val");
I
Igor Canadi 已提交
6106 6107 6108 6109 6110
    }
    Flush();
  }

  // this will produce empty file (delete compaction filter)
6111
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
6112
  ASSERT_EQ(0U, CountLiveFiles());
I
Igor Canadi 已提交
6113

L
Lei Jin 已提交
6114
  Reopen(options);
I
Igor Canadi 已提交
6115 6116 6117 6118 6119 6120 6121 6122 6123

  Iterator* itr = db_->NewIterator(ReadOptions());
  itr->SeekToFirst();
  // empty db
  ASSERT_TRUE(!itr->Valid());

  delete itr;
}

I
Igor Sugak 已提交
6124
TEST_F(DBTest, CompactionFilterWithValueChange) {
6125
  do {
6126
    Options options;
6127 6128
    options.num_levels = 3;
    options.max_mem_compaction_level = 0;
6129
    options.compaction_filter_factory =
6130
      std::make_shared<ChangeFilterFactory>();
6131
    options = CurrentOptions(options);
L
Lei Jin 已提交
6132
    CreateAndReopenWithCF({"pikachu"}, options);
6133

6134 6135 6136 6137 6138 6139 6140 6141 6142
    // Write 100K+1 keys, these are written to a few files
    // in L0. We do this so that the current snapshot points
    // to the 100001 key.The compaction filter is  not invoked
    // on keys that are visible via a snapshot because we
    // anyways cannot delete it.
    const std::string value(10, 'x');
    for (int i = 0; i < 100001; i++) {
      char key[100];
      snprintf(key, sizeof(key), "B%010d", i);
6143
      Put(1, key, value);
6144
    }
6145

6146
    // push all files to  lower levels
6147
    ASSERT_OK(Flush(1));
6148 6149 6150 6151
    if (option_config_ != kUniversalCompactionMultiLevel) {
      dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
      dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
    } else {
6152 6153
      dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                             nullptr);
6154
    }
6155

6156 6157 6158 6159
    // re-write all data again
    for (int i = 0; i < 100001; i++) {
      char key[100];
      snprintf(key, sizeof(key), "B%010d", i);
6160
      Put(1, key, value);
6161
    }
6162

6163 6164
    // push all files to  lower levels. This should
    // invoke the compaction filter for all 100000 keys.
6165
    ASSERT_OK(Flush(1));
6166 6167 6168 6169
    if (option_config_ != kUniversalCompactionMultiLevel) {
      dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
      dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
    } else {
6170 6171
      dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                             nullptr);
6172
    }
6173

6174 6175
    // verify that all keys now have the new value that
    // was set by the compaction process.
D
Danny Guo 已提交
6176
    for (int i = 0; i < 100001; i++) {
6177 6178
      char key[100];
      snprintf(key, sizeof(key), "B%010d", i);
6179
      std::string newvalue = Get(1, key);
6180 6181 6182
      ASSERT_EQ(newvalue.compare(NEW_VALUE), 0);
    }
  } while (ChangeCompactOptions());
6183 6184
}

I
Igor Sugak 已提交
6185
TEST_F(DBTest, CompactionFilterWithMergeOperator) {
6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211
  std::string one, two, three, four;
  PutFixed64(&one, 1);
  PutFixed64(&two, 2);
  PutFixed64(&three, 3);
  PutFixed64(&four, 4);

  Options options;
  options = CurrentOptions(options);
  options.create_if_missing = true;
  options.merge_operator = MergeOperators::CreateUInt64AddOperator();
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  // Filter out keys with value is 2.
  options.compaction_filter_factory =
      std::make_shared<ConditionalFilterFactory>(two);
  DestroyAndReopen(options);

  // In the same compaction, a value type needs to be deleted based on
  // compaction filter, and there is a merge type for the key. compaction
  // filter result is ignored.
  ASSERT_OK(db_->Put(WriteOptions(), "foo", two));
  ASSERT_OK(Flush());
  ASSERT_OK(db_->Merge(WriteOptions(), "foo", one));
  ASSERT_OK(Flush());
  std::string newvalue = Get("foo");
  ASSERT_EQ(newvalue, three);
6212
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
6213 6214 6215 6216 6217 6218 6219
  newvalue = Get("foo");
  ASSERT_EQ(newvalue, three);

  // value key can be deleted based on compaction filter, leaving only
  // merge keys.
  ASSERT_OK(db_->Put(WriteOptions(), "bar", two));
  ASSERT_OK(Flush());
6220
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
6221 6222 6223 6224
  newvalue = Get("bar");
  ASSERT_EQ("NOT_FOUND", newvalue);
  ASSERT_OK(db_->Merge(WriteOptions(), "bar", two));
  ASSERT_OK(Flush());
6225
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
6226 6227 6228 6229 6230 6231 6232 6233 6234 6235
  newvalue = Get("bar");
  ASSERT_EQ(two, two);

  // Compaction filter never applies to merge keys.
  ASSERT_OK(db_->Put(WriteOptions(), "foobar", one));
  ASSERT_OK(Flush());
  ASSERT_OK(db_->Merge(WriteOptions(), "foobar", two));
  ASSERT_OK(Flush());
  newvalue = Get("foobar");
  ASSERT_EQ(newvalue, three);
6236
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248
  newvalue = Get("foobar");
  ASSERT_EQ(newvalue, three);

  // In the same compaction, both of value type and merge type keys need to be
  // deleted based on compaction filter, and there is a merge type for the key.
  // For both keys, compaction filter results are ignored.
  ASSERT_OK(db_->Put(WriteOptions(), "barfoo", two));
  ASSERT_OK(Flush());
  ASSERT_OK(db_->Merge(WriteOptions(), "barfoo", two));
  ASSERT_OK(Flush());
  newvalue = Get("barfoo");
  ASSERT_EQ(newvalue, four);
6249
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
6250 6251 6252 6253
  newvalue = Get("barfoo");
  ASSERT_EQ(newvalue, four);
}

I
Igor Sugak 已提交
6254
TEST_F(DBTest, CompactionFilterContextManual) {
6255 6256 6257 6258 6259 6260 6261
  KeepFilterFactory* filter = new KeepFilterFactory();

  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.compaction_filter_factory.reset(filter);
  options.compression = kNoCompression;
  options.level0_file_num_compaction_trigger = 8;
L
Lei Jin 已提交
6262
  Reopen(options);
6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282
  int num_keys_per_file = 400;
  for (int j = 0; j < 3; j++) {
    // Write several keys.
    const std::string value(10, 'x');
    for (int i = 0; i < num_keys_per_file; i++) {
      char key[100];
      snprintf(key, sizeof(key), "B%08d%02d", i, j);
      Put(key, value);
    }
    dbfull()->TEST_FlushMemTable();
    // Make sure next file is much smaller so automatic compaction will not
    // be triggered.
    num_keys_per_file /= 2;
  }

  // Force a manual compaction
  cfilter_count = 0;
  filter->expect_manual_compaction_.store(true);
  filter->expect_full_compaction_.store(false);  // Manual compaction always
                                                 // set this flag.
6283
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
6284
  ASSERT_EQ(cfilter_count, 700);
S
sdong 已提交
6285
  ASSERT_EQ(NumSortedRuns(0), 1);
6286 6287

  // Verify total number of keys is correct after manual compaction.
6288
  {
6289 6290
    int count = 0;
    int total = 0;
6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303
    Arena arena;
    ScopedArenaIterator iter(dbfull()->TEST_NewInternalIterator(&arena));
    iter->SeekToFirst();
    ASSERT_OK(iter->status());
    while (iter->Valid()) {
      ParsedInternalKey ikey(Slice(), 0, kTypeValue);
      ikey.sequence = -1;
      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
      total++;
      if (ikey.sequence != 0) {
        count++;
      }
      iter->Next();
6304
    }
6305 6306
    ASSERT_EQ(total, 700);
    ASSERT_EQ(count, 1);
6307 6308 6309
  }
}

D
Danny Guo 已提交
6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429
class KeepFilterV2 : public CompactionFilterV2 {
 public:
  virtual std::vector<bool> Filter(int level,
                                   const SliceVector& keys,
                                   const SliceVector& existing_values,
                                   std::vector<std::string>* new_values,
                                   std::vector<bool>* values_changed)
    const override {
    cfilter_count++;
    std::vector<bool> ret;
    new_values->clear();
    values_changed->clear();
    for (unsigned int i = 0; i < keys.size(); ++i) {
      values_changed->push_back(false);
      ret.push_back(false);
    }
    return ret;
  }

  virtual const char* Name() const override {
    return "KeepFilterV2";
  }
};

class DeleteFilterV2 : public CompactionFilterV2 {
 public:
  virtual std::vector<bool> Filter(int level,
                                   const SliceVector& keys,
                                   const SliceVector& existing_values,
                                   std::vector<std::string>* new_values,
                                   std::vector<bool>* values_changed)
    const override {
    cfilter_count++;
    new_values->clear();
    values_changed->clear();
    std::vector<bool> ret;
    for (unsigned int i = 0; i < keys.size(); ++i) {
      values_changed->push_back(false);
      ret.push_back(true);
    }
    return ret;
  }

  virtual const char* Name() const override {
    return "DeleteFilterV2";
  }
};

class ChangeFilterV2 : public CompactionFilterV2 {
 public:
  virtual std::vector<bool> Filter(int level,
                                   const SliceVector& keys,
                                   const SliceVector& existing_values,
                                   std::vector<std::string>* new_values,
                                   std::vector<bool>* values_changed)
    const override {
    std::vector<bool> ret;
    new_values->clear();
    values_changed->clear();
    for (unsigned int i = 0; i < keys.size(); ++i) {
      values_changed->push_back(true);
      new_values->push_back(NEW_VALUE);
      ret.push_back(false);
    }
    return ret;
  }

  virtual const char* Name() const override {
    return "ChangeFilterV2";
  }
};

class KeepFilterFactoryV2 : public CompactionFilterFactoryV2 {
 public:
  explicit KeepFilterFactoryV2(const SliceTransform* prefix_extractor)
    : CompactionFilterFactoryV2(prefix_extractor) { }

  virtual std::unique_ptr<CompactionFilterV2>
  CreateCompactionFilterV2(
      const CompactionFilterContext& context) override {
    return std::unique_ptr<CompactionFilterV2>(new KeepFilterV2());
  }

  virtual const char* Name() const override {
    return "KeepFilterFactoryV2";
  }
};

class DeleteFilterFactoryV2 : public CompactionFilterFactoryV2 {
 public:
  explicit DeleteFilterFactoryV2(const SliceTransform* prefix_extractor)
    : CompactionFilterFactoryV2(prefix_extractor) { }

  virtual std::unique_ptr<CompactionFilterV2>
  CreateCompactionFilterV2(
      const CompactionFilterContext& context) override {
    return std::unique_ptr<CompactionFilterV2>(new DeleteFilterV2());
  }

  virtual const char* Name() const override {
    return "DeleteFilterFactoryV2";
  }
};

class ChangeFilterFactoryV2 : public CompactionFilterFactoryV2 {
 public:
  explicit ChangeFilterFactoryV2(const SliceTransform* prefix_extractor)
    : CompactionFilterFactoryV2(prefix_extractor) { }

  virtual std::unique_ptr<CompactionFilterV2>
  CreateCompactionFilterV2(
      const CompactionFilterContext& context) override {
    return std::unique_ptr<CompactionFilterV2>(new ChangeFilterV2());
  }

  virtual const char* Name() const override {
    return "ChangeFilterFactoryV2";
  }
};

I
Igor Sugak 已提交
6430
TEST_F(DBTest, CompactionFilterV2) {
D
Danny Guo 已提交
6431 6432 6433 6434
  Options options = CurrentOptions();
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
  // extract prefix
I
Igor Canadi 已提交
6435 6436 6437
  std::unique_ptr<const SliceTransform> prefix_extractor;
  prefix_extractor.reset(NewFixedPrefixTransform(8));

D
Danny Guo 已提交
6438
  options.compaction_filter_factory_v2
I
Igor Canadi 已提交
6439
    = std::make_shared<KeepFilterFactoryV2>(prefix_extractor.get());
D
Danny Guo 已提交
6440 6441 6442 6443
  // In a testing environment, we can only flush the application
  // compaction filter buffer using universal compaction
  option_config_ = kUniversalCompaction;
  options.compaction_style = (rocksdb::CompactionStyle)1;
L
Lei Jin 已提交
6444
  Reopen(options);
D
Danny Guo 已提交
6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458

  // Write 100K keys, these are written to a few files in L0.
  const std::string value(10, 'x');
  for (int i = 0; i < 100000; i++) {
    char key[100];
    snprintf(key, sizeof(key), "B%08d%010d", i , i);
    Put(key, value);
  }

  dbfull()->TEST_FlushMemTable();

  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
  dbfull()->TEST_CompactRange(1, nullptr, nullptr);

S
sdong 已提交
6459
  ASSERT_EQ(NumSortedRuns(0), 1);
D
Danny Guo 已提交
6460 6461 6462 6463

  // All the files are in the lowest level.
  int count = 0;
  int total = 0;
6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477
  {
    Arena arena;
    ScopedArenaIterator iter(dbfull()->TEST_NewInternalIterator(&arena));
    iter->SeekToFirst();
    ASSERT_OK(iter->status());
    while (iter->Valid()) {
      ParsedInternalKey ikey(Slice(), 0, kTypeValue);
      ikey.sequence = -1;
      ASSERT_EQ(ParseInternalKey(iter->key(), &ikey), true);
      total++;
      if (ikey.sequence != 0) {
        count++;
      }
      iter->Next();
D
Danny Guo 已提交
6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488
    }
  }

  ASSERT_EQ(total, 100000);
  // 1 snapshot only. Since we are using universal compacton,
  // the sequence no is cleared for better compression
  ASSERT_EQ(count, 1);

  // create a new database with the compaction
  // filter in such a way that it deletes all keys
  options.compaction_filter_factory_v2 =
I
Igor Canadi 已提交
6489
    std::make_shared<DeleteFilterFactoryV2>(prefix_extractor.get());
D
Danny Guo 已提交
6490
  options.create_if_missing = true;
L
Lei Jin 已提交
6491
  DestroyAndReopen(options);
D
Danny Guo 已提交
6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507

  // write all the keys once again.
  for (int i = 0; i < 100000; i++) {
    char key[100];
    snprintf(key, sizeof(key), "B%08d%010d", i, i);
    Put(key, value);
  }

  dbfull()->TEST_FlushMemTable();
  ASSERT_NE(NumTableFilesAtLevel(0), 0);

  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
  dbfull()->TEST_CompactRange(1, nullptr, nullptr);
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);

  // Scan the entire database to ensure that nothing is left
6508
  Iterator* iter = db_->NewIterator(ReadOptions());
D
Danny Guo 已提交
6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519
  iter->SeekToFirst();
  count = 0;
  while (iter->Valid()) {
    count++;
    iter->Next();
  }

  ASSERT_EQ(count, 0);
  delete iter;
}

I
Igor Sugak 已提交
6520
TEST_F(DBTest, CompactionFilterV2WithValueChange) {
D
Danny Guo 已提交
6521 6522 6523
  Options options = CurrentOptions();
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
I
Igor Canadi 已提交
6524 6525
  std::unique_ptr<const SliceTransform> prefix_extractor;
  prefix_extractor.reset(NewFixedPrefixTransform(8));
D
Danny Guo 已提交
6526
  options.compaction_filter_factory_v2 =
I
Igor Canadi 已提交
6527
    std::make_shared<ChangeFilterFactoryV2>(prefix_extractor.get());
D
Danny Guo 已提交
6528 6529 6530 6531
  // In a testing environment, we can only flush the application
  // compaction filter buffer using universal compaction
  option_config_ = kUniversalCompaction;
  options.compaction_style = (rocksdb::CompactionStyle)1;
6532
  options = CurrentOptions(options);
L
Lei Jin 已提交
6533
  Reopen(options);
D
Danny Guo 已提交
6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561

  // Write 100K+1 keys, these are written to a few files
  // in L0. We do this so that the current snapshot points
  // to the 100001 key.The compaction filter is  not invoked
  // on keys that are visible via a snapshot because we
  // anyways cannot delete it.
  const std::string value(10, 'x');
  for (int i = 0; i < 100001; i++) {
    char key[100];
    snprintf(key, sizeof(key), "B%08d%010d", i, i);
    Put(key, value);
  }

  // push all files to lower levels
  dbfull()->TEST_FlushMemTable();
  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
  dbfull()->TEST_CompactRange(1, nullptr, nullptr);

  // verify that all keys now have the new value that
  // was set by the compaction process.
  for (int i = 0; i < 100001; i++) {
    char key[100];
    snprintf(key, sizeof(key), "B%08d%010d", i, i);
    std::string newvalue = Get(key);
    ASSERT_EQ(newvalue.compare(NEW_VALUE), 0);
  }
}

I
Igor Sugak 已提交
6562
TEST_F(DBTest, CompactionFilterV2NULLPrefix) {
6563 6564 6565
  Options options = CurrentOptions();
  options.num_levels = 3;
  options.max_mem_compaction_level = 0;
I
Igor Canadi 已提交
6566 6567
  std::unique_ptr<const SliceTransform> prefix_extractor;
  prefix_extractor.reset(NewFixedPrefixTransform(8));
6568
  options.compaction_filter_factory_v2 =
I
Igor Canadi 已提交
6569
    std::make_shared<ChangeFilterFactoryV2>(prefix_extractor.get());
6570 6571 6572 6573
  // In a testing environment, we can only flush the application
  // compaction filter buffer using universal compaction
  option_config_ = kUniversalCompaction;
  options.compaction_style = (rocksdb::CompactionStyle)1;
L
Lei Jin 已提交
6574
  Reopen(options);
6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607

  // Write 100K+1 keys, these are written to a few files
  // in L0. We do this so that the current snapshot points
  // to the 100001 key.The compaction filter is  not invoked
  // on keys that are visible via a snapshot because we
  // anyways cannot delete it.
  const std::string value(10, 'x');
  char first_key[100];
  snprintf(first_key, sizeof(first_key), "%s0000%010d", "NULL", 1);
  Put(first_key, value);
  for (int i = 1; i < 100000; i++) {
    char key[100];
    snprintf(key, sizeof(key), "%08d%010d", i, i);
    Put(key, value);
  }

  char last_key[100];
  snprintf(last_key, sizeof(last_key), "%s0000%010d", "NULL", 2);
  Put(last_key, value);

  // push all files to lower levels
  dbfull()->TEST_FlushMemTable();
  dbfull()->TEST_CompactRange(0, nullptr, nullptr);

  // verify that all keys now have the new value that
  // was set by the compaction process.
  std::string newvalue = Get(first_key);
  ASSERT_EQ(newvalue.compare(NEW_VALUE), 0);
  newvalue = Get(last_key);
  ASSERT_EQ(newvalue.compare(NEW_VALUE), 0);
  for (int i = 1; i < 100000; i++) {
    char key[100];
    snprintf(key, sizeof(key), "%08d%010d", i, i);
I
Igor Canadi 已提交
6608
    newvalue = Get(key);
6609 6610 6611 6612
    ASSERT_EQ(newvalue.compare(NEW_VALUE), 0);
  }
}

I
Igor Sugak 已提交
6613
TEST_F(DBTest, SparseMerge) {
6614 6615 6616
  do {
    Options options = CurrentOptions();
    options.compression = kNoCompression;
L
Lei Jin 已提交
6617
    CreateAndReopenWithCF({"pikachu"}, options);
6618

6619
    FillLevels("A", "Z", 1);
6620 6621 6622 6623 6624 6625 6626 6627

    // Suppose there is:
    //    small amount of data with prefix A
    //    large amount of data with prefix B
    //    small amount of data with prefix C
    // and that recent updates have made small changes to all three prefixes.
    // Check that we do not do a compaction that merges all of B in one shot.
    const std::string value(1000, 'x');
6628
    Put(1, "A", "va");
6629 6630 6631 6632
    // Write approximately 100MB of "B" values
    for (int i = 0; i < 100000; i++) {
      char key[100];
      snprintf(key, sizeof(key), "B%010d", i);
6633
      Put(1, key, value);
6634
    }
6635 6636 6637
    Put(1, "C", "vc");
    ASSERT_OK(Flush(1));
    dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
6638

6639
    // Make sparse update
6640 6641 6642 6643
    Put(1, "A", "va2");
    Put(1, "B100", "bvalue2");
    Put(1, "C", "vc2");
    ASSERT_OK(Flush(1));
6644 6645 6646

    // Compactions should not cause us to create a situation where
    // a file overlaps too much data at the next level.
6647 6648
    ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(handles_[1]),
              20 * 1048576);
6649
    dbfull()->TEST_CompactRange(0, nullptr, nullptr);
6650 6651
    ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(handles_[1]),
              20 * 1048576);
6652
    dbfull()->TEST_CompactRange(1, nullptr, nullptr);
6653 6654
    ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(handles_[1]),
              20 * 1048576);
6655
  } while (ChangeCompactOptions());
6656 6657
}

J
jorlow@chromium.org 已提交
6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668
static bool Between(uint64_t val, uint64_t low, uint64_t high) {
  bool result = (val >= low) && (val <= high);
  if (!result) {
    fprintf(stderr, "Value %llu is not in range [%llu, %llu]\n",
            (unsigned long long)(val),
            (unsigned long long)(low),
            (unsigned long long)(high));
  }
  return result;
}

6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774
TEST_F(DBTest, ApproximateSizesMemTable) {
  Options options;
  options.write_buffer_size = 100000000;  // Large write buffer
  options.compression = kNoCompression;
  options.create_if_missing = true;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  const int N = 128;
  Random rnd(301);
  for (int i = 0; i < N; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
  }

  uint64_t size;
  std::string start = Key(50);
  std::string end = Key(60);
  Range r(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_GT(size, 6000);
  ASSERT_LT(size, 204800);
  // Zero if not including mem table
  db_->GetApproximateSizes(&r, 1, &size, false);
  ASSERT_EQ(size, 0);

  start = Key(500);
  end = Key(600);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  for (int i = 0; i < N; i++) {
    ASSERT_OK(Put(Key(1000 + i), RandomString(&rnd, 1024)));
  }

  start = Key(500);
  end = Key(600);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  start = Key(100);
  end = Key(1020);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_GT(size, 6000);

  options.max_write_buffer_number = 8;
  options.min_write_buffer_number_to_merge = 5;
  options.write_buffer_size = 1024 * N;  // Not very large
  DestroyAndReopen(options);

  int keys[N * 3];
  for (int i = 0; i < N; i++) {
    keys[i * 3] = i * 5;
    keys[i * 3 + 1] = i * 5 + 1;
    keys[i * 3 + 2] = i * 5 + 2;
  }
  std::random_shuffle(std::begin(keys), std::end(keys));

  for (int i = 0; i < N * 3; i++) {
    ASSERT_OK(Put(Key(keys[i] + 1000), RandomString(&rnd, 1024)));
  }

  start = Key(100);
  end = Key(300);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_GT(size, 6000);

  start = Key(2100);
  end = Key(2300);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
  uint64_t size_with_mt, size_without_mt;
  db_->GetApproximateSizes(&r, 1, &size_with_mt, true);
  ASSERT_GT(size_with_mt, 6000);
  db_->GetApproximateSizes(&r, 1, &size_without_mt, false);
  ASSERT_EQ(size_without_mt, 0);

  Flush();

  for (int i = 0; i < N; i++) {
    ASSERT_OK(Put(Key(i + 1000), RandomString(&rnd, 1024)));
  }

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
  db_->GetApproximateSizes(&r, 1, &size_with_mt, true);
  db_->GetApproximateSizes(&r, 1, &size_without_mt, false);
  ASSERT_GT(size_with_mt, size_without_mt);
  ASSERT_GT(size_without_mt, 6000);
}

I
Igor Sugak 已提交
6775
TEST_F(DBTest, ApproximateSizes) {
S
Sanjay Ghemawat 已提交
6776
  do {
6777
    Options options;
S
Sanjay Ghemawat 已提交
6778 6779
    options.write_buffer_size = 100000000;        // Large write buffer
    options.compression = kNoCompression;
L
Lei Jin 已提交
6780
    options.create_if_missing = true;
6781
    options = CurrentOptions(options);
L
Lei Jin 已提交
6782
    DestroyAndReopen(options);
L
Lei Jin 已提交
6783
    CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
6784

6785
    ASSERT_TRUE(Between(Size("", "xyz", 1), 0, 0));
L
Lei Jin 已提交
6786
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
6787
    ASSERT_TRUE(Between(Size("", "xyz", 1), 0, 0));
J
jorlow@chromium.org 已提交
6788

S
Sanjay Ghemawat 已提交
6789
    // Write 8MB (80 values, each 100K)
6790
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
S
Sanjay Ghemawat 已提交
6791 6792 6793 6794 6795
    const int N = 80;
    static const int S1 = 100000;
    static const int S2 = 105000;  // Allow some expansion from metadata
    Random rnd(301);
    for (int i = 0; i < N; i++) {
6796
      ASSERT_OK(Put(1, Key(i), RandomString(&rnd, S1)));
S
Sanjay Ghemawat 已提交
6797
    }
J
jorlow@chromium.org 已提交
6798

S
Sanjay Ghemawat 已提交
6799
    // 0 because GetApproximateSizes() does not account for memtable space
6800
    ASSERT_TRUE(Between(Size("", Key(50), 1), 0, 0));
D
 
dgrogan@chromium.org 已提交
6801

S
Sanjay Ghemawat 已提交
6802 6803
    // Check sizes across recovery by reopening a few times
    for (int run = 0; run < 3; run++) {
L
Lei Jin 已提交
6804
      ReopenWithColumnFamilies({"default", "pikachu"}, options);
D
dgrogan@chromium.org 已提交
6805

S
Sanjay Ghemawat 已提交
6806 6807
      for (int compact_start = 0; compact_start < N; compact_start += 10) {
        for (int i = 0; i < N; i += 10) {
6808 6809 6810 6811
          ASSERT_TRUE(Between(Size("", Key(i), 1), S1 * i, S2 * i));
          ASSERT_TRUE(Between(Size("", Key(i) + ".suffix", 1), S1 * (i + 1),
                              S2 * (i + 1)));
          ASSERT_TRUE(Between(Size(Key(i), Key(i + 10), 1), S1 * 10, S2 * 10));
S
Sanjay Ghemawat 已提交
6812
        }
6813 6814 6815
        ASSERT_TRUE(Between(Size("", Key(50), 1), S1 * 50, S2 * 50));
        ASSERT_TRUE(
            Between(Size("", Key(50) + ".suffix", 1), S1 * 50, S2 * 50));
S
Sanjay Ghemawat 已提交
6816 6817 6818 6819 6820

        std::string cstart_str = Key(compact_start);
        std::string cend_str = Key(compact_start + 9);
        Slice cstart = cstart_str;
        Slice cend = cend_str;
6821
        dbfull()->TEST_CompactRange(0, &cstart, &cend, handles_[1]);
J
jorlow@chromium.org 已提交
6822
      }
D
dgrogan@chromium.org 已提交
6823

6824 6825
      ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
      ASSERT_GT(NumTableFilesAtLevel(1, 1), 0);
S
Sanjay Ghemawat 已提交
6826
    }
6827
    // ApproximateOffsetOf() is not yet implemented in plain table format.
I
Igor Canadi 已提交
6828
  } while (ChangeOptions(kSkipUniversalCompaction | kSkipFIFOCompaction |
S
Stanislau Hlebik 已提交
6829
                         kSkipPlainTable | kSkipHashIndex));
J
jorlow@chromium.org 已提交
6830 6831
}

I
Igor Sugak 已提交
6832
TEST_F(DBTest, ApproximateSizes_MixOfSmallAndLarge) {
S
Sanjay Ghemawat 已提交
6833 6834 6835
  do {
    Options options = CurrentOptions();
    options.compression = kNoCompression;
L
Lei Jin 已提交
6836
    CreateAndReopenWithCF({"pikachu"}, options);
J
jorlow@chromium.org 已提交
6837

S
Sanjay Ghemawat 已提交
6838 6839
    Random rnd(301);
    std::string big1 = RandomString(&rnd, 100000);
6840 6841 6842 6843 6844 6845 6846 6847
    ASSERT_OK(Put(1, Key(0), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(1, Key(1), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(1, Key(2), big1));
    ASSERT_OK(Put(1, Key(3), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(1, Key(4), big1));
    ASSERT_OK(Put(1, Key(5), RandomString(&rnd, 10000)));
    ASSERT_OK(Put(1, Key(6), RandomString(&rnd, 300000)));
    ASSERT_OK(Put(1, Key(7), RandomString(&rnd, 10000)));
S
Sanjay Ghemawat 已提交
6848 6849 6850

    // Check sizes across recovery by reopening a few times
    for (int run = 0; run < 3; run++) {
L
Lei Jin 已提交
6851
      ReopenWithColumnFamilies({"default", "pikachu"}, options);
S
Sanjay Ghemawat 已提交
6852

6853 6854 6855 6856 6857 6858 6859 6860 6861
      ASSERT_TRUE(Between(Size("", Key(0), 1), 0, 0));
      ASSERT_TRUE(Between(Size("", Key(1), 1), 10000, 11000));
      ASSERT_TRUE(Between(Size("", Key(2), 1), 20000, 21000));
      ASSERT_TRUE(Between(Size("", Key(3), 1), 120000, 121000));
      ASSERT_TRUE(Between(Size("", Key(4), 1), 130000, 131000));
      ASSERT_TRUE(Between(Size("", Key(5), 1), 230000, 231000));
      ASSERT_TRUE(Between(Size("", Key(6), 1), 240000, 241000));
      ASSERT_TRUE(Between(Size("", Key(7), 1), 540000, 541000));
      ASSERT_TRUE(Between(Size("", Key(8), 1), 550000, 560000));
S
Sanjay Ghemawat 已提交
6862

6863
      ASSERT_TRUE(Between(Size(Key(3), Key(5), 1), 110000, 111000));
S
Sanjay Ghemawat 已提交
6864

6865
      dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
S
Sanjay Ghemawat 已提交
6866
    }
6867 6868
    // ApproximateOffsetOf() is not yet implemented in plain table format.
  } while (ChangeOptions(kSkipPlainTable));
J
jorlow@chromium.org 已提交
6869 6870
}

I
Igor Sugak 已提交
6871
TEST_F(DBTest, IteratorPinsRef) {
6872
  do {
L
Lei Jin 已提交
6873
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
6874
    Put(1, "foo", "hello");
J
jorlow@chromium.org 已提交
6875

6876
    // Get iterator that will yield the current contents of the DB.
6877
    Iterator* iter = db_->NewIterator(ReadOptions(), handles_[1]);
J
jorlow@chromium.org 已提交
6878

6879
    // Write to force compactions
6880
    Put(1, "foo", "newvalue1");
6881
    for (int i = 0; i < 100; i++) {
6882 6883
      // 100K values
      ASSERT_OK(Put(1, Key(i), Key(i) + std::string(100000, 'v')));
6884
    }
6885
    Put(1, "foo", "newvalue2");
J
jorlow@chromium.org 已提交
6886

6887 6888 6889 6890 6891 6892 6893 6894
    iter->SeekToFirst();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ("foo", iter->key().ToString());
    ASSERT_EQ("hello", iter->value().ToString());
    iter->Next();
    ASSERT_TRUE(!iter->Valid());
    delete iter;
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
6895 6896
}

I
Igor Sugak 已提交
6897
TEST_F(DBTest, Snapshot) {
6898 6899
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
S
Sanjay Ghemawat 已提交
6900
  do {
6901
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions(options_override));
6902 6903
    Put(0, "foo", "0v1");
    Put(1, "foo", "1v1");
6904

S
Sanjay Ghemawat 已提交
6905
    const Snapshot* s1 = db_->GetSnapshot();
6906 6907 6908
    ASSERT_EQ(1U, GetNumSnapshots());
    uint64_t time_snap1 = GetTimeOldestSnapshots();
    ASSERT_GT(time_snap1, 0U);
6909 6910
    Put(0, "foo", "0v2");
    Put(1, "foo", "1v2");
6911

S
sdong 已提交
6912
    env_->addon_time_.fetch_add(1);
6913

S
Sanjay Ghemawat 已提交
6914
    const Snapshot* s2 = db_->GetSnapshot();
6915 6916
    ASSERT_EQ(2U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
6917 6918
    Put(0, "foo", "0v3");
    Put(1, "foo", "1v3");
6919

S
Sanjay Ghemawat 已提交
6920
    const Snapshot* s3 = db_->GetSnapshot();
6921 6922
    ASSERT_EQ(3U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
S
Sanjay Ghemawat 已提交
6923

6924 6925 6926 6927 6928 6929 6930 6931 6932 6933
    Put(0, "foo", "0v4");
    Put(1, "foo", "1v4");
    ASSERT_EQ("0v1", Get(0, "foo", s1));
    ASSERT_EQ("1v1", Get(1, "foo", s1));
    ASSERT_EQ("0v2", Get(0, "foo", s2));
    ASSERT_EQ("1v2", Get(1, "foo", s2));
    ASSERT_EQ("0v3", Get(0, "foo", s3));
    ASSERT_EQ("1v3", Get(1, "foo", s3));
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
S
Sanjay Ghemawat 已提交
6934 6935

    db_->ReleaseSnapshot(s3);
6936 6937
    ASSERT_EQ(2U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
6938 6939 6940 6941 6942 6943
    ASSERT_EQ("0v1", Get(0, "foo", s1));
    ASSERT_EQ("1v1", Get(1, "foo", s1));
    ASSERT_EQ("0v2", Get(0, "foo", s2));
    ASSERT_EQ("1v2", Get(1, "foo", s2));
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
J
jorlow@chromium.org 已提交
6944

S
Sanjay Ghemawat 已提交
6945
    db_->ReleaseSnapshot(s1);
6946 6947 6948 6949
    ASSERT_EQ("0v2", Get(0, "foo", s2));
    ASSERT_EQ("1v2", Get(1, "foo", s2));
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
6950 6951
    ASSERT_EQ(1U, GetNumSnapshots());
    ASSERT_LT(time_snap1, GetTimeOldestSnapshots());
6952

S
Sanjay Ghemawat 已提交
6953
    db_->ReleaseSnapshot(s2);
6954
    ASSERT_EQ(0U, GetNumSnapshots());
6955 6956
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
6957
  } while (ChangeOptions(kSkipHashCuckoo));
S
Sanjay Ghemawat 已提交
6958
}
J
jorlow@chromium.org 已提交
6959

I
Igor Sugak 已提交
6960
TEST_F(DBTest, HiddenValuesAreRemoved) {
6961 6962
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
S
Sanjay Ghemawat 已提交
6963
  do {
6964
    Options options = CurrentOptions(options_override);
I
Igor Canadi 已提交
6965
    options.max_background_flushes = 0;
L
Lei Jin 已提交
6966
    CreateAndReopenWithCF({"pikachu"}, options);
S
Sanjay Ghemawat 已提交
6967
    Random rnd(301);
6968
    FillLevels("a", "z", 1);
S
Sanjay Ghemawat 已提交
6969 6970

    std::string big = RandomString(&rnd, 50000);
6971 6972
    Put(1, "foo", big);
    Put(1, "pastfoo", "v");
S
Sanjay Ghemawat 已提交
6973
    const Snapshot* snapshot = db_->GetSnapshot();
6974 6975
    Put(1, "foo", "tiny");
    Put(1, "pastfoo2", "v2");  // Advance sequence number one more
S
Sanjay Ghemawat 已提交
6976

6977 6978
    ASSERT_OK(Flush(1));
    ASSERT_GT(NumTableFilesAtLevel(0, 1), 0);
S
Sanjay Ghemawat 已提交
6979

6980 6981
    ASSERT_EQ(big, Get(1, "foo", snapshot));
    ASSERT_TRUE(Between(Size("", "pastfoo", 1), 50000, 60000));
S
Sanjay Ghemawat 已提交
6982
    db_->ReleaseSnapshot(snapshot);
6983
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ tiny, " + big + " ]");
S
Sanjay Ghemawat 已提交
6984
    Slice x("x");
6985 6986 6987 6988 6989 6990 6991 6992
    dbfull()->TEST_CompactRange(0, nullptr, &x, handles_[1]);
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ tiny ]");
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
    ASSERT_GE(NumTableFilesAtLevel(1, 1), 1);
    dbfull()->TEST_CompactRange(1, nullptr, &x, handles_[1]);
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ tiny ]");

    ASSERT_TRUE(Between(Size("", "pastfoo", 1), 0, 1000));
6993 6994
    // ApproximateOffsetOf() is not yet implemented in plain table format,
    // which is used by Size().
6995
    // skip HashCuckooRep as it does not support snapshot
I
Igor Canadi 已提交
6996 6997
  } while (ChangeOptions(kSkipUniversalCompaction | kSkipFIFOCompaction |
                         kSkipPlainTable | kSkipHashCuckoo));
J
jorlow@chromium.org 已提交
6998 6999
}

I
Igor Sugak 已提交
7000
TEST_F(DBTest, CompactBetweenSnapshots) {
7001 7002
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
7003
  do {
7004
    Options options = CurrentOptions(options_override);
7005
    options.disable_auto_compactions = true;
L
Lei Jin 已提交
7006
    CreateAndReopenWithCF({"pikachu"}, options);
7007
    Random rnd(301);
7008
    FillLevels("a", "z", 1);
7009

7010
    Put(1, "foo", "first");
7011
    const Snapshot* snapshot1 = db_->GetSnapshot();
7012 7013 7014
    Put(1, "foo", "second");
    Put(1, "foo", "third");
    Put(1, "foo", "fourth");
7015
    const Snapshot* snapshot2 = db_->GetSnapshot();
7016 7017
    Put(1, "foo", "fifth");
    Put(1, "foo", "sixth");
7018 7019 7020

    // All entries (including duplicates) exist
    // before any compaction is triggered.
7021 7022 7023 7024 7025
    ASSERT_OK(Flush(1));
    ASSERT_EQ("sixth", Get(1, "foo"));
    ASSERT_EQ("fourth", Get(1, "foo", snapshot2));
    ASSERT_EQ("first", Get(1, "foo", snapshot1));
    ASSERT_EQ(AllEntriesFor("foo", 1),
7026 7027 7028 7029
              "[ sixth, fifth, fourth, third, second, first ]");

    // After a compaction, "second", "third" and "fifth" should
    // be removed
7030
    FillLevels("a", "z", 1);
7031 7032
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
7033 7034 7035 7036
    ASSERT_EQ("sixth", Get(1, "foo"));
    ASSERT_EQ("fourth", Get(1, "foo", snapshot2));
    ASSERT_EQ("first", Get(1, "foo", snapshot1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ sixth, fourth, first ]");
7037 7038 7039

    // after we release the snapshot1, only two values left
    db_->ReleaseSnapshot(snapshot1);
7040
    FillLevels("a", "z", 1);
7041 7042
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
7043 7044 7045

    // We have only one valid snapshot snapshot2. Since snapshot1 is
    // not valid anymore, "first" should be removed by a compaction.
7046 7047 7048
    ASSERT_EQ("sixth", Get(1, "foo"));
    ASSERT_EQ("fourth", Get(1, "foo", snapshot2));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ sixth, fourth ]");
7049 7050 7051

    // after we release the snapshot2, only one value should be left
    db_->ReleaseSnapshot(snapshot2);
7052
    FillLevels("a", "z", 1);
7053 7054
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
7055 7056
    ASSERT_EQ("sixth", Get(1, "foo"));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ sixth ]");
7057
    // skip HashCuckooRep as it does not support snapshot
I
Igor Canadi 已提交
7058
  } while (ChangeOptions(kSkipHashCuckoo | kSkipFIFOCompaction));
7059 7060
}

I
Igor Sugak 已提交
7061
TEST_F(DBTest, DeletionMarkers1) {
I
Igor Canadi 已提交
7062 7063
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
L
Lei Jin 已提交
7064
  CreateAndReopenWithCF({"pikachu"}, options);
7065 7066 7067 7068 7069
  Put(1, "foo", "v1");
  ASSERT_OK(Flush(1));
  const int last = CurrentOptions().max_mem_compaction_level;
  // foo => v1 is now in last level
  ASSERT_EQ(NumTableFilesAtLevel(last, 1), 1);
7070 7071

  // Place a table at level last-1 to prevent merging with preceding mutation
7072 7073 7074 7075 7076 7077 7078 7079 7080 7081
  Put(1, "a", "begin");
  Put(1, "z", "end");
  Flush(1);
  ASSERT_EQ(NumTableFilesAtLevel(last, 1), 1);
  ASSERT_EQ(NumTableFilesAtLevel(last - 1, 1), 1);

  Delete(1, "foo");
  Put(1, "foo", "v2");
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, DEL, v1 ]");
  ASSERT_OK(Flush(1));  // Moves to level last-2
7082
  if (CurrentOptions().purge_redundant_kvs_while_flush) {
7083
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, v1 ]");
7084
  } else {
7085
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, DEL, v1 ]");
7086
  }
G
Gabor Cselle 已提交
7087
  Slice z("z");
7088
  dbfull()->TEST_CompactRange(last - 2, nullptr, &z, handles_[1]);
J
jorlow@chromium.org 已提交
7089 7090
  // DEL eliminated, but v1 remains because we aren't compacting that level
  // (DEL can be eliminated because v2 hides v1).
7091 7092
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, v1 ]");
  dbfull()->TEST_CompactRange(last - 1, nullptr, nullptr, handles_[1]);
7093 7094
  // Merging last-1 w/ last, so we are the base level for "foo", so
  // DEL is removed.  (as is v1).
7095
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2 ]");
J
jorlow@chromium.org 已提交
7096 7097
}

I
Igor Sugak 已提交
7098
TEST_F(DBTest, DeletionMarkers2) {
I
Igor Canadi 已提交
7099 7100
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
L
Lei Jin 已提交
7101
  CreateAndReopenWithCF({"pikachu"}, options);
7102 7103 7104 7105 7106
  Put(1, "foo", "v1");
  ASSERT_OK(Flush(1));
  const int last = CurrentOptions().max_mem_compaction_level;
  // foo => v1 is now in last level
  ASSERT_EQ(NumTableFilesAtLevel(last, 1), 1);
7107 7108

  // Place a table at level last-1 to prevent merging with preceding mutation
7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119
  Put(1, "a", "begin");
  Put(1, "z", "end");
  Flush(1);
  ASSERT_EQ(NumTableFilesAtLevel(last, 1), 1);
  ASSERT_EQ(NumTableFilesAtLevel(last - 1, 1), 1);

  Delete(1, "foo");
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v1 ]");
  ASSERT_OK(Flush(1));  // Moves to level last-2
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v1 ]");
  dbfull()->TEST_CompactRange(last - 2, nullptr, nullptr, handles_[1]);
7120
  // DEL kept: "last" file overlaps
7121 7122
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v1 ]");
  dbfull()->TEST_CompactRange(last - 1, nullptr, nullptr, handles_[1]);
7123 7124
  // Merging last-1 w/ last, so we are the base level for "foo", so
  // DEL is removed.  (as is v1).
7125
  ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
J
jorlow@chromium.org 已提交
7126 7127
}

I
Igor Sugak 已提交
7128
TEST_F(DBTest, OverlapInLevel0) {
S
Sanjay Ghemawat 已提交
7129
  do {
I
Igor Canadi 已提交
7130 7131
    Options options = CurrentOptions();
    options.max_background_flushes = 0;
L
Lei Jin 已提交
7132
    CreateAndReopenWithCF({"pikachu"}, options);
7133
    int tmp = CurrentOptions().max_mem_compaction_level;
7134
    ASSERT_EQ(tmp, 2) << "Fix test to match config";
G
Gabor Cselle 已提交
7135

N
Naman Gupta 已提交
7136
    //Fill levels 1 and 2 to disable the pushing of new memtables to levels > 0.
7137 7138 7139 7140 7141 7142 7143
    ASSERT_OK(Put(1, "100", "v100"));
    ASSERT_OK(Put(1, "999", "v999"));
    Flush(1);
    ASSERT_OK(Delete(1, "100"));
    ASSERT_OK(Delete(1, "999"));
    Flush(1);
    ASSERT_EQ("0,1,1", FilesPerLevel(1));
S
Sanjay Ghemawat 已提交
7144 7145 7146 7147 7148

    // Make files spanning the following ranges in level-0:
    //  files[0]  200 .. 900
    //  files[1]  300 .. 500
    // Note that files are sorted by smallest key.
7149 7150 7151 7152 7153 7154 7155 7156
    ASSERT_OK(Put(1, "300", "v300"));
    ASSERT_OK(Put(1, "500", "v500"));
    Flush(1);
    ASSERT_OK(Put(1, "200", "v200"));
    ASSERT_OK(Put(1, "600", "v600"));
    ASSERT_OK(Put(1, "900", "v900"));
    Flush(1);
    ASSERT_EQ("2,1,1", FilesPerLevel(1));
G
Gabor Cselle 已提交
7157

S
Sanjay Ghemawat 已提交
7158
    // Compact away the placeholder files we created initially
7159 7160 7161
    dbfull()->TEST_CompactRange(1, nullptr, nullptr, handles_[1]);
    dbfull()->TEST_CompactRange(2, nullptr, nullptr, handles_[1]);
    ASSERT_EQ("2", FilesPerLevel(1));
G
Gabor Cselle 已提交
7162

S
Sanjay Ghemawat 已提交
7163 7164 7165
    // Do a memtable compaction.  Before bug-fix, the compaction would
    // not detect the overlap with level-0 files and would incorrectly place
    // the deletion in a deeper level.
7166 7167 7168 7169
    ASSERT_OK(Delete(1, "600"));
    Flush(1);
    ASSERT_EQ("3", FilesPerLevel(1));
    ASSERT_EQ("NOT_FOUND", Get(1, "600"));
I
Igor Canadi 已提交
7170
  } while (ChangeOptions(kSkipUniversalCompaction | kSkipFIFOCompaction));
G
Gabor Cselle 已提交
7171 7172
}

I
Igor Sugak 已提交
7173
TEST_F(DBTest, L0_CompactionBug_Issue44_a) {
7174
  do {
L
Lei Jin 已提交
7175
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
7176
    ASSERT_OK(Put(1, "b", "v"));
L
Lei Jin 已提交
7177
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7178 7179
    ASSERT_OK(Delete(1, "b"));
    ASSERT_OK(Delete(1, "a"));
L
Lei Jin 已提交
7180
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7181
    ASSERT_OK(Delete(1, "a"));
L
Lei Jin 已提交
7182
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7183
    ASSERT_OK(Put(1, "a", "v"));
L
Lei Jin 已提交
7184 7185
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7186
    ASSERT_EQ("(a->v)", Contents(1));
7187
    env_->SleepForMicroseconds(1000000);  // Wait for compaction to finish
7188
    ASSERT_EQ("(a->v)", Contents(1));
7189
  } while (ChangeCompactOptions());
H
Hans Wennborg 已提交
7190 7191
}

I
Igor Sugak 已提交
7192
TEST_F(DBTest, L0_CompactionBug_Issue44_b) {
7193
  do {
L
Lei Jin 已提交
7194
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
7195
    Put(1, "", "");
L
Lei Jin 已提交
7196
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7197 7198
    Delete(1, "e");
    Put(1, "", "");
L
Lei Jin 已提交
7199
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7200
    Put(1, "c", "cv");
L
Lei Jin 已提交
7201
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7202
    Put(1, "", "");
L
Lei Jin 已提交
7203
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7204
    Put(1, "", "");
7205
    env_->SleepForMicroseconds(1000000);  // Wait for compaction to finish
L
Lei Jin 已提交
7206
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7207
    Put(1, "d", "dv");
L
Lei Jin 已提交
7208
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7209
    Put(1, "", "");
L
Lei Jin 已提交
7210
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7211 7212
    Delete(1, "d");
    Delete(1, "b");
L
Lei Jin 已提交
7213
    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
7214
    ASSERT_EQ("(->)(c->cv)", Contents(1));
7215
    env_->SleepForMicroseconds(1000000);  // Wait for compaction to finish
7216
    ASSERT_EQ("(->)(c->cv)", Contents(1));
7217
  } while (ChangeCompactOptions());
H
Hans Wennborg 已提交
7218 7219
}

I
Igor Sugak 已提交
7220
TEST_F(DBTest, ComparatorCheck) {
J
jorlow@chromium.org 已提交
7221 7222
  class NewComparator : public Comparator {
   public:
I
Igor Sugak 已提交
7223 7224 7225 7226
    virtual const char* Name() const override {
      return "rocksdb.NewComparator";
    }
    virtual int Compare(const Slice& a, const Slice& b) const override {
J
jorlow@chromium.org 已提交
7227 7228
      return BytewiseComparator()->Compare(a, b);
    }
I
Igor Sugak 已提交
7229 7230
    virtual void FindShortestSeparator(std::string* s,
                                       const Slice& l) const override {
J
jorlow@chromium.org 已提交
7231 7232
      BytewiseComparator()->FindShortestSeparator(s, l);
    }
I
Igor Sugak 已提交
7233
    virtual void FindShortSuccessor(std::string* key) const override {
J
jorlow@chromium.org 已提交
7234 7235 7236
      BytewiseComparator()->FindShortSuccessor(key);
    }
  };
7237
  Options new_options, options;
7238
  NewComparator cmp;
7239
  do {
7240
    options = CurrentOptions();
L
Lei Jin 已提交
7241
    CreateAndReopenWithCF({"pikachu"}, options);
7242
    new_options = CurrentOptions();
7243
    new_options.comparator = &cmp;
7244 7245
    // only the non-default column family has non-matching comparator
    Status s = TryReopenWithColumnFamilies({"default", "pikachu"},
L
Lei Jin 已提交
7246
        std::vector<Options>({options, new_options}));
7247 7248 7249
    ASSERT_TRUE(!s.ok());
    ASSERT_TRUE(s.ToString().find("comparator") != std::string::npos)
        << s.ToString();
7250
  } while (ChangeCompactOptions());
J
jorlow@chromium.org 已提交
7251 7252
}

I
Igor Sugak 已提交
7253
TEST_F(DBTest, CustomComparator) {
H
Hans Wennborg 已提交
7254 7255
  class NumberComparator : public Comparator {
   public:
I
Igor Sugak 已提交
7256 7257 7258 7259
    virtual const char* Name() const override {
      return "test.NumberComparator";
    }
    virtual int Compare(const Slice& a, const Slice& b) const override {
7260 7261
      return ToNumber(a) - ToNumber(b);
    }
I
Igor Sugak 已提交
7262 7263
    virtual void FindShortestSeparator(std::string* s,
                                       const Slice& l) const override {
7264 7265 7266
      ToNumber(*s);     // Check format
      ToNumber(l);      // Check format
    }
I
Igor Sugak 已提交
7267
    virtual void FindShortSuccessor(std::string* key) const override {
7268 7269 7270 7271 7272
      ToNumber(*key);   // Check format
    }
   private:
    static int ToNumber(const Slice& x) {
      // Check that there are no extra characters.
7273
      EXPECT_TRUE(x.size() >= 2 && x[0] == '[' && x[x.size() - 1] == ']')
7274 7275 7276
          << EscapeString(x);
      int val;
      char ignored;
7277
      EXPECT_TRUE(sscanf(x.ToString().c_str(), "[%i]%c", &val, &ignored) == 1)
7278 7279
          << EscapeString(x);
      return val;
H
Hans Wennborg 已提交
7280 7281
    }
  };
7282 7283
  Options new_options;
  NumberComparator cmp;
7284
  do {
7285
    new_options = CurrentOptions();
7286 7287 7288
    new_options.create_if_missing = true;
    new_options.comparator = &cmp;
    new_options.write_buffer_size = 1000;  // Compact more often
7289
    new_options = CurrentOptions(new_options);
L
Lei Jin 已提交
7290
    DestroyAndReopen(new_options);
L
Lei Jin 已提交
7291
    CreateAndReopenWithCF({"pikachu"}, new_options);
7292 7293
    ASSERT_OK(Put(1, "[10]", "ten"));
    ASSERT_OK(Put(1, "[0x14]", "twenty"));
7294
    for (int i = 0; i < 2; i++) {
7295 7296 7297 7298 7299 7300 7301
      ASSERT_EQ("ten", Get(1, "[10]"));
      ASSERT_EQ("ten", Get(1, "[0xa]"));
      ASSERT_EQ("twenty", Get(1, "[20]"));
      ASSERT_EQ("twenty", Get(1, "[0x14]"));
      ASSERT_EQ("NOT_FOUND", Get(1, "[15]"));
      ASSERT_EQ("NOT_FOUND", Get(1, "[0xf]"));
      Compact(1, "[0]", "[9999]");
7302 7303 7304 7305 7306 7307
    }

    for (int run = 0; run < 2; run++) {
      for (int i = 0; i < 1000; i++) {
        char buf[100];
        snprintf(buf, sizeof(buf), "[%d]", i*10);
7308
        ASSERT_OK(Put(1, buf, buf));
7309
      }
7310
      Compact(1, "[0]", "[1000000]");
7311
    }
7312
  } while (ChangeCompactOptions());
H
Hans Wennborg 已提交
7313 7314
}

I
Igor Sugak 已提交
7315
TEST_F(DBTest, ManualCompaction) {
I
Igor Canadi 已提交
7316 7317
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
L
Lei Jin 已提交
7318
  CreateAndReopenWithCF({"pikachu"}, options);
7319
  ASSERT_EQ(dbfull()->MaxMemCompactionLevel(), 2)
G
Gabor Cselle 已提交
7320 7321
      << "Need to update this test to match kMaxMemCompactLevel";

7322 7323 7324
  // iter - 0 with 7 levels
  // iter - 1 with 3 levels
  for (int iter = 0; iter < 2; ++iter) {
7325 7326
    MakeTables(3, "p", "q", 1);
    ASSERT_EQ("1,1,1", FilesPerLevel(1));
7327 7328

    // Compaction range falls before files
7329 7330
    Compact(1, "", "c");
    ASSERT_EQ("1,1,1", FilesPerLevel(1));
G
Gabor Cselle 已提交
7331

7332
    // Compaction range falls after files
7333 7334
    Compact(1, "r", "z");
    ASSERT_EQ("1,1,1", FilesPerLevel(1));
G
Gabor Cselle 已提交
7335

7336
    // Compaction range overlaps files
7337 7338
    Compact(1, "p1", "p9");
    ASSERT_EQ("0,0,1", FilesPerLevel(1));
G
Gabor Cselle 已提交
7339

7340
    // Populate a different range
7341 7342
    MakeTables(3, "c", "e", 1);
    ASSERT_EQ("1,1,2", FilesPerLevel(1));
G
Gabor Cselle 已提交
7343

7344
    // Compact just the new range
7345 7346
    Compact(1, "b", "f");
    ASSERT_EQ("0,0,2", FilesPerLevel(1));
G
Gabor Cselle 已提交
7347

7348
    // Compact all
7349 7350
    MakeTables(1, "a", "z", 1);
    ASSERT_EQ("0,1,2", FilesPerLevel(1));
7351
    db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
7352
    ASSERT_EQ("0,0,1", FilesPerLevel(1));
7353 7354

    if (iter == 0) {
I
Igor Canadi 已提交
7355
      options = CurrentOptions();
I
Igor Canadi 已提交
7356
      options.max_background_flushes = 0;
7357 7358
      options.num_levels = 3;
      options.create_if_missing = true;
L
Lei Jin 已提交
7359
      DestroyAndReopen(options);
L
Lei Jin 已提交
7360
      CreateAndReopenWithCF({"pikachu"}, options);
7361 7362
    }
  }
G
Gabor Cselle 已提交
7363 7364 7365

}

S
sdong 已提交
7366 7367 7368 7369 7370
class DBTestUniversalManualCompactionOutputPathId
    : public DBTestUniversalCompactionBase {};

TEST_P(DBTestUniversalManualCompactionOutputPathId,
       ManualCompactionOutputPathId) {
7371 7372 7373 7374 7375
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.db_paths.emplace_back(dbname_, 1000000000);
  options.db_paths.emplace_back(dbname_ + "_2", 1000000000);
  options.compaction_style = kCompactionStyleUniversal;
S
sdong 已提交
7376 7377
  options.num_levels = num_levels_;
  options.target_file_size_base = 1 << 30;  // Big size
7378
  options.level0_file_num_compaction_trigger = 10;
L
Lei Jin 已提交
7379 7380
  Destroy(options);
  DestroyAndReopen(options);
L
Lei Jin 已提交
7381
  CreateAndReopenWithCF({"pikachu"}, options);
7382 7383
  MakeTables(3, "p", "q", 1);
  dbfull()->TEST_WaitForCompact();
S
sdong 已提交
7384
  ASSERT_EQ(3, TotalLiveFiles(1));
7385 7386 7387 7388
  ASSERT_EQ(3, GetSstFileCount(options.db_paths[0].path));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[1].path));

  // Full compaction to DB path 0
7389 7390 7391
  CompactRangeOptions compact_options;
  compact_options.target_path_id = 1;
  db_->CompactRange(compact_options, handles_[1], nullptr, nullptr);
S
sdong 已提交
7392
  ASSERT_EQ(1, TotalLiveFiles(1));
7393 7394 7395
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[0].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

L
Lei Jin 已提交
7396
  ReopenWithColumnFamilies({kDefaultColumnFamilyName, "pikachu"}, options);
S
sdong 已提交
7397
  ASSERT_EQ(1, TotalLiveFiles(1));
7398 7399 7400 7401
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[0].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

  MakeTables(1, "p", "q", 1);
S
sdong 已提交
7402
  ASSERT_EQ(2, TotalLiveFiles(1));
7403 7404 7405
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[0].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

L
Lei Jin 已提交
7406
  ReopenWithColumnFamilies({kDefaultColumnFamilyName, "pikachu"}, options);
S
sdong 已提交
7407
  ASSERT_EQ(2, TotalLiveFiles(1));
7408 7409 7410 7411
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[0].path));
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));

  // Full compaction to DB path 0
7412 7413
  compact_options.target_path_id = 0;
  db_->CompactRange(compact_options, handles_[1], nullptr, nullptr);
S
sdong 已提交
7414
  ASSERT_EQ(1, TotalLiveFiles(1));
7415 7416 7417 7418
  ASSERT_EQ(1, GetSstFileCount(options.db_paths[0].path));
  ASSERT_EQ(0, GetSstFileCount(options.db_paths[1].path));

  // Fail when compacting to an invalid path ID
7419 7420
  compact_options.target_path_id = 2;
  ASSERT_TRUE(db_->CompactRange(compact_options, handles_[1], nullptr, nullptr)
7421 7422 7423
                  .IsInvalidArgument());
}

S
sdong 已提交
7424 7425 7426 7427
INSTANTIATE_TEST_CASE_P(DBTestUniversalManualCompactionOutputPathId,
                        DBTestUniversalManualCompactionOutputPathId,
                        ::testing::Values(1, 8));

I
Igor Sugak 已提交
7428
TEST_F(DBTest, ManualLevelCompactionOutputPathId) {
7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476
  Options options = CurrentOptions();
  options.db_paths.emplace_back(dbname_ + "_2", 2 * 10485760);
  options.db_paths.emplace_back(dbname_ + "_3", 100 * 10485760);
  options.db_paths.emplace_back(dbname_ + "_4", 120 * 10485760);
  options.max_background_flushes = 1;
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_EQ(dbfull()->MaxMemCompactionLevel(), 2)
      << "Need to update this test to match kMaxMemCompactLevel";

  // iter - 0 with 7 levels
  // iter - 1 with 3 levels
  for (int iter = 0; iter < 2; ++iter) {
    MakeTables(3, "p", "q", 1);
    ASSERT_EQ("3", FilesPerLevel(1));
    ASSERT_EQ(3, GetSstFileCount(options.db_paths[0].path));
    ASSERT_EQ(0, GetSstFileCount(dbname_));

    // Compaction range falls before files
    Compact(1, "", "c");
    ASSERT_EQ("3", FilesPerLevel(1));

    // Compaction range falls after files
    Compact(1, "r", "z");
    ASSERT_EQ("3", FilesPerLevel(1));

    // Compaction range overlaps files
    Compact(1, "p1", "p9", 1);
    ASSERT_EQ("0,1", FilesPerLevel(1));
    ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
    ASSERT_EQ(0, GetSstFileCount(options.db_paths[0].path));
    ASSERT_EQ(0, GetSstFileCount(dbname_));

    // Populate a different range
    MakeTables(3, "c", "e", 1);
    ASSERT_EQ("3,1", FilesPerLevel(1));

    // Compact just the new range
    Compact(1, "b", "f", 1);
    ASSERT_EQ("0,2", FilesPerLevel(1));
    ASSERT_EQ(2, GetSstFileCount(options.db_paths[1].path));
    ASSERT_EQ(0, GetSstFileCount(options.db_paths[0].path));
    ASSERT_EQ(0, GetSstFileCount(dbname_));

    // Compact all
    MakeTables(1, "a", "z", 1);
    ASSERT_EQ("1,2", FilesPerLevel(1));
    ASSERT_EQ(2, GetSstFileCount(options.db_paths[1].path));
    ASSERT_EQ(1, GetSstFileCount(options.db_paths[0].path));
7477 7478 7479
    CompactRangeOptions compact_options;
    compact_options.target_path_id = 1;
    db_->CompactRange(compact_options, handles_[1], nullptr, nullptr);
7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498
    ASSERT_EQ("0,1", FilesPerLevel(1));
    ASSERT_EQ(1, GetSstFileCount(options.db_paths[1].path));
    ASSERT_EQ(0, GetSstFileCount(options.db_paths[0].path));
    ASSERT_EQ(0, GetSstFileCount(dbname_));

    if (iter == 0) {
      DestroyAndReopen(options);
      options = CurrentOptions();
      options.db_paths.emplace_back(dbname_ + "_2", 2 * 10485760);
      options.db_paths.emplace_back(dbname_ + "_3", 100 * 10485760);
      options.db_paths.emplace_back(dbname_ + "_4", 120 * 10485760);
      options.max_background_flushes = 1;
      options.num_levels = 3;
      options.create_if_missing = true;
      CreateAndReopenWithCF({"pikachu"}, options);
    }
  }
}

I
Igor Sugak 已提交
7499
TEST_F(DBTest, DBOpen_Options) {
7500 7501 7502
  Options options = CurrentOptions();
  std::string dbname = test::TmpDir(env_) + "/db_options_test";
  ASSERT_OK(DestroyDB(dbname, options));
J
jorlow@chromium.org 已提交
7503 7504

  // Does not exist, and create_if_missing == false: error
A
Abhishek Kona 已提交
7505
  DB* db = nullptr;
7506 7507
  options.create_if_missing = false;
  Status s = DB::Open(options, dbname, &db);
A
Abhishek Kona 已提交
7508 7509
  ASSERT_TRUE(strstr(s.ToString().c_str(), "does not exist") != nullptr);
  ASSERT_TRUE(db == nullptr);
J
jorlow@chromium.org 已提交
7510 7511

  // Does not exist, and create_if_missing == true: OK
7512 7513
  options.create_if_missing = true;
  s = DB::Open(options, dbname, &db);
J
jorlow@chromium.org 已提交
7514
  ASSERT_OK(s);
A
Abhishek Kona 已提交
7515
  ASSERT_TRUE(db != nullptr);
J
jorlow@chromium.org 已提交
7516 7517

  delete db;
A
Abhishek Kona 已提交
7518
  db = nullptr;
J
jorlow@chromium.org 已提交
7519 7520

  // Does exist, and error_if_exists == true: error
7521 7522 7523
  options.create_if_missing = false;
  options.error_if_exists = true;
  s = DB::Open(options, dbname, &db);
A
Abhishek Kona 已提交
7524 7525
  ASSERT_TRUE(strstr(s.ToString().c_str(), "exists") != nullptr);
  ASSERT_TRUE(db == nullptr);
J
jorlow@chromium.org 已提交
7526 7527

  // Does exist, and error_if_exists == false: OK
7528 7529 7530
  options.create_if_missing = true;
  options.error_if_exists = false;
  s = DB::Open(options, dbname, &db);
J
jorlow@chromium.org 已提交
7531
  ASSERT_OK(s);
A
Abhishek Kona 已提交
7532
  ASSERT_TRUE(db != nullptr);
J
jorlow@chromium.org 已提交
7533 7534

  delete db;
A
Abhishek Kona 已提交
7535
  db = nullptr;
J
jorlow@chromium.org 已提交
7536 7537
}

I
Igor Sugak 已提交
7538
TEST_F(DBTest, DBOpen_Change_NumLevels) {
7539 7540 7541 7542
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.max_background_flushes = 0;
  DestroyAndReopen(options);
7543
  ASSERT_TRUE(db_ != nullptr);
7544
  CreateAndReopenWithCF({"pikachu"}, options);
7545 7546 7547

  ASSERT_OK(Put(1, "a", "123"));
  ASSERT_OK(Put(1, "b", "234"));
7548
  db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
7549
  Close();
7550

7551 7552 7553
  options.create_if_missing = false;
  options.num_levels = 2;
  Status s = TryReopenWithColumnFamilies({"default", "pikachu"}, options);
7554
  ASSERT_TRUE(strstr(s.ToString().c_str(), "Invalid argument") != nullptr);
7555
  ASSERT_TRUE(db_ == nullptr);
7556 7557
}

I
Igor Sugak 已提交
7558
TEST_F(DBTest, DestroyDBMetaDatabase) {
7559
  std::string dbname = test::TmpDir(env_) + "/db_meta";
7560
  ASSERT_OK(env_->CreateDirIfMissing(dbname));
K
Kosie van der Merwe 已提交
7561
  std::string metadbname = MetaDatabaseName(dbname, 0);
7562
  ASSERT_OK(env_->CreateDirIfMissing(metadbname));
K
Kosie van der Merwe 已提交
7563
  std::string metametadbname = MetaDatabaseName(metadbname, 0);
7564
  ASSERT_OK(env_->CreateDirIfMissing(metametadbname));
K
Kosie van der Merwe 已提交
7565 7566

  // Destroy previous versions if they exist. Using the long way.
7567 7568 7569 7570
  Options options = CurrentOptions();
  ASSERT_OK(DestroyDB(metametadbname, options));
  ASSERT_OK(DestroyDB(metadbname, options));
  ASSERT_OK(DestroyDB(dbname, options));
K
Kosie van der Merwe 已提交
7571 7572

  // Setup databases
A
Abhishek Kona 已提交
7573
  DB* db = nullptr;
7574
  ASSERT_OK(DB::Open(options, dbname, &db));
K
Kosie van der Merwe 已提交
7575
  delete db;
A
Abhishek Kona 已提交
7576
  db = nullptr;
7577
  ASSERT_OK(DB::Open(options, metadbname, &db));
K
Kosie van der Merwe 已提交
7578
  delete db;
A
Abhishek Kona 已提交
7579
  db = nullptr;
7580
  ASSERT_OK(DB::Open(options, metametadbname, &db));
K
Kosie van der Merwe 已提交
7581
  delete db;
A
Abhishek Kona 已提交
7582
  db = nullptr;
K
Kosie van der Merwe 已提交
7583 7584

  // Delete databases
7585
  ASSERT_OK(DestroyDB(dbname, options));
K
Kosie van der Merwe 已提交
7586 7587

  // Check if deletion worked.
7588 7589 7590 7591
  options.create_if_missing = false;
  ASSERT_TRUE(!(DB::Open(options, dbname, &db)).ok());
  ASSERT_TRUE(!(DB::Open(options, metadbname, &db)).ok());
  ASSERT_TRUE(!(DB::Open(options, metametadbname, &db)).ok());
K
Kosie van der Merwe 已提交
7592 7593
}

7594
// Check that number of files does not grow when writes are dropped
I
Igor Sugak 已提交
7595
TEST_F(DBTest, DropWrites) {
7596 7597 7598
  do {
    Options options = CurrentOptions();
    options.env = env_;
7599
    options.paranoid_checks = false;
L
Lei Jin 已提交
7600
    Reopen(options);
7601

7602 7603 7604
    ASSERT_OK(Put("foo", "v1"));
    ASSERT_EQ("v1", Get("foo"));
    Compact("a", "z");
7605
    const size_t num_files = CountFiles();
I
Igor Canadi 已提交
7606 7607
    // Force out-of-space errors
    env_->drop_writes_.store(true, std::memory_order_release);
7608
    env_->sleep_counter_.Reset();
K
krad 已提交
7609
    env_->no_sleep_ = true;
7610
    for (int i = 0; i < 5; i++) {
7611 7612 7613 7614 7615
      if (option_config_ != kUniversalCompactionMultiLevel) {
        for (int level = 0; level < dbfull()->NumberLevels(); level++) {
          if (level > 0 && level == dbfull()->NumberLevels() - 1) {
            break;
          }
7616 7617
          dbfull()->TEST_CompactRange(level, nullptr, nullptr, nullptr,
                                      true /* disallow trivial move */);
S
sdong 已提交
7618
        }
7619
      } else {
7620
        dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
7621
      }
7622
    }
7623 7624 7625 7626 7627

    std::string property_value;
    ASSERT_TRUE(db_->GetProperty("rocksdb.background-errors", &property_value));
    ASSERT_EQ("5", property_value);

I
Igor Canadi 已提交
7628
    env_->drop_writes_.store(false, std::memory_order_release);
7629
    ASSERT_LT(CountFiles(), num_files + 3);
7630

7631
    // Check that compaction attempts slept after errors
K
krad 已提交
7632
    ASSERT_TRUE(env_->sleep_counter_.WaitFor(5));
7633
  } while (ChangeCompactOptions());
7634 7635
}

7636
// Check background error counter bumped on flush failures.
I
Igor Sugak 已提交
7637
TEST_F(DBTest, DropWritesFlush) {
7638 7639 7640 7641
  do {
    Options options = CurrentOptions();
    options.env = env_;
    options.max_background_flushes = 1;
L
Lei Jin 已提交
7642
    Reopen(options);
7643 7644

    ASSERT_OK(Put("foo", "v1"));
I
Igor Canadi 已提交
7645 7646
    // Force out-of-space errors
    env_->drop_writes_.store(true, std::memory_order_release);
7647 7648 7649 7650 7651 7652

    std::string property_value;
    // Background error count is 0 now.
    ASSERT_TRUE(db_->GetProperty("rocksdb.background-errors", &property_value));
    ASSERT_EQ("0", property_value);

L
Lei Jin 已提交
7653 7654 7655
    dbfull()->TEST_FlushMemTable(true);

    ASSERT_TRUE(db_->GetProperty("rocksdb.background-errors", &property_value));
7656 7657
    ASSERT_EQ("1", property_value);

I
Igor Canadi 已提交
7658
    env_->drop_writes_.store(false, std::memory_order_release);
7659 7660 7661 7662 7663
  } while (ChangeCompactOptions());
}

// Check that CompactRange() returns failure if there is not enough space left
// on device
I
Igor Sugak 已提交
7664
TEST_F(DBTest, NoSpaceCompactRange) {
7665 7666 7667 7668
  do {
    Options options = CurrentOptions();
    options.env = env_;
    options.disable_auto_compactions = true;
L
Lei Jin 已提交
7669
    Reopen(options);
7670 7671 7672 7673 7674 7675 7676

    // generate 5 tables
    for (int i = 0; i < 5; ++i) {
      ASSERT_OK(Put(Key(i), Key(i) + "v"));
      ASSERT_OK(Flush());
    }

I
Igor Canadi 已提交
7677 7678
    // Force out-of-space errors
    env_->no_space_.store(true, std::memory_order_release);
7679

7680 7681
    Status s = dbfull()->TEST_CompactRange(0, nullptr, nullptr, nullptr,
                                           true /* disallow trivial move */);
7682 7683
    ASSERT_TRUE(s.IsIOError());

I
Igor Canadi 已提交
7684
    env_->no_space_.store(false, std::memory_order_release);
7685 7686 7687
  } while (ChangeCompactOptions());
}

I
Igor Sugak 已提交
7688
TEST_F(DBTest, NonWritableFileSystem) {
7689 7690 7691 7692
  do {
    Options options = CurrentOptions();
    options.write_buffer_size = 1000;
    options.env = env_;
L
Lei Jin 已提交
7693
    Reopen(options);
7694
    ASSERT_OK(Put("foo", "v1"));
7695
    env_->non_writeable_rate_.store(100);
7696 7697 7698 7699 7700 7701 7702
    std::string big(100000, 'x');
    int errors = 0;
    for (int i = 0; i < 20; i++) {
      if (!Put("foo", big).ok()) {
        errors++;
        env_->SleepForMicroseconds(100000);
      }
7703
    }
7704
    ASSERT_GT(errors, 0);
7705
    env_->non_writeable_rate_.store(0);
7706
  } while (ChangeCompactOptions());
7707 7708
}

I
Igor Sugak 已提交
7709
TEST_F(DBTest, ManifestWriteError) {
7710 7711 7712 7713 7714 7715 7716 7717 7718
  // Test for the following problem:
  // (a) Compaction produces file F
  // (b) Log record containing F is written to MANIFEST file, but Sync() fails
  // (c) GC deletes F
  // (d) After reopening DB, reads fail since deleted F is named in log record

  // We iterate twice.  In the second iteration, everything is the
  // same except the log record never makes it to the MANIFEST file.
  for (int iter = 0; iter < 2; iter++) {
I
Igor Canadi 已提交
7719
    std::atomic<bool>* error_type = (iter == 0)
7720 7721 7722 7723 7724 7725 7726 7727
        ? &env_->manifest_sync_error_
        : &env_->manifest_write_error_;

    // Insert foo=>bar mapping
    Options options = CurrentOptions();
    options.env = env_;
    options.create_if_missing = true;
    options.error_if_exists = false;
I
Igor Canadi 已提交
7728
    options.max_background_flushes = 0;
L
Lei Jin 已提交
7729
    DestroyAndReopen(options);
7730 7731 7732 7733
    ASSERT_OK(Put("foo", "bar"));
    ASSERT_EQ("bar", Get("foo"));

    // Memtable compaction (will succeed)
7734
    Flush();
7735 7736 7737 7738 7739
    ASSERT_EQ("bar", Get("foo"));
    const int last = dbfull()->MaxMemCompactionLevel();
    ASSERT_EQ(NumTableFilesAtLevel(last), 1);   // foo=>bar is now in last level

    // Merging compaction (will fail)
I
Igor Canadi 已提交
7740
    error_type->store(true, std::memory_order_release);
A
Abhishek Kona 已提交
7741
    dbfull()->TEST_CompactRange(last, nullptr, nullptr);  // Should fail
7742 7743 7744
    ASSERT_EQ("bar", Get("foo"));

    // Recovery: should not lose data
I
Igor Canadi 已提交
7745
    error_type->store(false, std::memory_order_release);
L
Lei Jin 已提交
7746
    Reopen(options);
7747 7748 7749 7750
    ASSERT_EQ("bar", Get("foo"));
  }
}

I
Igor Sugak 已提交
7751
TEST_F(DBTest, PutFailsParanoid) {
I
Igor Canadi 已提交
7752 7753 7754 7755 7756 7757 7758 7759 7760 7761
  // Test the following:
  // (a) A random put fails in paranoid mode (simulate by sync fail)
  // (b) All other puts have to fail, even if writes would succeed
  // (c) All of that should happen ONLY if paranoid_checks = true

  Options options = CurrentOptions();
  options.env = env_;
  options.create_if_missing = true;
  options.error_if_exists = false;
  options.paranoid_checks = true;
L
Lei Jin 已提交
7762
  DestroyAndReopen(options);
L
Lei Jin 已提交
7763
  CreateAndReopenWithCF({"pikachu"}, options);
I
Igor Canadi 已提交
7764 7765
  Status s;

7766 7767
  ASSERT_OK(Put(1, "foo", "bar"));
  ASSERT_OK(Put(1, "foo1", "bar1"));
I
Igor Canadi 已提交
7768
  // simulate error
I
Igor Canadi 已提交
7769
  env_->log_write_error_.store(true, std::memory_order_release);
7770
  s = Put(1, "foo2", "bar2");
I
Igor Canadi 已提交
7771
  ASSERT_TRUE(!s.ok());
I
Igor Canadi 已提交
7772
  env_->log_write_error_.store(false, std::memory_order_release);
7773
  s = Put(1, "foo3", "bar3");
I
Igor Canadi 已提交
7774 7775 7776
  // the next put should fail, too
  ASSERT_TRUE(!s.ok());
  // but we're still able to read
7777
  ASSERT_EQ("bar", Get(1, "foo"));
I
Igor Canadi 已提交
7778 7779 7780

  // do the same thing with paranoid checks off
  options.paranoid_checks = false;
L
Lei Jin 已提交
7781
  DestroyAndReopen(options);
L
Lei Jin 已提交
7782
  CreateAndReopenWithCF({"pikachu"}, options);
I
Igor Canadi 已提交
7783

7784 7785
  ASSERT_OK(Put(1, "foo", "bar"));
  ASSERT_OK(Put(1, "foo1", "bar1"));
I
Igor Canadi 已提交
7786
  // simulate error
I
Igor Canadi 已提交
7787
  env_->log_write_error_.store(true, std::memory_order_release);
7788
  s = Put(1, "foo2", "bar2");
I
Igor Canadi 已提交
7789
  ASSERT_TRUE(!s.ok());
I
Igor Canadi 已提交
7790
  env_->log_write_error_.store(false, std::memory_order_release);
7791
  s = Put(1, "foo3", "bar3");
I
Igor Canadi 已提交
7792 7793 7794 7795
  // the next put should NOT fail
  ASSERT_TRUE(s.ok());
}

I
Igor Sugak 已提交
7796
TEST_F(DBTest, FilesDeletedAfterCompaction) {
7797
  do {
L
Lei Jin 已提交
7798
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
7799 7800
    ASSERT_OK(Put(1, "foo", "v2"));
    Compact(1, "a", "z");
7801
    const size_t num_files = CountLiveFiles();
7802
    for (int i = 0; i < 10; i++) {
7803 7804
      ASSERT_OK(Put(1, "foo", "v2"));
      Compact(1, "a", "z");
7805 7806 7807
    }
    ASSERT_EQ(CountLiveFiles(), num_files);
  } while (ChangeCompactOptions());
7808 7809
}

I
Igor Sugak 已提交
7810
TEST_F(DBTest, BloomFilter) {
7811 7812
  do {
    Options options = CurrentOptions();
7813
    env_->count_random_reads_ = true;
7814
    options.env = env_;
7815 7816 7817 7818 7819 7820 7821
    // ChangeCompactOptions() only changes compaction style, which does not
    // trigger reset of table_factory
    BlockBasedTableOptions table_options;
    table_options.no_block_cache = true;
    table_options.filter_policy.reset(NewBloomFilterPolicy(10));
    options.table_factory.reset(NewBlockBasedTableFactory(table_options));

L
Lei Jin 已提交
7822
    CreateAndReopenWithCF({"pikachu"}, options);
S
Sanjay Ghemawat 已提交
7823

7824 7825 7826
    // Populate multiple layers
    const int N = 10000;
    for (int i = 0; i < N; i++) {
7827
      ASSERT_OK(Put(1, Key(i), Key(i)));
7828
    }
7829
    Compact(1, "a", "z");
7830
    for (int i = 0; i < N; i += 100) {
7831
      ASSERT_OK(Put(1, Key(i), Key(i)));
7832
    }
7833
    Flush(1);
S
Sanjay Ghemawat 已提交
7834

7835
    // Prevent auto compactions triggered by seeks
I
Igor Canadi 已提交
7836
    env_->delay_sstable_sync_.store(true, std::memory_order_release);
S
Sanjay Ghemawat 已提交
7837

7838 7839 7840
    // Lookup present keys.  Should rarely read from small sstable.
    env_->random_read_counter_.Reset();
    for (int i = 0; i < N; i++) {
7841
      ASSERT_EQ(Key(i), Get(1, Key(i)));
7842 7843 7844 7845 7846
    }
    int reads = env_->random_read_counter_.Read();
    fprintf(stderr, "%d present => %d reads\n", N, reads);
    ASSERT_GE(reads, N);
    ASSERT_LE(reads, N + 2*N/100);
S
Sanjay Ghemawat 已提交
7847

7848 7849 7850
    // Lookup present keys.  Should rarely read from either sstable.
    env_->random_read_counter_.Reset();
    for (int i = 0; i < N; i++) {
7851
      ASSERT_EQ("NOT_FOUND", Get(1, Key(i) + ".missing"));
7852 7853 7854 7855
    }
    reads = env_->random_read_counter_.Read();
    fprintf(stderr, "%d missing => %d reads\n", N, reads);
    ASSERT_LE(reads, 3*N/100);
S
Sanjay Ghemawat 已提交
7856

I
Igor Canadi 已提交
7857
    env_->delay_sstable_sync_.store(false, std::memory_order_release);
7858 7859
    Close();
  } while (ChangeCompactOptions());
S
Sanjay Ghemawat 已提交
7860 7861
}

I
Igor Sugak 已提交
7862
TEST_F(DBTest, BloomFilterRate) {
7863 7864 7865
  while (ChangeFilterOptions()) {
    Options options = CurrentOptions();
    options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
7866
    CreateAndReopenWithCF({"pikachu"}, options);
7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889

    const int maxKey = 10000;
    for (int i = 0; i < maxKey; i++) {
      ASSERT_OK(Put(1, Key(i), Key(i)));
    }
    // Add a large key to make the file contain wide range
    ASSERT_OK(Put(1, Key(maxKey + 55555), Key(maxKey + 55555)));
    Flush(1);

    // Check if they can be found
    for (int i = 0; i < maxKey; i++) {
      ASSERT_EQ(Key(i), Get(1, Key(i)));
    }
    ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);

    // Check if filter is useful
    for (int i = 0; i < maxKey; i++) {
      ASSERT_EQ("NOT_FOUND", Get(1, Key(i+33333)));
    }
    ASSERT_GE(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), maxKey*0.98);
  }
}

I
Igor Sugak 已提交
7890
TEST_F(DBTest, BloomFilterCompatibility) {
7891
  Options options = CurrentOptions();
7892 7893 7894 7895 7896 7897
  options.statistics = rocksdb::CreateDBStatistics();
  BlockBasedTableOptions table_options;
  table_options.filter_policy.reset(NewBloomFilterPolicy(10, true));
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  // Create with block based filter
L
Lei Jin 已提交
7898
  CreateAndReopenWithCF({"pikachu"}, options);
7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909

  const int maxKey = 10000;
  for (int i = 0; i < maxKey; i++) {
    ASSERT_OK(Put(1, Key(i), Key(i)));
  }
  ASSERT_OK(Put(1, Key(maxKey + 55555), Key(maxKey + 55555)));
  Flush(1);

  // Check db with full filter
  table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
7910
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
7911 7912 7913 7914 7915 7916 7917 7918

  // Check if they can be found
  for (int i = 0; i < maxKey; i++) {
    ASSERT_EQ(Key(i), Get(1, Key(i)));
  }
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
}

I
Igor Sugak 已提交
7919
TEST_F(DBTest, BloomFilterReverseCompatibility) {
7920
  Options options = CurrentOptions();
7921 7922 7923 7924 7925 7926
  options.statistics = rocksdb::CreateDBStatistics();
  BlockBasedTableOptions table_options;
  table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  // Create with full filter
L
Lei Jin 已提交
7927
  CreateAndReopenWithCF({"pikachu"}, options);
7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938

  const int maxKey = 10000;
  for (int i = 0; i < maxKey; i++) {
    ASSERT_OK(Put(1, Key(i), Key(i)));
  }
  ASSERT_OK(Put(1, Key(maxKey + 55555), Key(maxKey + 55555)));
  Flush(1);

  // Check db with block_based filter
  table_options.filter_policy.reset(NewBloomFilterPolicy(10, true));
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
7939
  ReopenWithColumnFamilies({"default", "pikachu"}, options);
7940 7941 7942 7943 7944 7945 7946 7947

  // Check if they can be found
  for (int i = 0; i < maxKey; i++) {
    ASSERT_EQ(Key(i), Get(1, Key(i)));
  }
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
}

F
Feng Zhu 已提交
7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980
namespace {
// A wrapped bloom over default FilterPolicy
class WrappedBloom : public FilterPolicy {
 public:
  explicit WrappedBloom(int bits_per_key) :
        filter_(NewBloomFilterPolicy(bits_per_key)),
        counter_(0) {}

  ~WrappedBloom() { delete filter_; }

  const char* Name() const override { return "WrappedRocksDbFilterPolicy"; }

  void CreateFilter(const rocksdb::Slice* keys, int n, std::string* dst)
      const override {
    std::unique_ptr<rocksdb::Slice[]> user_keys(new rocksdb::Slice[n]);
    for (int i = 0; i < n; ++i) {
      user_keys[i] = convertKey(keys[i]);
    }
    return filter_->CreateFilter(user_keys.get(), n, dst);
  }

  bool KeyMayMatch(const rocksdb::Slice& key, const rocksdb::Slice& filter)
      const override {
    counter_++;
    return filter_->KeyMayMatch(convertKey(key), filter);
  }

  uint32_t GetCounter() { return counter_; }

 private:
  const FilterPolicy* filter_;
  mutable uint32_t counter_;

7981
  rocksdb::Slice convertKey(const rocksdb::Slice& key) const {
F
Feng Zhu 已提交
7982 7983 7984 7985 7986
    return key;
  }
};
}  // namespace

I
Igor Sugak 已提交
7987
TEST_F(DBTest, BloomFilterWrapper) {
7988
  Options options = CurrentOptions();
F
Feng Zhu 已提交
7989 7990 7991 7992 7993 7994 7995
  options.statistics = rocksdb::CreateDBStatistics();

  BlockBasedTableOptions table_options;
  WrappedBloom* policy = new WrappedBloom(10);
  table_options.filter_policy.reset(policy);
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

L
Lei Jin 已提交
7996
  CreateAndReopenWithCF({"pikachu"}, options);
F
Feng Zhu 已提交
7997 7998 7999 8000 8001 8002 8003

  const int maxKey = 10000;
  for (int i = 0; i < maxKey; i++) {
    ASSERT_OK(Put(1, Key(i), Key(i)));
  }
  // Add a large key to make the file contain wide range
  ASSERT_OK(Put(1, Key(maxKey + 55555), Key(maxKey + 55555)));
C
Chilledheart 已提交
8004
  ASSERT_EQ(0U, policy->GetCounter());
F
Feng Zhu 已提交
8005 8006 8007 8008 8009 8010 8011
  Flush(1);

  // Check if they can be found
  for (int i = 0; i < maxKey; i++) {
    ASSERT_EQ(Key(i), Get(1, Key(i)));
  }
  ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 0);
C
Chilledheart 已提交
8012
  ASSERT_EQ(1U * maxKey, policy->GetCounter());
F
Feng Zhu 已提交
8013 8014 8015 8016 8017 8018

  // Check if filter is useful
  for (int i = 0; i < maxKey; i++) {
    ASSERT_EQ("NOT_FOUND", Get(1, Key(i+33333)));
  }
  ASSERT_GE(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), maxKey*0.98);
C
Chilledheart 已提交
8019
  ASSERT_EQ(2U * maxKey, policy->GetCounter());
F
Feng Zhu 已提交
8020 8021
}

I
Igor Sugak 已提交
8022
TEST_F(DBTest, SnapshotFiles) {
8023 8024 8025
  do {
    Options options = CurrentOptions();
    options.write_buffer_size = 100000000;        // Large write buffer
L
Lei Jin 已提交
8026
    CreateAndReopenWithCF({"pikachu"}, options);
8027

8028
    Random rnd(301);
8029

8030
    // Write 8MB (80 values, each 100K)
8031
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
8032 8033 8034
    std::vector<std::string> values;
    for (int i = 0; i < 80; i++) {
      values.push_back(RandomString(&rnd, 100000));
8035
      ASSERT_OK(Put((i < 40), Key(i), values[i]));
8036
    }
8037

8038
    // assert that nothing makes it to disk yet.
8039
    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
8040

8041 8042 8043 8044 8045 8046 8047
    // get a file snapshot
    uint64_t manifest_number = 0;
    uint64_t manifest_size = 0;
    std::vector<std::string> files;
    dbfull()->DisableFileDeletions();
    dbfull()->GetLiveFiles(files, &manifest_size);

8048 8049
    // CURRENT, MANIFEST, *.sst files (one for each CF)
    ASSERT_EQ(files.size(), 4U);
8050 8051 8052 8053 8054 8055

    uint64_t number = 0;
    FileType type;

    // copy these files to a new snapshot directory
    std::string snapdir = dbname_ + ".snapdir/";
8056
    ASSERT_OK(env_->CreateDirIfMissing(snapdir));
8057 8058

    for (unsigned int i = 0; i < files.size(); i++) {
I
Igor Canadi 已提交
8059 8060 8061 8062 8063
      // our clients require that GetLiveFiles returns
      // files with "/" as first character!
      ASSERT_EQ(files[i][0], '/');
      std::string src = dbname_ + files[i];
      std::string dest = snapdir + files[i];
8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076

      uint64_t size;
      ASSERT_OK(env_->GetFileSize(src, &size));

      // record the number and the size of the
      // latest manifest file
      if (ParseFileName(files[i].substr(1), &number, &type)) {
        if (type == kDescriptorFile) {
          if (number > manifest_number) {
            manifest_number = number;
            ASSERT_GE(size, manifest_size);
            size = manifest_size; // copy only valid MANIFEST data
          }
8077 8078
        }
      }
I
Igor Canadi 已提交
8079
      CopyFile(src, dest, size);
8080 8081
    }

8082 8083 8084 8085 8086 8087
    // release file snapshot
    dbfull()->DisableFileDeletions();
    // overwrite one key, this key should not appear in the snapshot
    std::vector<std::string> extras;
    for (unsigned int i = 0; i < 1; i++) {
      extras.push_back(RandomString(&rnd, 100000));
8088
      ASSERT_OK(Put(0, Key(i), extras[i]));
8089
    }
8090

8091
    // verify that data in the snapshot are correct
8092 8093 8094 8095
    std::vector<ColumnFamilyDescriptor> column_families;
    column_families.emplace_back("default", ColumnFamilyOptions());
    column_families.emplace_back("pikachu", ColumnFamilyOptions());
    std::vector<ColumnFamilyHandle*> cf_handles;
8096
    DB* snapdb;
8097
    DBOptions opts;
8098
    opts.env = env_;
8099
    opts.create_if_missing = false;
8100 8101
    Status stat =
        DB::Open(opts, snapdir, column_families, &cf_handles, &snapdb);
N
Naman Gupta 已提交
8102
    ASSERT_OK(stat);
8103 8104 8105 8106

    ReadOptions roptions;
    std::string val;
    for (unsigned int i = 0; i < 80; i++) {
8107
      stat = snapdb->Get(roptions, cf_handles[i < 40], Key(i), &val);
8108 8109
      ASSERT_EQ(values[i].compare(val), 0);
    }
8110 8111 8112
    for (auto cfh : cf_handles) {
      delete cfh;
    }
8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137 8138
    delete snapdb;

    // look at the new live files after we added an 'extra' key
    // and after we took the first snapshot.
    uint64_t new_manifest_number = 0;
    uint64_t new_manifest_size = 0;
    std::vector<std::string> newfiles;
    dbfull()->DisableFileDeletions();
    dbfull()->GetLiveFiles(newfiles, &new_manifest_size);

    // find the new manifest file. assert that this manifest file is
    // the same one as in the previous snapshot. But its size should be
    // larger because we added an extra key after taking the
    // previous shapshot.
    for (unsigned int i = 0; i < newfiles.size(); i++) {
      std::string src = dbname_ + "/" + newfiles[i];
      // record the lognumber and the size of the
      // latest manifest file
      if (ParseFileName(newfiles[i].substr(1), &number, &type)) {
        if (type == kDescriptorFile) {
          if (number > new_manifest_number) {
            uint64_t size;
            new_manifest_number = number;
            ASSERT_OK(env_->GetFileSize(src, &size));
            ASSERT_GE(size, new_manifest_size);
          }
8139 8140 8141
        }
      }
    }
8142 8143
    ASSERT_EQ(manifest_number, new_manifest_number);
    ASSERT_GT(new_manifest_size, manifest_size);
8144

8145 8146 8147
    // release file snapshot
    dbfull()->DisableFileDeletions();
  } while (ChangeCompactOptions());
8148 8149
}

I
Igor Sugak 已提交
8150
TEST_F(DBTest, CompactOnFlush) {
8151 8152
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
8153
  do {
8154
    Options options = CurrentOptions(options_override);
8155 8156
    options.purge_redundant_kvs_while_flush = true;
    options.disable_auto_compactions = true;
L
Lei Jin 已提交
8157
    CreateAndReopenWithCF({"pikachu"}, options);
8158

8159 8160 8161
    Put(1, "foo", "v1");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v1 ]");
8162

8163
    // Write two new keys
8164 8165 8166
    Put(1, "a", "begin");
    Put(1, "z", "end");
    Flush(1);
8167

8168
    // Case1: Delete followed by a put
8169 8170 8171
    Delete(1, "foo");
    Put(1, "foo", "v2");
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, DEL, v1 ]");
8172

8173 8174
    // After the current memtable is flushed, the DEL should
    // have been removed
8175 8176
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2, v1 ]");
8177

8178 8179
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
8180
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v2 ]");
8181

8182
    // Case 2: Delete followed by another delete
8183 8184 8185 8186 8187
    Delete(1, "foo");
    Delete(1, "foo");
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, DEL, v2 ]");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v2 ]");
8188 8189
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
8190
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
8191

8192
    // Case 3: Put followed by a delete
8193 8194 8195 8196 8197
    Put(1, "foo", "v3");
    Delete(1, "foo");
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL, v3 ]");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ DEL ]");
8198 8199
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
8200
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
8201

8202
    // Case 4: Put followed by another Put
8203 8204 8205 8206 8207
    Put(1, "foo", "v4");
    Put(1, "foo", "v5");
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v5, v4 ]");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v5 ]");
8208 8209
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
8210
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v5 ]");
8211

8212
    // clear database
8213
    Delete(1, "foo");
8214 8215
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
8216
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
8217

8218 8219
    // Case 5: Put followed by snapshot followed by another Put
    // Both puts should remain.
8220
    Put(1, "foo", "v6");
8221
    const Snapshot* snapshot = db_->GetSnapshot();
8222 8223 8224
    Put(1, "foo", "v7");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v7, v6 ]");
8225
    db_->ReleaseSnapshot(snapshot);
8226

8227
    // clear database
8228
    Delete(1, "foo");
8229 8230
    dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
                           nullptr);
8231
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ ]");
8232

8233 8234 8235
    // Case 5: snapshot followed by a put followed by another Put
    // Only the last put should remain.
    const Snapshot* snapshot1 = db_->GetSnapshot();
8236 8237 8238 8239
    Put(1, "foo", "v8");
    Put(1, "foo", "v9");
    ASSERT_OK(Flush(1));
    ASSERT_EQ(AllEntriesFor("foo", 1), "[ v9 ]");
8240 8241
    db_->ReleaseSnapshot(snapshot1);
  } while (ChangeCompactOptions());
8242 8243
}

I
Igor Canadi 已提交
8244
namespace {
S
Stanislau Hlebik 已提交
8245 8246
std::vector<std::uint64_t> ListSpecificFiles(
    Env* env, const std::string& path, const FileType expected_file_type) {
8247
  std::vector<std::string> files;
S
Stanislau Hlebik 已提交
8248
  std::vector<uint64_t> file_numbers;
8249 8250 8251 8252 8253
  env->GetChildren(path, &files);
  uint64_t number;
  FileType type;
  for (size_t i = 0; i < files.size(); ++i) {
    if (ParseFileName(files[i], &number, &type)) {
S
Stanislau Hlebik 已提交
8254
      if (type == expected_file_type) {
S
Stanislau Hlebik 已提交
8255
        file_numbers.push_back(number);
8256 8257 8258
      }
    }
  }
S
Stanislau Hlebik 已提交
8259
  return std::move(file_numbers);
8260
}
S
Stanislau Hlebik 已提交
8261 8262 8263 8264

std::vector<std::uint64_t> ListTableFiles(Env* env, const std::string& path) {
  return ListSpecificFiles(env, path, kTableFile);
}
I
Igor Canadi 已提交
8265
}  // namespace
8266

I
Igor Sugak 已提交
8267
TEST_F(DBTest, FlushOneColumnFamily) {
8268
  Options options = CurrentOptions();
S
Stanislau Hlebik 已提交
8269 8270
  CreateAndReopenWithCF({"pikachu", "ilya", "muromec", "dobrynia", "nikitich",
                         "alyosha", "popovich"},
L
Lei Jin 已提交
8271
                        options);
S
Stanislau Hlebik 已提交
8272 8273 8274 8275 8276 8277 8278 8279 8280 8281

  ASSERT_OK(Put(0, "Default", "Default"));
  ASSERT_OK(Put(1, "pikachu", "pikachu"));
  ASSERT_OK(Put(2, "ilya", "ilya"));
  ASSERT_OK(Put(3, "muromec", "muromec"));
  ASSERT_OK(Put(4, "dobrynia", "dobrynia"));
  ASSERT_OK(Put(5, "nikitich", "nikitich"));
  ASSERT_OK(Put(6, "alyosha", "alyosha"));
  ASSERT_OK(Put(7, "popovich", "popovich"));

8282
  for (int i = 0; i < 8; ++i) {
S
Stanislau Hlebik 已提交
8283 8284
    Flush(i);
    auto tables = ListTableFiles(env_, dbname_);
8285
    ASSERT_EQ(tables.size(), i + 1U);
S
Stanislau Hlebik 已提交
8286 8287 8288
  }
}

S
Stanislau Hlebik 已提交
8289 8290 8291 8292 8293
// In https://reviews.facebook.net/D20661 we change
// recovery behavior: previously for each log file each column family
// memtable was flushed, even it was empty. Now it's changed:
// we try to create the smallest number of table files by merging
// updates from multiple logs
I
Igor Sugak 已提交
8294
TEST_F(DBTest, RecoverCheckFileAmountWithSmallWriteBuffer) {
8295
  Options options = CurrentOptions();
S
Stanislau Hlebik 已提交
8296
  options.write_buffer_size = 5000000;
L
Lei Jin 已提交
8297
  CreateAndReopenWithCF({"pikachu", "dobrynia", "nikitich"}, options);
S
Stanislau Hlebik 已提交
8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312

  // Since we will reopen DB with smaller write_buffer_size,
  // each key will go to new SST file
  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));

  ASSERT_OK(Put(3, Key(10), DummyString(1)));
  // Make 'dobrynia' to be flushed and new WAL file to be created
  ASSERT_OK(Put(2, Key(10), DummyString(7500000)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[2]);
  {
    auto tables = ListTableFiles(env_, dbname_);
I
Igor Canadi 已提交
8313
    ASSERT_EQ(tables.size(), static_cast<size_t>(1));
S
Stanislau Hlebik 已提交
8314
    // Make sure 'dobrynia' was flushed: check sst files amount
I
Igor Canadi 已提交
8315 8316
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(1));
S
Stanislau Hlebik 已提交
8317 8318 8319 8320 8321 8322 8323 8324 8325 8326
  }
  // New WAL file
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(3, Key(10), DummyString(1)));
  ASSERT_OK(Put(3, Key(10), DummyString(1)));
  ASSERT_OK(Put(3, Key(10), DummyString(1)));

  options.write_buffer_size = 10;
  ReopenWithColumnFamilies({"default", "pikachu", "dobrynia", "nikitich"},
L
Lei Jin 已提交
8327
                           options);
S
Stanislau Hlebik 已提交
8328 8329
  {
    // No inserts => default is empty
I
Igor Canadi 已提交
8330 8331
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(0));
S
Stanislau Hlebik 已提交
8332
    // First 4 keys goes to separate SSTs + 1 more SST for 2 smaller keys
I
Igor Canadi 已提交
8333 8334
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(5));
S
Stanislau Hlebik 已提交
8335
    // 1 SST for big key + 1 SST for small one
I
Igor Canadi 已提交
8336 8337
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(2));
S
Stanislau Hlebik 已提交
8338
    // 1 SST for all keys
I
Igor Canadi 已提交
8339 8340
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(1));
S
Stanislau Hlebik 已提交
8341 8342 8343 8344 8345 8346 8347 8348
  }
}

// In https://reviews.facebook.net/D20661 we change
// recovery behavior: previously for each log file each column family
// memtable was flushed, even it wasn't empty. Now it's changed:
// we try to create the smallest number of table files by merging
// updates from multiple logs
I
Igor Sugak 已提交
8349
TEST_F(DBTest, RecoverCheckFileAmount) {
8350
  Options options = CurrentOptions();
S
Stanislau Hlebik 已提交
8351
  options.write_buffer_size = 100000;
L
Lei Jin 已提交
8352
  CreateAndReopenWithCF({"pikachu", "dobrynia", "nikitich"}, options);
S
Stanislau Hlebik 已提交
8353 8354 8355 8356 8357 8358 8359 8360 8361 8362 8363 8364

  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));

  // Make 'nikitich' memtable to be flushed
  ASSERT_OK(Put(3, Key(10), DummyString(1002400)));
  ASSERT_OK(Put(3, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  // 4 memtable are not flushed, 1 sst file
  {
    auto tables = ListTableFiles(env_, dbname_);
I
Igor Canadi 已提交
8365 8366 8367
    ASSERT_EQ(tables.size(), static_cast<size_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(1));
S
Stanislau Hlebik 已提交
8368 8369 8370 8371 8372 8373 8374 8375 8376 8377 8378 8379 8380 8381 8382 8383 8384 8385 8386 8387 8388
  }
  // Memtable for 'nikitich' has flushed, new WAL file has opened
  // 4 memtable still not flushed

  // Write to new WAL file
  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));

  // Fill up 'nikitich' one more time
  ASSERT_OK(Put(3, Key(10), DummyString(1002400)));
  // make it flush
  ASSERT_OK(Put(3, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  // There are still 4 memtable not flushed, and 2 sst tables
  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));

  {
    auto tables = ListTableFiles(env_, dbname_);
I
Igor Canadi 已提交
8389 8390 8391
    ASSERT_EQ(tables.size(), static_cast<size_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(2));
S
Stanislau Hlebik 已提交
8392 8393 8394
  }

  ReopenWithColumnFamilies({"default", "pikachu", "dobrynia", "nikitich"},
L
Lei Jin 已提交
8395
                           options);
S
Stanislau Hlebik 已提交
8396 8397 8398 8399 8400 8401
  {
    std::vector<uint64_t> table_files = ListTableFiles(env_, dbname_);
    // Check, that records for 'default', 'dobrynia' and 'pikachu' from
    // first, second and third WALs  went to the same SST.
    // So, there is 6 SSTs: three  for 'nikitich', one for 'default', one for
    // 'dobrynia', one for 'pikachu'
I
Igor Canadi 已提交
8402 8403 8404 8405 8406 8407 8408 8409
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(3));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(1));
S
Stanislau Hlebik 已提交
8410 8411 8412
  }
}

I
Igor Sugak 已提交
8413
TEST_F(DBTest, SharedWriteBuffer) {
8414
  Options options = CurrentOptions();
8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425 8426 8427 8428 8429 8430 8431 8432 8433 8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473 8474 8475 8476 8477 8478 8479 8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492
  options.db_write_buffer_size = 100000;  // this is the real limit
  options.write_buffer_size    = 500000;  // this is never hit
  CreateAndReopenWithCF({"pikachu", "dobrynia", "nikitich"}, options);

  // Trigger a flush on every CF
  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  ASSERT_OK(Put(1, Key(1), DummyString(1)));
  ASSERT_OK(Put(3, Key(1), DummyString(90000)));
  ASSERT_OK(Put(2, Key(2), DummyString(20000)));
  ASSERT_OK(Put(2, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[0]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[2]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  {
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(1));
  }

  // Flush 'dobrynia' and 'nikitich'
  ASSERT_OK(Put(2, Key(2), DummyString(50000)));
  ASSERT_OK(Put(3, Key(2), DummyString(40000)));
  ASSERT_OK(Put(2, Key(3), DummyString(20000)));
  ASSERT_OK(Put(3, Key(2), DummyString(40000)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[2]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  {
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(2));
  }

  // Make 'dobrynia' and 'nikitich' both take up 40% of space
  // When 'pikachu' puts us over 100%, all 3 flush.
  ASSERT_OK(Put(2, Key(2), DummyString(40000)));
  ASSERT_OK(Put(1, Key(2), DummyString(20000)));
  ASSERT_OK(Put(0, Key(1), DummyString(1)));
  dbfull()->TEST_WaitForFlushMemTable(handles_[2]);
  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
  {
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(1));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(3));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(3));
  }

  // Some remaining writes so 'default' and 'nikitich' flush on closure.
  ASSERT_OK(Put(3, Key(1), DummyString(1)));
  ReopenWithColumnFamilies({"default", "pikachu", "dobrynia", "nikitich"},
                           options);
  {
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
              static_cast<uint64_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
              static_cast<uint64_t>(2));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
              static_cast<uint64_t>(3));
    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
              static_cast<uint64_t>(4));
  }
}

I
Igor Sugak 已提交
8493
TEST_F(DBTest, PurgeInfoLogs) {
8494 8495 8496 8497 8498 8499 8500 8501 8502 8503 8504
  Options options = CurrentOptions();
  options.keep_log_file_num = 5;
  options.create_if_missing = true;
  for (int mode = 0; mode <= 1; mode++) {
    if (mode == 1) {
      options.db_log_dir = dbname_ + "_logs";
      env_->CreateDirIfMissing(options.db_log_dir);
    } else {
      options.db_log_dir = "";
    }
    for (int i = 0; i < 8; i++) {
L
Lei Jin 已提交
8505
      Reopen(options);
8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517
    }

    std::vector<std::string> files;
    env_->GetChildren(options.db_log_dir.empty() ? dbname_ : options.db_log_dir,
                      &files);
    int info_log_count = 0;
    for (std::string file : files) {
      if (file.find("LOG") != std::string::npos) {
        info_log_count++;
      }
    }
    ASSERT_EQ(5, info_log_count);
8518

L
Lei Jin 已提交
8519
    Destroy(options);
I
Igor Canadi 已提交
8520
    // For mode (1), test DestroyDB() to delete all the logs under DB dir.
8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533 8534 8535
    // For mode (2), no info log file should have been put under DB dir.
    std::vector<std::string> db_files;
    env_->GetChildren(dbname_, &db_files);
    for (std::string file : db_files) {
      ASSERT_TRUE(file.find("LOG") == std::string::npos);
    }

    if (mode == 1) {
      // Cleaning up
      env_->GetChildren(options.db_log_dir, &files);
      for (std::string file : files) {
        env_->DeleteFile(options.db_log_dir + "/" + file);
      }
      env_->DeleteDir(options.db_log_dir);
    }
8536 8537 8538
  }
}

I
Igor Canadi 已提交
8539
namespace {
8540 8541 8542 8543
SequenceNumber ReadRecords(
    std::unique_ptr<TransactionLogIterator>& iter,
    int& count) {
  count = 0;
8544
  SequenceNumber lastSequence = 0;
8545
  BatchResult res;
8546
  while (iter->Valid()) {
8547
    res = iter->GetBatch();
8548
    EXPECT_TRUE(res.sequence > lastSequence);
8549
    ++count;
8550
    lastSequence = res.sequence;
8551
    EXPECT_OK(iter->status());
8552 8553
    iter->Next();
  }
8554 8555 8556 8557 8558 8559 8560 8561 8562
  return res.sequence;
}

void ExpectRecords(
    const int expected_no_records,
    std::unique_ptr<TransactionLogIterator>& iter) {
  int num_records;
  ReadRecords(iter, num_records);
  ASSERT_EQ(num_records, expected_no_records);
8563
}
I
Igor Canadi 已提交
8564
}  // namespace
8565

I
Igor Sugak 已提交
8566
TEST_F(DBTest, TransactionLogIterator) {
8567 8568
  do {
    Options options = OptionsForLogIterTest();
L
Lei Jin 已提交
8569
    DestroyAndReopen(options);
L
Lei Jin 已提交
8570
    CreateAndReopenWithCF({"pikachu"}, options);
8571 8572 8573
    Put(0, "key1", DummyString(1024));
    Put(1, "key2", DummyString(1024));
    Put(1, "key2", DummyString(1024));
8574 8575 8576 8577 8578
    ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 3U);
    {
      auto iter = OpenTransactionLogIter(0);
      ExpectRecords(3, iter);
    }
L
Lei Jin 已提交
8579
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
8580 8581 8582 8583 8584
    env_->SleepForMicroseconds(2 * 1000 * 1000);
    {
      Put(0, "key4", DummyString(1024));
      Put(1, "key5", DummyString(1024));
      Put(0, "key6", DummyString(1024));
8585 8586 8587 8588 8589 8590
    }
    {
      auto iter = OpenTransactionLogIter(0);
      ExpectRecords(6, iter);
    }
  } while (ChangeCompactOptions());
8591 8592
}

8593
#ifndef NDEBUG // sync point is not included with DNDEBUG build
I
Igor Sugak 已提交
8594
TEST_F(DBTest, TransactionLogIteratorRace) {
8595
  static const int LOG_ITERATOR_RACE_TEST_COUNT = 2;
I
Igor Canadi 已提交
8596 8597 8598 8599 8600 8601 8602
  static const char* sync_points[LOG_ITERATOR_RACE_TEST_COUNT][4] = {
      {"WalManager::GetSortedWalFiles:1",  "WalManager::PurgeObsoleteFiles:1",
       "WalManager::PurgeObsoleteFiles:2", "WalManager::GetSortedWalFiles:2"},
      {"WalManager::GetSortedWalsOfType:1",
       "WalManager::PurgeObsoleteFiles:1",
       "WalManager::PurgeObsoleteFiles:2",
       "WalManager::GetSortedWalsOfType:2"}};
8603 8604 8605 8606 8607 8608 8609 8610 8611 8612 8613 8614
  for (int test = 0; test < LOG_ITERATOR_RACE_TEST_COUNT; ++test) {
    // Setup sync point dependency to reproduce the race condition of
    // a log file moved to archived dir, in the middle of GetSortedWalFiles
    rocksdb::SyncPoint::GetInstance()->LoadDependency(
      { { sync_points[test][0], sync_points[test][1] },
        { sync_points[test][2], sync_points[test][3] },
      });

    do {
      rocksdb::SyncPoint::GetInstance()->ClearTrace();
      rocksdb::SyncPoint::GetInstance()->DisableProcessing();
      Options options = OptionsForLogIterTest();
L
Lei Jin 已提交
8615
      DestroyAndReopen(options);
8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628
      Put("key1", DummyString(1024));
      dbfull()->Flush(FlushOptions());
      Put("key2", DummyString(1024));
      dbfull()->Flush(FlushOptions());
      Put("key3", DummyString(1024));
      dbfull()->Flush(FlushOptions());
      Put("key4", DummyString(1024));
      ASSERT_EQ(dbfull()->GetLatestSequenceNumber(), 4U);

      {
        auto iter = OpenTransactionLogIter(0);
        ExpectRecords(4, iter);
      }
8629

8630 8631 8632 8633 8634 8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646
      rocksdb::SyncPoint::GetInstance()->EnableProcessing();
      // trigger async flush, and log move. Well, log move will
      // wait until the GetSortedWalFiles:1 to reproduce the race
      // condition
      FlushOptions flush_options;
      flush_options.wait = false;
      dbfull()->Flush(flush_options);

      // "key5" would be written in a new memtable and log
      Put("key5", DummyString(1024));
      {
        // this iter would miss "key4" if not fixed
        auto iter = OpenTransactionLogIter(0);
        ExpectRecords(5, iter);
      }
    } while (ChangeCompactOptions());
  }
8647
}
8648
#endif
8649

I
Igor Sugak 已提交
8650
TEST_F(DBTest, TransactionLogIteratorStallAtLastRecord) {
8651 8652
  do {
    Options options = OptionsForLogIterTest();
L
Lei Jin 已提交
8653
    DestroyAndReopen(options);
8654 8655 8656 8657 8658 8659 8660 8661 8662 8663 8664 8665
    Put("key1", DummyString(1024));
    auto iter = OpenTransactionLogIter(0);
    ASSERT_OK(iter->status());
    ASSERT_TRUE(iter->Valid());
    iter->Next();
    ASSERT_TRUE(!iter->Valid());
    ASSERT_OK(iter->status());
    Put("key2", DummyString(1024));
    iter->Next();
    ASSERT_OK(iter->status());
    ASSERT_TRUE(iter->Valid());
  } while (ChangeCompactOptions());
8666 8667
}

I
Igor Sugak 已提交
8668
TEST_F(DBTest, TransactionLogIteratorCheckAfterRestart) {
8669 8670
  do {
    Options options = OptionsForLogIterTest();
L
Lei Jin 已提交
8671
    DestroyAndReopen(options);
8672 8673 8674
    Put("key1", DummyString(1024));
    Put("key2", DummyString(1023));
    dbfull()->Flush(FlushOptions());
L
Lei Jin 已提交
8675
    Reopen(options);
8676 8677 8678
    auto iter = OpenTransactionLogIter(0);
    ExpectRecords(2, iter);
  } while (ChangeCompactOptions());
8679 8680
}

I
Igor Sugak 已提交
8681
TEST_F(DBTest, TransactionLogIteratorCorruptedLog) {
8682 8683
  do {
    Options options = OptionsForLogIterTest();
L
Lei Jin 已提交
8684
    DestroyAndReopen(options);
8685
    for (int i = 0; i < 1024; i++) {
8686
      Put("key"+ToString(i), DummyString(10));
8687 8688 8689 8690 8691
    }
    dbfull()->Flush(FlushOptions());
    // Corrupt this log to create a gap
    rocksdb::VectorLogPtr wal_files;
    ASSERT_OK(dbfull()->GetSortedWalFiles(wal_files));
8692 8693 8694 8695 8696 8697 8698 8699
    const auto logfile_path = dbname_ + "/" + wal_files.front()->PathName();
    if (mem_env_) {
      mem_env_->Truncate(logfile_path, wal_files.front()->SizeFileBytes() / 2);
    } else {
      ASSERT_EQ(0, truncate(logfile_path.c_str(),
                   wal_files.front()->SizeFileBytes() / 2));
    }

8700 8701 8702 8703 8704 8705
    // Insert a new entry to a new log file
    Put("key1025", DummyString(10));
    // Try to read from the beginning. Should stop before the gap and read less
    // than 1025 entries
    auto iter = OpenTransactionLogIter(0);
    int count;
8706 8707
    SequenceNumber last_sequence_read = ReadRecords(iter, count);
    ASSERT_LT(last_sequence_read, 1025U);
8708 8709 8710 8711 8712 8713
    // Try to read past the gap, should be able to seek to key1025
    auto iter2 = OpenTransactionLogIter(last_sequence_read + 1);
    ExpectRecords(1, iter2);
  } while (ChangeCompactOptions());
}

K
krad 已提交
8714 8715 8716 8717 8718 8719
//
// Test WAL recovery for the various modes available
//
class RecoveryTestHelper {
 public:

8720 8721 8722 8723 8724 8725 8726 8727
  // Number of WAL files to generate
  static const int kWALFilesCount = 10;
  // Starting number for the WAL file name like 00010.log
  static const int kWALFileOffset = 10;
  // Keys to be written per WAL file
  static const int kKeysPerWALFile = 1024;
  // Size of the value
  static const int kValueSize = 10;
K
krad 已提交
8728

8729 8730 8731 8732 8733 8734 8735 8736 8737 8738 8739 8740 8741 8742 8743 8744 8745 8746 8747 8748 8749 8750 8751 8752 8753 8754 8755 8756 8757 8758 8759 8760 8761 8762 8763 8764 8765 8766 8767 8768 8769
  // Create WAL files with values filled in
  static void FillData(DBTest* test, Options& options,
                       const size_t wal_count, size_t & count) {
    DBOptions & db_options = options;

    count = 0;

    shared_ptr<Cache> table_cache = NewLRUCache(50000, 16);
    EnvOptions env_options;
    WriteBuffer write_buffer(db_options.db_write_buffer_size);

    unique_ptr<VersionSet> versions;
    unique_ptr<WalManager> wal_manager;
    WriteController write_controller;

    versions.reset(new VersionSet(test->dbname_, &db_options, env_options,
                                  table_cache.get(), &write_buffer,
                                  &write_controller));

    wal_manager.reset(new WalManager(db_options, env_options));

    std::unique_ptr<log::Writer> current_log_writer;

    for (size_t j = kWALFileOffset; j < wal_count + kWALFileOffset; j++) {
      uint64_t current_log_number =  j;
      std::string fname = LogFileName(test->dbname_, current_log_number);
      unique_ptr<WritableFile> file;
      ASSERT_OK(db_options.env->NewWritableFile(fname, &file, env_options));
      current_log_writer.reset(new log::Writer(std::move(file)));

      for (int i = 0; i < kKeysPerWALFile; i++) {
        std::string key = "key" + ToString(count++);
        std::string value = test->DummyString(kValueSize);
        assert(current_log_writer.get() != nullptr);
        uint64_t seq =  versions->LastSequence() + 1;
        WriteBatch batch;
        batch.Put(key, value);
        WriteBatchInternal::SetSequence(&batch, seq);
        current_log_writer->AddRecord(WriteBatchInternal::Contents(&batch));
        versions->SetLastSequence(seq);
      }
K
krad 已提交
8770
    }
8771 8772 8773 8774 8775 8776 8777 8778 8779 8780
  }

  // Recreate and fill the store with some data
  static size_t FillData(DBTest* test, Options& options) {
    options.create_if_missing = true;
    test->DestroyAndReopen(options);
    test->Close();

    size_t count = 0;
    FillData(test, options, kWALFilesCount, count);
K
krad 已提交
8781 8782 8783 8784 8785 8786
    return count;
  }

  // Read back all the keys we wrote and return the number of keys found
  static size_t GetData(DBTest* test) {
    size_t count = 0;
8787
    for (size_t i = 0; i < kWALFilesCount * kKeysPerWALFile; i++) {
K
krad 已提交
8788 8789 8790 8791 8792 8793 8794
      if (test->Get("key" + ToString(i)) != "NOT_FOUND") {
        ++count;
      }
    }
    return count;
  }

8795 8796 8797 8798 8799 8800 8801 8802 8803
  // Manuall corrupt the specified WAL
  static void CorruptWAL(DBTest * test, Options& options,
                         const double off, const double len,
                         const int wal_file_id, const bool trunc = false) {
    Env* env = options.env;
    std::string fname = LogFileName(test->dbname_, wal_file_id);
    uint64_t size;
    ASSERT_OK(env->GetFileSize(fname, &size));
    ASSERT_GT(size, 0);
D
Dmitri Smirnov 已提交
8804 8805 8806 8807 8808 8809 8810 8811
#ifdef OS_WIN
    // Windows disk cache behaves differently. When we truncate
    // the original content is still in the cache due to the original
    // handle is still open. Generally, in Windows, one prohibits
    // shared access to files and it is not needed for WAL but we allow
    // it to induce corruption at various tests.
    test->Close();
#endif
8812 8813 8814 8815 8816 8817 8818
    if (trunc) {
      ASSERT_EQ(0, truncate(fname.c_str(), size * off));
    } else {
      InduceCorruption(fname, size * off, size * len);
    }
  }

K
krad 已提交
8819 8820 8821 8822 8823 8824 8825 8826 8827 8828
  // Overwrite data with 'a' from offset for length len
  static void InduceCorruption(const std::string& filename, uint32_t offset,
                               uint32_t len) {
    ASSERT_GT(len, 0);

    int fd = open(filename.c_str(), O_RDWR);

    ASSERT_GT(fd, 0);
    ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));

D
Dmitri Smirnov 已提交
8829
    void* buf = alloca(len);
K
krad 已提交
8830 8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841
    memset(buf, 'a', len);
    ASSERT_EQ(len, write(fd, buf, len));

    close(fd);
  }
};

// Test scope:
// - We expect to open the data store when there is incomplete trailing writes
// at the end of any of the logs
// - We do not expect to open the data store for corruption
TEST_F(DBTest, kTolerateCorruptedTailRecords) {
8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859 8860 8861 8862 8863 8864 8865 8866 8867
  const int jstart =  RecoveryTestHelper::kWALFileOffset;
  const int jend = jstart + RecoveryTestHelper::kWALFilesCount; 

  for (auto trunc : {true, false}) {  /* Corruption style */
    for (int i = 0; i < 4; i++) { /* Corruption offset position */
      for (int j = jstart; j < jend; j++) { /* WAL file */
        // Fill data for testing
        Options options = CurrentOptions();
        const size_t row_count = RecoveryTestHelper::FillData(this, options);
        // test checksum failure or parsing
        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/ i * .3,
                                       /*len%=*/ .1, /*wal=*/ j, trunc);

        if (trunc) {
          options.wal_recovery_mode =
              WALRecoveryMode::kTolerateCorruptedTailRecords;
          options.create_if_missing = false;
          ASSERT_OK(TryReopen(options));
          const size_t recovered_row_count = RecoveryTestHelper::GetData(this);
          ASSERT_TRUE(i == 0 || recovered_row_count > 0);
          ASSERT_LT(recovered_row_count, row_count);
        } else {
          options.wal_recovery_mode =
              WALRecoveryMode::kTolerateCorruptedTailRecords;
          ASSERT_NOK(TryReopen(options));
        }
K
krad 已提交
8868 8869 8870 8871 8872 8873 8874 8875 8876
      }
    }
  }
}

// Test scope:
// We don't expect the data store to be opened if there is any corruption
// (leading, middle or trailing -- incomplete writes or corruption)
TEST_F(DBTest, kAbsoluteConsistency) {
8877 8878 8879 8880
  const int jstart =  RecoveryTestHelper::kWALFileOffset;
  const int jend = jstart + RecoveryTestHelper::kWALFilesCount; 

  // Verify clean slate behavior
K
krad 已提交
8881 8882 8883
  Options options = CurrentOptions();
  const size_t row_count = RecoveryTestHelper::FillData(this, options);
  options.wal_recovery_mode = WALRecoveryMode::kAbsoluteConsistency;
8884
  options.create_if_missing = false;
K
krad 已提交
8885 8886 8887
  ASSERT_OK(TryReopen(options));
  ASSERT_EQ(RecoveryTestHelper::GetData(this), row_count);

8888 8889
  for (auto trunc : {true, false}) { /* Corruption style */
    for (int i = 0; i < 4; i++) { /* Corruption offset position */
K
krad 已提交
8890 8891 8892 8893
      if (trunc && i == 0) {
        continue;
      }

8894 8895 8896 8897 8898 8899 8900 8901 8902 8903 8904
      for (int j = jstart; j < jend; j++) { /* wal files */
        // fill with new date
        RecoveryTestHelper::FillData(this, options);
        // corrupt the wal
        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/ i * .3,
                                       /*len%=*/.1, j, trunc);
        // verify
        options.wal_recovery_mode = WALRecoveryMode::kAbsoluteConsistency;
        options.create_if_missing = false;
        ASSERT_NOK(TryReopen(options));
      }
K
krad 已提交
8905 8906 8907 8908 8909 8910 8911 8912
    }
  }
}

// Test scope:
// - We expect to open data store under all circumstances
// - We expect only data upto the point where the first error was encountered
TEST_F(DBTest, kPointInTimeRecovery) {
8913 8914 8915 8916 8917 8918 8919 8920 8921 8922 8923 8924 8925 8926 8927 8928 8929 8930 8931 8932
  const int jstart =  RecoveryTestHelper::kWALFileOffset;
  const int jend = jstart + RecoveryTestHelper::kWALFilesCount;
  const int maxkeys = RecoveryTestHelper::kWALFilesCount *
                        RecoveryTestHelper::kKeysPerWALFile;

  for (auto trunc : {true, false}) { /* Corruption style */
    for (int i = 0; i < 4; i++) { /* Offset of corruption */
      for (int j = jstart; j < jend; j++) { /* WAL file */
        // Fill data for testing
        Options options = CurrentOptions();
        const size_t row_count = RecoveryTestHelper::FillData(this, options);

        // Corrupt the wal
        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/ i * .3,
                                       /*len%=*/.1, j, trunc);

        // Verify
        options.wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
        options.create_if_missing = false;
        ASSERT_OK(TryReopen(options));
K
krad 已提交
8933

8934 8935 8936
        // Probe data for invariants
        size_t recovered_row_count = RecoveryTestHelper::GetData(this);
        ASSERT_LT(recovered_row_count, row_count);
K
krad 已提交
8937

8938 8939 8940 8941 8942 8943 8944 8945
        bool expect_data = true;
        for (size_t k = 0; k < maxkeys; ++k) {
          bool found = Get("key" + ToString(i)) != "NOT_FOUND";
          if (expect_data && !found) {
            expect_data = false;
          }
          ASSERT_EQ(found, expect_data);
        }
K
krad 已提交
8946

8947 8948 8949 8950 8951 8952 8953
        const size_t min = RecoveryTestHelper::kKeysPerWALFile *
                              (j - RecoveryTestHelper::kWALFileOffset);
        ASSERT_GE(recovered_row_count, min);
        if (!trunc && i != 0) {
          const size_t max = RecoveryTestHelper::kKeysPerWALFile *
                                (j - RecoveryTestHelper::kWALFileOffset + 1);
          ASSERT_LE(recovered_row_count, max);
K
krad 已提交
8954 8955 8956 8957 8958 8959 8960 8961 8962 8963
        }
      }
    }
  }
}

// Test scope:
// - We expect to open the data store under all scenarios
// - We expect to have recovered records past the corruption zone
TEST_F(DBTest, kSkipAnyCorruptedRecords) {
8964 8965 8966 8967 8968 8969 8970 8971 8972 8973 8974 8975 8976 8977 8978 8979 8980 8981
  const int jstart =  RecoveryTestHelper::kWALFileOffset;
  const int jend = jstart + RecoveryTestHelper::kWALFilesCount; 

  for (auto trunc : {true, false}) { /* Corruption style */
    for (int i = 0; i < 4; i++) { /* Corruption offset */
      for (int j = jstart; j < jend; j++) { /* wal files */
        // Fill data for testing
        Options options = CurrentOptions();
        const size_t row_count = RecoveryTestHelper::FillData(this, options);

        // Corrupt the WAL
        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/ i * .3,
                                       /*len%=*/.1, j, trunc);

        // Verify behavior
        options.wal_recovery_mode = WALRecoveryMode::kSkipAnyCorruptedRecords;
        options.create_if_missing = false;
        ASSERT_OK(TryReopen(options));
K
krad 已提交
8982

8983 8984 8985
        // Probe data for invariants
        size_t recovered_row_count = RecoveryTestHelper::GetData(this);
        ASSERT_LT(recovered_row_count, row_count);
K
krad 已提交
8986

8987 8988 8989
        if (!trunc) {
          ASSERT_TRUE(i != 0 || recovered_row_count > 0);
        }
K
krad 已提交
8990 8991 8992 8993 8994
      }
    }
  }
}

I
Igor Sugak 已提交
8995
TEST_F(DBTest, TransactionLogIteratorBatchOperations) {
8996 8997
  do {
    Options options = OptionsForLogIterTest();
L
Lei Jin 已提交
8998
    DestroyAndReopen(options);
L
Lei Jin 已提交
8999
    CreateAndReopenWithCF({"pikachu"}, options);
9000
    WriteBatch batch;
I
Igor Canadi 已提交
9001 9002 9003 9004
    batch.Put(handles_[1], "key1", DummyString(1024));
    batch.Put(handles_[0], "key2", DummyString(1024));
    batch.Put(handles_[1], "key3", DummyString(1024));
    batch.Delete(handles_[0], "key2");
9005
    dbfull()->Write(WriteOptions(), &batch);
9006 9007
    Flush(1);
    Flush(0);
L
Lei Jin 已提交
9008
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
9009
    Put(1, "key4", DummyString(1024));
9010
    auto iter = OpenTransactionLogIter(3);
9011
    ExpectRecords(2, iter);
9012
  } while (ChangeCompactOptions());
9013 9014
}

I
Igor Sugak 已提交
9015
TEST_F(DBTest, TransactionLogIteratorBlobs) {
J
Jim Paton 已提交
9016
  Options options = OptionsForLogIterTest();
L
Lei Jin 已提交
9017
  DestroyAndReopen(options);
L
Lei Jin 已提交
9018
  CreateAndReopenWithCF({"pikachu"}, options);
J
Jim Paton 已提交
9019 9020
  {
    WriteBatch batch;
I
Igor Canadi 已提交
9021 9022
    batch.Put(handles_[1], "key1", DummyString(1024));
    batch.Put(handles_[0], "key2", DummyString(1024));
J
Jim Paton 已提交
9023
    batch.PutLogData(Slice("blob1"));
I
Igor Canadi 已提交
9024
    batch.Put(handles_[1], "key3", DummyString(1024));
J
Jim Paton 已提交
9025
    batch.PutLogData(Slice("blob2"));
I
Igor Canadi 已提交
9026
    batch.Delete(handles_[0], "key2");
J
Jim Paton 已提交
9027
    dbfull()->Write(WriteOptions(), &batch);
L
Lei Jin 已提交
9028
    ReopenWithColumnFamilies({"default", "pikachu"}, options);
J
Jim Paton 已提交
9029 9030 9031 9032 9033
  }

  auto res = OpenTransactionLogIter(0)->GetBatch();
  struct Handler : public WriteBatch::Handler {
    std::string seen;
I
Igor Sugak 已提交
9034 9035
    virtual Status PutCF(uint32_t cf, const Slice& key,
                         const Slice& value) override {
9036 9037
      seen += "Put(" + ToString(cf) + ", " + key.ToString() + ", " +
              ToString(value.size()) + ")";
9038
      return Status::OK();
J
Jim Paton 已提交
9039
    }
I
Igor Sugak 已提交
9040 9041
    virtual Status MergeCF(uint32_t cf, const Slice& key,
                           const Slice& value) override {
9042 9043
      seen += "Merge(" + ToString(cf) + ", " + key.ToString() + ", " +
              ToString(value.size()) + ")";
9044
      return Status::OK();
J
Jim Paton 已提交
9045
    }
I
Igor Sugak 已提交
9046
    virtual void LogData(const Slice& blob) override {
J
Jim Paton 已提交
9047 9048
      seen += "LogData(" + blob.ToString() + ")";
    }
I
Igor Sugak 已提交
9049
    virtual Status DeleteCF(uint32_t cf, const Slice& key) override {
9050
      seen += "Delete(" + ToString(cf) + ", " + key.ToString() + ")";
9051
      return Status::OK();
J
Jim Paton 已提交
9052 9053 9054
    }
  } handler;
  res.writeBatchPtr->Iterate(&handler);
9055 9056 9057 9058 9059 9060 9061 9062
  ASSERT_EQ(
      "Put(1, key1, 1024)"
      "Put(0, key2, 1024)"
      "LogData(blob1)"
      "Put(1, key3, 1024)"
      "LogData(blob2)"
      "Delete(0, key2)",
      handler.seen);
J
Jim Paton 已提交
9063 9064
}

9065 9066 9067
// Multi-threaded test:
namespace {

9068 9069
static const int kColumnFamilies = 10;
static const int kNumThreads = 10;
9070 9071 9072 9073 9074
static const int kTestSeconds = 10;
static const int kNumKeys = 1000;

struct MTState {
  DBTest* test;
I
Igor Canadi 已提交
9075 9076 9077
  std::atomic<bool> stop;
  std::atomic<int> counter[kNumThreads];
  std::atomic<bool> thread_done[kNumThreads];
9078 9079 9080 9081 9082 9083 9084 9085 9086
};

struct MTThread {
  MTState* state;
  int id;
};

static void MTThreadBody(void* arg) {
  MTThread* t = reinterpret_cast<MTThread*>(arg);
9087
  int id = t->id;
9088
  DB* db = t->state->test->db_;
I
Igor Canadi 已提交
9089
  int counter = 0;
9090 9091
  fprintf(stderr, "... starting thread %d\n", id);
  Random rnd(1000 + id);
9092
  char valbuf[1500];
I
Igor Canadi 已提交
9093 9094
  while (t->state->stop.load(std::memory_order_acquire) == false) {
    t->state->counter[id].store(counter, std::memory_order_release);
9095 9096 9097 9098 9099 9100

    int key = rnd.Uniform(kNumKeys);
    char keybuf[20];
    snprintf(keybuf, sizeof(keybuf), "%016d", key);

    if (rnd.OneIn(2)) {
9101 9102
      // Write values of the form <key, my id, counter, cf, unique_id>.
      // into each of the CFs
9103
      // We add some padding for force compactions.
9104
      int unique_id = rnd.Uniform(1000000);
9105 9106 9107 9108 9109 9110 9111 9112 9113 9114 9115 9116 9117 9118 9119 9120 9121 9122 9123

      // Half of the time directly use WriteBatch. Half of the time use
      // WriteBatchWithIndex.
      if (rnd.OneIn(2)) {
        WriteBatch batch;
        for (int cf = 0; cf < kColumnFamilies; ++cf) {
          snprintf(valbuf, sizeof(valbuf), "%d.%d.%d.%d.%-1000d", key, id,
                   static_cast<int>(counter), cf, unique_id);
          batch.Put(t->state->test->handles_[cf], Slice(keybuf), Slice(valbuf));
        }
        ASSERT_OK(db->Write(WriteOptions(), &batch));
      } else {
        WriteBatchWithIndex batch(db->GetOptions().comparator);
        for (int cf = 0; cf < kColumnFamilies; ++cf) {
          snprintf(valbuf, sizeof(valbuf), "%d.%d.%d.%d.%-1000d", key, id,
                   static_cast<int>(counter), cf, unique_id);
          batch.Put(t->state->test->handles_[cf], Slice(keybuf), Slice(valbuf));
        }
        ASSERT_OK(db->Write(WriteOptions(), batch.GetWriteBatch()));
9124
      }
9125
    } else {
9126 9127 9128 9129 9130 9131 9132 9133 9134 9135 9136 9137 9138 9139
      // Read a value and verify that it matches the pattern written above
      // and that writes to all column families were atomic (unique_id is the
      // same)
      std::vector<Slice> keys(kColumnFamilies, Slice(keybuf));
      std::vector<std::string> values;
      std::vector<Status> statuses =
          db->MultiGet(ReadOptions(), t->state->test->handles_, keys, &values);
      Status s = statuses[0];
      // all statuses have to be the same
      for (size_t i = 1; i < statuses.size(); ++i) {
        // they are either both ok or both not-found
        ASSERT_TRUE((s.ok() && statuses[i].ok()) ||
                    (s.IsNotFound() && statuses[i].IsNotFound()));
      }
9140 9141 9142 9143 9144
      if (s.IsNotFound()) {
        // Key has not yet been written
      } else {
        // Check that the writer thread counter is >= the counter in the value
        ASSERT_OK(s);
9145 9146 9147 9148 9149 9150 9151 9152 9153
        int unique_id = -1;
        for (int i = 0; i < kColumnFamilies; ++i) {
          int k, w, c, cf, u;
          ASSERT_EQ(5, sscanf(values[i].c_str(), "%d.%d.%d.%d.%d", &k, &w,
                              &c, &cf, &u))
              << values[i];
          ASSERT_EQ(k, key);
          ASSERT_GE(w, 0);
          ASSERT_LT(w, kNumThreads);
I
Igor Canadi 已提交
9154
          ASSERT_LE(c, t->state->counter[w].load(std::memory_order_acquire));
9155 9156 9157 9158 9159 9160 9161 9162 9163
          ASSERT_EQ(cf, i);
          if (i == 0) {
            unique_id = u;
          } else {
            // this checks that updates across column families happened
            // atomically -- all unique ids are the same
            ASSERT_EQ(u, unique_id);
          }
        }
9164 9165 9166 9167
      }
    }
    counter++;
  }
I
Igor Canadi 已提交
9168
  t->state->thread_done[id].store(true, std::memory_order_release);
9169
  fprintf(stderr, "... stopping thread %d after %d ops\n", id, int(counter));
9170 9171
}

H
Hans Wennborg 已提交
9172
}  // namespace
9173

9174 9175 9176 9177 9178 9179 9180 9181 9182 9183 9184 9185 9186 9187 9188 9189 9190 9191
class MultiThreadedDBTest : public DBTest,
                            public ::testing::WithParamInterface<int> {
 public:
  virtual void SetUp() override { option_config_ = GetParam(); }

  static std::vector<int> GenerateOptionConfigs() {
    std::vector<int> optionConfigs;
    for (int optionConfig = kDefault; optionConfig < kEnd; ++optionConfig) {
      // skip as HashCuckooRep does not support snapshot
      if (optionConfig != kHashCuckoo) {
        optionConfigs.push_back(optionConfig);
      }
    }
    return optionConfigs;
  }
};

TEST_P(MultiThreadedDBTest, MultiThreaded) {
9192 9193
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
9194 9195 9196 9197 9198 9199 9200 9201 9202 9203 9204 9205 9206
  std::vector<std::string> cfs;
  for (int i = 1; i < kColumnFamilies; ++i) {
    cfs.push_back(ToString(i));
  }
  CreateAndReopenWithCF(cfs, CurrentOptions(options_override));
  // Initialize state
  MTState mt;
  mt.test = this;
  mt.stop.store(false, std::memory_order_release);
  for (int id = 0; id < kNumThreads; id++) {
    mt.counter[id].store(0, std::memory_order_release);
    mt.thread_done[id].store(false, std::memory_order_release);
  }
9207

9208 9209 9210 9211 9212 9213 9214
  // Start threads
  MTThread thread[kNumThreads];
  for (int id = 0; id < kNumThreads; id++) {
    thread[id].state = &mt;
    thread[id].id = id;
    env_->StartThread(MTThreadBody, &thread[id]);
  }
9215

9216 9217
  // Let them run for a while
  env_->SleepForMicroseconds(kTestSeconds * 1000000);
9218

9219 9220 9221 9222 9223
  // Stop the threads and wait for them to finish
  mt.stop.store(true, std::memory_order_release);
  for (int id = 0; id < kNumThreads; id++) {
    while (mt.thread_done[id].load(std::memory_order_acquire) == false) {
      env_->SleepForMicroseconds(100000);
9224
    }
9225
  }
9226 9227
}

9228 9229 9230 9231
INSTANTIATE_TEST_CASE_P(
    MultiThreaded, MultiThreadedDBTest,
    ::testing::ValuesIn(MultiThreadedDBTest::GenerateOptionConfigs()));

9232 9233 9234 9235 9236 9237 9238 9239 9240 9241 9242 9243 9244 9245 9246 9247 9248 9249 9250
// Group commit test:
namespace {

static const int kGCNumThreads = 4;
static const int kGCNumKeys = 1000;

struct GCThread {
  DB* db;
  int id;
  std::atomic<bool> done;
};

static void GCThreadBody(void* arg) {
  GCThread* t = reinterpret_cast<GCThread*>(arg);
  int id = t->id;
  DB* db = t->db;
  WriteOptions wo;

  for (int i = 0; i < kGCNumKeys; ++i) {
9251
    std::string kv(ToString(i + id * kGCNumKeys));
9252 9253 9254 9255 9256 9257 9258
    ASSERT_OK(db->Put(wo, kv, kv));
  }
  t->done = true;
}

}  // namespace

I
Igor Sugak 已提交
9259
TEST_F(DBTest, GroupCommitTest) {
9260
  do {
9261
    Options options = CurrentOptions();
9262 9263
    options.env = env_;
    env_->log_write_slowdown_.store(100);
9264
    options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
9265
    Reopen(options);
9266

9267 9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279 9280
    // Start threads
    GCThread thread[kGCNumThreads];
    for (int id = 0; id < kGCNumThreads; id++) {
      thread[id].id = id;
      thread[id].db = db_;
      thread[id].done = false;
      env_->StartThread(GCThreadBody, &thread[id]);
    }

    for (int id = 0; id < kGCNumThreads; id++) {
      while (thread[id].done == false) {
        env_->SleepForMicroseconds(100000);
      }
    }
9281 9282
    env_->log_write_slowdown_.store(0);

9283
    ASSERT_GT(TestGetTickerCount(options, WRITE_DONE_BY_OTHER), 0);
9284 9285 9286

    std::vector<std::string> expected_db;
    for (int i = 0; i < kGCNumThreads * kGCNumKeys; ++i) {
9287
      expected_db.push_back(ToString(i));
9288 9289 9290 9291 9292 9293 9294 9295 9296 9297 9298 9299
    }
    sort(expected_db.begin(), expected_db.end());

    Iterator* itr = db_->NewIterator(ReadOptions());
    itr->SeekToFirst();
    for (auto x : expected_db) {
      ASSERT_TRUE(itr->Valid());
      ASSERT_EQ(itr->key().ToString(), x);
      ASSERT_EQ(itr->value().ToString(), x);
      itr->Next();
    }
    ASSERT_TRUE(!itr->Valid());
I
Igor Canadi 已提交
9300
    delete itr;
9301

9302 9303 9304
    HistogramData hist_data = {0};
    options.statistics->histogramData(DB_WRITE, &hist_data);
    ASSERT_GT(hist_data.average, 0.0);
9305
  } while (ChangeOptions(kSkipNoSeekToLast));
9306 9307
}

9308 9309 9310 9311
namespace {
typedef std::map<std::string, std::string> KVMap;
}

J
jorlow@chromium.org 已提交
9312 9313
class ModelDB: public DB {
 public:
9314 9315 9316
  class ModelSnapshot : public Snapshot {
   public:
    KVMap map_;
I
Igor Canadi 已提交
9317

I
Igor Sugak 已提交
9318
    virtual SequenceNumber GetSequenceNumber() const override {
I
Igor Canadi 已提交
9319 9320 9321 9322
      // no need to call this
      assert(false);
      return 0;
    }
9323 9324
  };

9325
  explicit ModelDB(const Options& options) : options_(options) {}
9326
  using DB::Put;
9327
  virtual Status Put(const WriteOptions& o, ColumnFamilyHandle* cf,
I
Igor Sugak 已提交
9328
                     const Slice& k, const Slice& v) override {
9329
    WriteBatch batch;
I
Igor Canadi 已提交
9330
    batch.Put(cf, k, v);
9331
    return Write(o, &batch);
9332 9333
  }
  using DB::Merge;
9334
  virtual Status Merge(const WriteOptions& o, ColumnFamilyHandle* cf,
I
Igor Sugak 已提交
9335
                       const Slice& k, const Slice& v) override {
9336
    WriteBatch batch;
I
Igor Canadi 已提交
9337
    batch.Merge(cf, k, v);
9338
    return Write(o, &batch);
9339 9340
  }
  using DB::Delete;
9341
  virtual Status Delete(const WriteOptions& o, ColumnFamilyHandle* cf,
I
Igor Sugak 已提交
9342
                        const Slice& key) override {
9343
    WriteBatch batch;
I
Igor Canadi 已提交
9344
    batch.Delete(cf, key);
9345
    return Write(o, &batch);
9346 9347
  }
  using DB::Get;
9348
  virtual Status Get(const ReadOptions& options, ColumnFamilyHandle* cf,
I
Igor Sugak 已提交
9349
                     const Slice& key, std::string* value) override {
9350 9351 9352
    return Status::NotSupported(key);
  }

9353 9354 9355
  using DB::MultiGet;
  virtual std::vector<Status> MultiGet(
      const ReadOptions& options,
9356
      const std::vector<ColumnFamilyHandle*>& column_family,
I
Igor Sugak 已提交
9357 9358
      const std::vector<Slice>& keys,
      std::vector<std::string>* values) override {
9359 9360 9361
    std::vector<Status> s(keys.size(),
                          Status::NotSupported("Not implemented."));
    return s;
J
jorlow@chromium.org 已提交
9362
  }
9363

I
Igor Canadi 已提交
9364
  using DB::GetPropertiesOfAllTables;
I
Igor Sugak 已提交
9365 9366 9367
  virtual Status GetPropertiesOfAllTables(
      ColumnFamilyHandle* column_family,
      TablePropertiesCollection* props) override {
9368 9369
    return Status();
  }
9370

9371
  using DB::KeyMayExist;
9372
  virtual bool KeyMayExist(const ReadOptions& options,
9373
                           ColumnFamilyHandle* column_family, const Slice& key,
I
Igor Sugak 已提交
9374 9375
                           std::string* value,
                           bool* value_found = nullptr) override {
9376 9377 9378
    if (value_found != nullptr) {
      *value_found = false;
    }
9379 9380
    return true; // Not Supported directly
  }
9381 9382
  using DB::NewIterator;
  virtual Iterator* NewIterator(const ReadOptions& options,
I
Igor Sugak 已提交
9383
                                ColumnFamilyHandle* column_family) override {
A
Abhishek Kona 已提交
9384
    if (options.snapshot == nullptr) {
J
jorlow@chromium.org 已提交
9385 9386 9387 9388 9389
      KVMap* saved = new KVMap;
      *saved = map_;
      return new ModelIter(saved, true);
    } else {
      const KVMap* snapshot_state =
9390
          &(reinterpret_cast<const ModelSnapshot*>(options.snapshot)->map_);
J
jorlow@chromium.org 已提交
9391 9392 9393
      return new ModelIter(snapshot_state, false);
    }
  }
9394 9395
  virtual Status NewIterators(
      const ReadOptions& options,
9396
      const std::vector<ColumnFamilyHandle*>& column_family,
I
Igor Sugak 已提交
9397
      std::vector<Iterator*>* iterators) override {
9398 9399
    return Status::NotSupported("Not supported yet");
  }
I
Igor Sugak 已提交
9400
  virtual const Snapshot* GetSnapshot() override {
9401 9402 9403
    ModelSnapshot* snapshot = new ModelSnapshot;
    snapshot->map_ = map_;
    return snapshot;
J
jorlow@chromium.org 已提交
9404 9405
  }

I
Igor Sugak 已提交
9406
  virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
9407
    delete reinterpret_cast<const ModelSnapshot*>(snapshot);
J
jorlow@chromium.org 已提交
9408
  }
9409

I
Igor Sugak 已提交
9410 9411
  virtual Status Write(const WriteOptions& options,
                       WriteBatch* batch) override {
9412 9413 9414
    class Handler : public WriteBatch::Handler {
     public:
      KVMap* map_;
I
Igor Sugak 已提交
9415
      virtual void Put(const Slice& key, const Slice& value) override {
9416
        (*map_)[key.ToString()] = value.ToString();
J
jorlow@chromium.org 已提交
9417
      }
I
Igor Sugak 已提交
9418
      virtual void Merge(const Slice& key, const Slice& value) override {
9419 9420 9421
        // ignore merge for now
        //(*map_)[key.ToString()] = value.ToString();
      }
I
Igor Sugak 已提交
9422
      virtual void Delete(const Slice& key) override {
9423 9424 9425 9426 9427 9428
        map_->erase(key.ToString());
      }
    };
    Handler handler;
    handler.map_ = &map_;
    return batch->Iterate(&handler);
J
jorlow@chromium.org 已提交
9429 9430
  }

9431
  using DB::GetProperty;
9432
  virtual bool GetProperty(ColumnFamilyHandle* column_family,
I
Igor Sugak 已提交
9433
                           const Slice& property, std::string* value) override {
J
jorlow@chromium.org 已提交
9434 9435
    return false;
  }
9436 9437 9438 9439 9440
  using DB::GetIntProperty;
  virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
                              const Slice& property, uint64_t* value) override {
    return false;
  }
9441
  using DB::GetApproximateSizes;
9442
  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
9443 9444
                                   const Range* range, int n, uint64_t* sizes,
                                   bool include_memtable) override {
J
jorlow@chromium.org 已提交
9445 9446 9447 9448
    for (int i = 0; i < n; i++) {
      sizes[i] = 0;
    }
  }
9449
  using DB::CompactRange;
9450 9451 9452
  virtual Status CompactRange(const CompactRangeOptions& options,
                              ColumnFamilyHandle* column_family,
                              const Slice* start, const Slice* end) override {
L
Lei Jin 已提交
9453
    return Status::NotSupported("Not supported operation.");
G
Gabor Cselle 已提交
9454 9455
  }

9456 9457 9458 9459 9460 9461 9462 9463 9464
  using DB::CompactFiles;
  virtual Status CompactFiles(
      const CompactionOptions& compact_options,
      ColumnFamilyHandle* column_family,
      const std::vector<std::string>& input_file_names,
      const int output_level, const int output_path_id = -1) override {
    return Status::NotSupported("Not supported operation.");
  }

9465
  using DB::NumberLevels;
I
Igor Sugak 已提交
9466 9467 9468
  virtual int NumberLevels(ColumnFamilyHandle* column_family) override {
    return 1;
  }
9469

9470
  using DB::MaxMemCompactionLevel;
I
Igor Sugak 已提交
9471 9472
  virtual int MaxMemCompactionLevel(
      ColumnFamilyHandle* column_family) override {
9473
    return 1;
9474 9475
  }

9476
  using DB::Level0StopWriteTrigger;
I
Igor Sugak 已提交
9477 9478
  virtual int Level0StopWriteTrigger(
      ColumnFamilyHandle* column_family) override {
9479
    return -1;
9480 9481
  }

I
Igor Sugak 已提交
9482
  virtual const std::string& GetName() const override { return name_; }
I
Igor Canadi 已提交
9483

I
Igor Sugak 已提交
9484
  virtual Env* GetEnv() const override { return nullptr; }
9485

9486
  using DB::GetOptions;
I
Igor Sugak 已提交
9487 9488
  virtual const Options& GetOptions(
      ColumnFamilyHandle* column_family) const override {
I
Igor Canadi 已提交
9489 9490 9491
    return options_;
  }

9492 9493 9494
  using DB::GetDBOptions;
  virtual const DBOptions& GetDBOptions() const override { return options_; }

9495 9496
  using DB::Flush;
  virtual Status Flush(const rocksdb::FlushOptions& options,
I
Igor Sugak 已提交
9497
                       ColumnFamilyHandle* column_family) override {
H
heyongqiang 已提交
9498 9499 9500 9501
    Status ret;
    return ret;
  }

I
Igor Sugak 已提交
9502 9503
  virtual Status DisableFileDeletions() override { return Status::OK(); }
  virtual Status EnableFileDeletions(bool force) override {
9504 9505
    return Status::OK();
  }
9506
  virtual Status GetLiveFiles(std::vector<std::string>&, uint64_t* size,
I
Igor Sugak 已提交
9507
                              bool flush_memtable = true) override {
9508 9509 9510
    return Status::OK();
  }

I
Igor Sugak 已提交
9511
  virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
9512 9513 9514
    return Status::OK();
  }

I
Igor Sugak 已提交
9515
  virtual Status DeleteFile(std::string name) override { return Status::OK(); }
9516

9517
  virtual Status GetDbIdentity(std::string& identity) const override {
9518 9519 9520
    return Status::OK();
  }

I
Igor Sugak 已提交
9521
  virtual SequenceNumber GetLatestSequenceNumber() const override { return 0; }
9522 9523 9524
  virtual Status GetUpdatesSince(
      rocksdb::SequenceNumber, unique_ptr<rocksdb::TransactionLogIterator>*,
      const TransactionLogIterator::ReadOptions&
I
Igor Sugak 已提交
9525
          read_options = TransactionLogIterator::ReadOptions()) override {
9526 9527 9528
    return Status::NotSupported("Not supported in Model DB");
  }

I
Igor Sugak 已提交
9529 9530 9531
  virtual ColumnFamilyHandle* DefaultColumnFamily() const override {
    return nullptr;
  }
9532

9533 9534
  virtual void GetColumnFamilyMetaData(
      ColumnFamilyHandle* column_family,
I
Igor Sugak 已提交
9535
      ColumnFamilyMetaData* metadata) override {}
9536

J
jorlow@chromium.org 已提交
9537 9538 9539 9540 9541 9542 9543 9544 9545
 private:
  class ModelIter: public Iterator {
   public:
    ModelIter(const KVMap* map, bool owned)
        : map_(map), owned_(owned), iter_(map_->end()) {
    }
    ~ModelIter() {
      if (owned_) delete map_;
    }
I
Igor Sugak 已提交
9546 9547 9548
    virtual bool Valid() const override { return iter_ != map_->end(); }
    virtual void SeekToFirst() override { iter_ = map_->begin(); }
    virtual void SeekToLast() override {
J
jorlow@chromium.org 已提交
9549 9550 9551 9552 9553 9554
      if (map_->empty()) {
        iter_ = map_->end();
      } else {
        iter_ = map_->find(map_->rbegin()->first);
      }
    }
I
Igor Sugak 已提交
9555
    virtual void Seek(const Slice& k) override {
J
jorlow@chromium.org 已提交
9556 9557
      iter_ = map_->lower_bound(k.ToString());
    }
I
Igor Sugak 已提交
9558 9559
    virtual void Next() override { ++iter_; }
    virtual void Prev() override {
S
Stanislau Hlebik 已提交
9560 9561 9562 9563 9564 9565 9566
      if (iter_ == map_->begin()) {
        iter_ = map_->end();
        return;
      }
      --iter_;
    }

I
Igor Sugak 已提交
9567 9568 9569 9570
    virtual Slice key() const override { return iter_->first; }
    virtual Slice value() const override { return iter_->second; }
    virtual Status status() const override { return Status::OK(); }

J
jorlow@chromium.org 已提交
9571 9572 9573 9574 9575 9576 9577
   private:
    const KVMap* const map_;
    const bool owned_;  // Do we own map_
    KVMap::const_iterator iter_;
  };
  const Options options_;
  KVMap map_;
I
Igor Canadi 已提交
9578
  std::string name_ = "";
J
jorlow@chromium.org 已提交
9579 9580
};

J
Jim Paton 已提交
9581 9582 9583 9584 9585 9586 9587
static std::string RandomKey(Random* rnd, int minimum = 0) {
  int len;
  do {
    len = (rnd->OneIn(3)
           ? 1                // Short sometimes to encourage collisions
           : (rnd->OneIn(100) ? rnd->Skewed(10) : rnd->Uniform(10)));
  } while (len < minimum);
J
jorlow@chromium.org 已提交
9588 9589 9590 9591 9592 9593 9594 9595 9596 9597 9598 9599 9600 9601 9602 9603 9604 9605 9606 9607 9608 9609 9610 9611 9612 9613 9614 9615 9616 9617 9618 9619 9620 9621 9622 9623 9624 9625 9626 9627 9628 9629 9630 9631 9632 9633 9634 9635 9636 9637
  return test::RandomKey(rnd, len);
}

static bool CompareIterators(int step,
                             DB* model,
                             DB* db,
                             const Snapshot* model_snap,
                             const Snapshot* db_snap) {
  ReadOptions options;
  options.snapshot = model_snap;
  Iterator* miter = model->NewIterator(options);
  options.snapshot = db_snap;
  Iterator* dbiter = db->NewIterator(options);
  bool ok = true;
  int count = 0;
  for (miter->SeekToFirst(), dbiter->SeekToFirst();
       ok && miter->Valid() && dbiter->Valid();
       miter->Next(), dbiter->Next()) {
    count++;
    if (miter->key().compare(dbiter->key()) != 0) {
      fprintf(stderr, "step %d: Key mismatch: '%s' vs. '%s'\n",
              step,
              EscapeString(miter->key()).c_str(),
              EscapeString(dbiter->key()).c_str());
      ok = false;
      break;
    }

    if (miter->value().compare(dbiter->value()) != 0) {
      fprintf(stderr, "step %d: Value mismatch for key '%s': '%s' vs. '%s'\n",
              step,
              EscapeString(miter->key()).c_str(),
              EscapeString(miter->value()).c_str(),
              EscapeString(miter->value()).c_str());
      ok = false;
    }
  }

  if (ok) {
    if (miter->Valid() != dbiter->Valid()) {
      fprintf(stderr, "step %d: Mismatch at end of iterators: %d vs. %d\n",
              step, miter->Valid(), dbiter->Valid());
      ok = false;
    }
  }
  delete miter;
  delete dbiter;
  return ok;
}

I
Igor Sugak 已提交
9638
TEST_F(DBTest, Randomized) {
9639 9640
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
J
jorlow@chromium.org 已提交
9641
  Random rnd(test::RandomSeed());
S
Sanjay Ghemawat 已提交
9642
  do {
9643
    ModelDB model(CurrentOptions(options_override));
S
Sanjay Ghemawat 已提交
9644
    const int N = 10000;
A
Abhishek Kona 已提交
9645 9646
    const Snapshot* model_snap = nullptr;
    const Snapshot* db_snap = nullptr;
S
Sanjay Ghemawat 已提交
9647 9648 9649 9650
    std::string k, v;
    for (int step = 0; step < N; step++) {
      // TODO(sanjay): Test Get() works
      int p = rnd.Uniform(100);
J
Jim Paton 已提交
9651
      int minimum = 0;
9652
      if (option_config_ == kHashSkipList ||
9653
          option_config_ == kHashLinkList ||
9654
          option_config_ == kHashCuckoo ||
9655 9656 9657
          option_config_ == kPlainTableFirstBytePrefix ||
          option_config_ == kBlockBasedTableWithWholeKeyHashIndex ||
          option_config_ == kBlockBasedTableWithPrefixHashIndex) {
J
Jim Paton 已提交
9658 9659
        minimum = 1;
      }
S
Sanjay Ghemawat 已提交
9660
      if (p < 45) {                               // Put
J
Jim Paton 已提交
9661
        k = RandomKey(&rnd, minimum);
S
Sanjay Ghemawat 已提交
9662 9663 9664 9665 9666 9667 9668 9669
        v = RandomString(&rnd,
                         rnd.OneIn(20)
                         ? 100 + rnd.Uniform(100)
                         : rnd.Uniform(8));
        ASSERT_OK(model.Put(WriteOptions(), k, v));
        ASSERT_OK(db_->Put(WriteOptions(), k, v));

      } else if (p < 90) {                        // Delete
J
Jim Paton 已提交
9670
        k = RandomKey(&rnd, minimum);
S
Sanjay Ghemawat 已提交
9671 9672 9673 9674 9675 9676 9677 9678 9679
        ASSERT_OK(model.Delete(WriteOptions(), k));
        ASSERT_OK(db_->Delete(WriteOptions(), k));


      } else {                                    // Multi-element batch
        WriteBatch b;
        const int num = rnd.Uniform(8);
        for (int i = 0; i < num; i++) {
          if (i == 0 || !rnd.OneIn(10)) {
J
Jim Paton 已提交
9680
            k = RandomKey(&rnd, minimum);
S
Sanjay Ghemawat 已提交
9681 9682 9683 9684 9685 9686 9687 9688 9689 9690
          } else {
            // Periodically re-use the same key from the previous iter, so
            // we have multiple entries in the write batch for the same key
          }
          if (rnd.OneIn(2)) {
            v = RandomString(&rnd, rnd.Uniform(10));
            b.Put(k, v);
          } else {
            b.Delete(k);
          }
J
jorlow@chromium.org 已提交
9691
        }
S
Sanjay Ghemawat 已提交
9692 9693
        ASSERT_OK(model.Write(WriteOptions(), &b));
        ASSERT_OK(db_->Write(WriteOptions(), &b));
J
jorlow@chromium.org 已提交
9694 9695
      }

S
Sanjay Ghemawat 已提交
9696
      if ((step % 100) == 0) {
S
Stanislau Hlebik 已提交
9697 9698 9699 9700 9701 9702 9703 9704
        // For DB instances that use the hash index + block-based table, the
        // iterator will be invalid right when seeking a non-existent key, right
        // than return a key that is close to it.
        if (option_config_ != kBlockBasedTableWithWholeKeyHashIndex &&
            option_config_ != kBlockBasedTableWithPrefixHashIndex) {
          ASSERT_TRUE(CompareIterators(step, &model, db_, nullptr, nullptr));
          ASSERT_TRUE(CompareIterators(step, &model, db_, model_snap, db_snap));
        }
9705

S
Sanjay Ghemawat 已提交
9706 9707 9708
        // Save a snapshot from each DB this time that we'll use next
        // time we compare things, to make sure the current state is
        // preserved with the snapshot
A
Abhishek Kona 已提交
9709 9710
        if (model_snap != nullptr) model.ReleaseSnapshot(model_snap);
        if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap);
J
jorlow@chromium.org 已提交
9711

L
Lei Jin 已提交
9712

9713
        auto options = CurrentOptions(options_override);
L
Lei Jin 已提交
9714
        Reopen(options);
A
Abhishek Kona 已提交
9715
        ASSERT_TRUE(CompareIterators(step, &model, db_, nullptr, nullptr));
J
jorlow@chromium.org 已提交
9716

S
Sanjay Ghemawat 已提交
9717 9718 9719
        model_snap = model.GetSnapshot();
        db_snap = db_->GetSnapshot();
      }
S
Stanislau Hlebik 已提交
9720 9721

      if ((step % 2000) == 0) {
9722
        fprintf(stderr,
S
Stanislau Hlebik 已提交
9723 9724 9725
                "DBTest.Randomized, option ID: %d, step: %d out of %d\n",
                option_config_, step, N);
      }
J
jorlow@chromium.org 已提交
9726
    }
A
Abhishek Kona 已提交
9727 9728
    if (model_snap != nullptr) model.ReleaseSnapshot(model_snap);
    if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap);
9729
    // skip cuckoo hash as it does not support snapshot.
S
Stanislau Hlebik 已提交
9730 9731
  } while (ChangeOptions(kSkipDeletesFilterFirst | kSkipNoSeekToLast |
                         kSkipHashCuckoo));
J
jorlow@chromium.org 已提交
9732 9733
}

I
Igor Sugak 已提交
9734
TEST_F(DBTest, MultiGetSimple) {
9735
  do {
L
Lei Jin 已提交
9736
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
9737 9738 9739 9740 9741 9742 9743 9744 9745 9746 9747 9748 9749 9750 9751
    ASSERT_OK(Put(1, "k1", "v1"));
    ASSERT_OK(Put(1, "k2", "v2"));
    ASSERT_OK(Put(1, "k3", "v3"));
    ASSERT_OK(Put(1, "k4", "v4"));
    ASSERT_OK(Delete(1, "k4"));
    ASSERT_OK(Put(1, "k5", "v5"));
    ASSERT_OK(Delete(1, "no_key"));

    std::vector<Slice> keys({"k1", "k2", "k3", "k4", "k5", "no_key"});

    std::vector<std::string> values(20, "Temporary data to be overwritten");
    std::vector<ColumnFamilyHandle*> cfs(keys.size(), handles_[1]);

    std::vector<Status> s = db_->MultiGet(ReadOptions(), cfs, keys, &values);
    ASSERT_EQ(values.size(), keys.size());
9752 9753 9754 9755 9756 9757 9758 9759 9760 9761 9762 9763
    ASSERT_EQ(values[0], "v1");
    ASSERT_EQ(values[1], "v2");
    ASSERT_EQ(values[2], "v3");
    ASSERT_EQ(values[4], "v5");

    ASSERT_OK(s[0]);
    ASSERT_OK(s[1]);
    ASSERT_OK(s[2]);
    ASSERT_TRUE(s[3].IsNotFound());
    ASSERT_OK(s[4]);
    ASSERT_TRUE(s[5].IsNotFound());
  } while (ChangeCompactOptions());
9764 9765
}

I
Igor Sugak 已提交
9766
TEST_F(DBTest, MultiGetEmpty) {
9767
  do {
L
Lei Jin 已提交
9768
    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
9769 9770 9771
    // Empty Key Set
    std::vector<Slice> keys;
    std::vector<std::string> values;
9772 9773 9774
    std::vector<ColumnFamilyHandle*> cfs;
    std::vector<Status> s = db_->MultiGet(ReadOptions(), cfs, keys, &values);
    ASSERT_EQ(s.size(), 0U);
9775 9776

    // Empty Database, Empty Key Set
L
Lei Jin 已提交
9777 9778 9779
    Options options = CurrentOptions();
    options.create_if_missing = true;
    DestroyAndReopen(options);
L
Lei Jin 已提交
9780
    CreateAndReopenWithCF({"pikachu"}, options);
9781 9782
    s = db_->MultiGet(ReadOptions(), cfs, keys, &values);
    ASSERT_EQ(s.size(), 0U);
9783 9784 9785 9786 9787

    // Empty Database, Search for Keys
    keys.resize(2);
    keys[0] = "a";
    keys[1] = "b";
9788 9789 9790
    cfs.push_back(handles_[0]);
    cfs.push_back(handles_[1]);
    s = db_->MultiGet(ReadOptions(), cfs, keys, &values);
9791 9792 9793
    ASSERT_EQ((int)s.size(), 2);
    ASSERT_TRUE(s[0].IsNotFound() && s[1].IsNotFound());
  } while (ChangeCompactOptions());
9794 9795
}

I
Igor Canadi 已提交
9796
namespace {
T
Tyler Harter 已提交
9797 9798 9799 9800 9801 9802 9803 9804 9805 9806 9807 9808 9809 9810 9811 9812 9813 9814 9815 9816 9817 9818
void PrefixScanInit(DBTest *dbtest) {
  char buf[100];
  std::string keystr;
  const int small_range_sstfiles = 5;
  const int big_range_sstfiles = 5;

  // Generate 11 sst files with the following prefix ranges.
  // GROUP 0: [0,10]                              (level 1)
  // GROUP 1: [1,2], [2,3], [3,4], [4,5], [5, 6]  (level 0)
  // GROUP 2: [0,6], [0,7], [0,8], [0,9], [0,10]  (level 0)
  //
  // A seek with the previous API would do 11 random I/Os (to all the
  // files).  With the new API and a prefix filter enabled, we should
  // only do 2 random I/O, to the 2 files containing the key.

  // GROUP 0
  snprintf(buf, sizeof(buf), "%02d______:start", 0);
  keystr = std::string(buf);
  ASSERT_OK(dbtest->Put(keystr, keystr));
  snprintf(buf, sizeof(buf), "%02d______:end", 10);
  keystr = std::string(buf);
  ASSERT_OK(dbtest->Put(keystr, keystr));
9819
  dbtest->Flush();
9820 9821
  dbtest->dbfull()->CompactRange(CompactRangeOptions(), nullptr,
                                 nullptr);  // move to level 1
T
Tyler Harter 已提交
9822 9823 9824 9825 9826 9827 9828 9829 9830

  // GROUP 1
  for (int i = 1; i <= small_range_sstfiles; i++) {
    snprintf(buf, sizeof(buf), "%02d______:start", i);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
    snprintf(buf, sizeof(buf), "%02d______:end", i+1);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
9831
    dbtest->Flush();
T
Tyler Harter 已提交
9832 9833 9834 9835 9836 9837 9838 9839 9840 9841 9842
  }

  // GROUP 2
  for (int i = 1; i <= big_range_sstfiles; i++) {
    snprintf(buf, sizeof(buf), "%02d______:start", 0);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
    snprintf(buf, sizeof(buf), "%02d______:end",
             small_range_sstfiles+i+1);
    keystr = std::string(buf);
    ASSERT_OK(dbtest->Put(keystr, keystr));
9843
    dbtest->Flush();
T
Tyler Harter 已提交
9844 9845
  }
}
I
Igor Canadi 已提交
9846
}  // namespace
T
Tyler Harter 已提交
9847

I
Igor Sugak 已提交
9848
TEST_F(DBTest, PrefixScan) {
V
Venkatesh Radhakrishnan 已提交
9849 9850
  XFUNC_TEST("", "dbtest_prefix", prefix_skip1, XFuncPoint::SetSkip,
             kSkipNoPrefix);
9851 9852 9853 9854 9855 9856 9857 9858 9859 9860 9861 9862 9863 9864 9865 9866 9867 9868
  while (ChangeFilterOptions()) {
    int count;
    Slice prefix;
    Slice key;
    char buf[100];
    Iterator* iter;
    snprintf(buf, sizeof(buf), "03______:");
    prefix = Slice(buf, 8);
    key = Slice(buf, 9);
    // db configs
    env_->count_random_reads_ = true;
    Options options = CurrentOptions();
    options.env = env_;
    options.prefix_extractor.reset(NewFixedPrefixTransform(8));
    options.disable_auto_compactions = true;
    options.max_background_compactions = 2;
    options.create_if_missing = true;
    options.memtable_factory.reset(NewHashSkipListRepFactory(16));
T
Tyler Harter 已提交
9869

9870 9871 9872 9873 9874
    BlockBasedTableOptions table_options;
    table_options.no_block_cache = true;
    table_options.filter_policy.reset(NewBloomFilterPolicy(10));
    table_options.whole_key_filtering = false;
    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
9875

9876
    // 11 RAND I/Os
L
Lei Jin 已提交
9877
    DestroyAndReopen(options);
9878 9879 9880 9881 9882 9883 9884 9885 9886
    PrefixScanInit(this);
    count = 0;
    env_->random_read_counter_.Reset();
    iter = db_->NewIterator(ReadOptions());
    for (iter->Seek(prefix); iter->Valid(); iter->Next()) {
      if (! iter->key().starts_with(prefix)) {
        break;
      }
      count++;
T
Tyler Harter 已提交
9887
    }
9888 9889 9890 9891 9892 9893
    ASSERT_OK(iter->status());
    delete iter;
    ASSERT_EQ(count, 2);
    ASSERT_EQ(env_->random_read_counter_.Read(), 2);
    Close();
  }  // end of while
V
Venkatesh Radhakrishnan 已提交
9894
  XFUNC_TEST("", "dbtest_prefix", prefix_skip1, XFuncPoint::SetSkip, 0);
T
Tyler Harter 已提交
9895 9896
}

I
Igor Sugak 已提交
9897
TEST_F(DBTest, TailingIteratorSingle) {
T
Tomislav Novak 已提交
9898 9899 9900 9901 9902 9903 9904 9905 9906 9907 9908 9909 9910 9911 9912 9913 9914
  ReadOptions read_options;
  read_options.tailing = true;

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
  iter->SeekToFirst();
  ASSERT_TRUE(!iter->Valid());

  // add a record and check that iter can see it
  ASSERT_OK(db_->Put(WriteOptions(), "mirko", "fodor"));
  iter->SeekToFirst();
  ASSERT_TRUE(iter->Valid());
  ASSERT_EQ(iter->key().ToString(), "mirko");

  iter->Next();
  ASSERT_TRUE(!iter->Valid());
}

I
Igor Sugak 已提交
9915
TEST_F(DBTest, TailingIteratorKeepAdding) {
L
Lei Jin 已提交
9916
  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
T
Tomislav Novak 已提交
9917 9918 9919
  ReadOptions read_options;
  read_options.tailing = true;

9920
  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options, handles_[1]));
T
Tomislav Novak 已提交
9921 9922 9923 9924 9925 9926 9927 9928
  std::string value(1024, 'a');

  const int num_records = 10000;
  for (int i = 0; i < num_records; ++i) {
    char buf[32];
    snprintf(buf, sizeof(buf), "%016d", i);

    Slice key(buf, 16);
9929
    ASSERT_OK(Put(1, key, value));
T
Tomislav Novak 已提交
9930 9931 9932 9933 9934 9935 9936

    iter->Seek(key);
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(key), 0);
  }
}

I
Igor Sugak 已提交
9937
TEST_F(DBTest, TailingIteratorSeekToNext) {
L
Lei Jin 已提交
9938
  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
L
Lei Jin 已提交
9939 9940 9941 9942 9943 9944 9945 9946 9947 9948 9949 9950 9951 9952 9953 9954 9955 9956 9957 9958 9959 9960 9961 9962 9963 9964 9965 9966 9967 9968 9969 9970 9971 9972 9973 9974 9975 9976 9977 9978 9979 9980 9981 9982 9983
  ReadOptions read_options;
  read_options.tailing = true;

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options, handles_[1]));
  std::string value(1024, 'a');

  const int num_records = 1000;
  for (int i = 1; i < num_records; ++i) {
    char buf1[32];
    char buf2[32];
    snprintf(buf1, sizeof(buf1), "00a0%016d", i * 5);

    Slice key(buf1, 20);
    ASSERT_OK(Put(1, key, value));

    if (i % 100 == 99) {
      ASSERT_OK(Flush(1));
    }

    snprintf(buf2, sizeof(buf2), "00a0%016d", i * 5 - 2);
    Slice target(buf2, 20);
    iter->Seek(target);
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(key), 0);
  }
  for (int i = 2 * num_records; i > 0; --i) {
    char buf1[32];
    char buf2[32];
    snprintf(buf1, sizeof(buf1), "00a0%016d", i * 5);

    Slice key(buf1, 20);
    ASSERT_OK(Put(1, key, value));

    if (i % 100 == 99) {
      ASSERT_OK(Flush(1));
    }

    snprintf(buf2, sizeof(buf2), "00a0%016d", i * 5 - 2);
    Slice target(buf2, 20);
    iter->Seek(target);
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(key), 0);
  }
}

I
Igor Sugak 已提交
9984
TEST_F(DBTest, TailingIteratorDeletes) {
L
Lei Jin 已提交
9985
  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
T
Tomislav Novak 已提交
9986 9987 9988
  ReadOptions read_options;
  read_options.tailing = true;

9989
  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options, handles_[1]));
T
Tomislav Novak 已提交
9990 9991

  // write a single record, read it using the iterator, then delete it
9992
  ASSERT_OK(Put(1, "0test", "test"));
T
Tomislav Novak 已提交
9993 9994 9995
  iter->SeekToFirst();
  ASSERT_TRUE(iter->Valid());
  ASSERT_EQ(iter->key().ToString(), "0test");
9996
  ASSERT_OK(Delete(1, "0test"));
T
Tomislav Novak 已提交
9997 9998 9999 10000 10001 10002 10003 10004 10005 10006

  // write many more records
  const int num_records = 10000;
  std::string value(1024, 'A');

  for (int i = 0; i < num_records; ++i) {
    char buf[32];
    snprintf(buf, sizeof(buf), "1%015d", i);

    Slice key(buf, 16);
10007
    ASSERT_OK(Put(1, key, value));
T
Tomislav Novak 已提交
10008 10009 10010
  }

  // force a flush to make sure that no records are read from memtable
10011
  ASSERT_OK(Flush(1));
T
Tomislav Novak 已提交
10012 10013 10014 10015 10016 10017 10018 10019 10020 10021 10022

  // skip "0test"
  iter->Next();

  // make sure we can read all new records using the existing iterator
  int count = 0;
  for (; iter->Valid(); iter->Next(), ++count) ;

  ASSERT_EQ(count, num_records);
}

I
Igor Sugak 已提交
10023
TEST_F(DBTest, TailingIteratorPrefixSeek) {
V
Venkatesh Radhakrishnan 已提交
10024 10025
  XFUNC_TEST("", "dbtest_prefix", prefix_skip1, XFuncPoint::SetSkip,
             kSkipNoPrefix);
T
Tomislav Novak 已提交
10026 10027 10028 10029 10030 10031 10032
  ReadOptions read_options;
  read_options.tailing = true;

  Options options = CurrentOptions();
  options.env = env_;
  options.create_if_missing = true;
  options.disable_auto_compactions = true;
10033
  options.prefix_extractor.reset(NewFixedPrefixTransform(2));
10034
  options.memtable_factory.reset(NewHashSkipListRepFactory(16));
L
Lei Jin 已提交
10035
  DestroyAndReopen(options);
L
Lei Jin 已提交
10036
  CreateAndReopenWithCF({"pikachu"}, options);
T
Tomislav Novak 已提交
10037

10038 10039
  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options, handles_[1]));
  ASSERT_OK(Put(1, "0101", "test"));
T
Tomislav Novak 已提交
10040

10041
  ASSERT_OK(Flush(1));
T
Tomislav Novak 已提交
10042

10043
  ASSERT_OK(Put(1, "0202", "test"));
T
Tomislav Novak 已提交
10044 10045 10046 10047 10048 10049 10050 10051 10052 10053 10054

  // Seek(0102) shouldn't find any records since 0202 has a different prefix
  iter->Seek("0102");
  ASSERT_TRUE(!iter->Valid());

  iter->Seek("0202");
  ASSERT_TRUE(iter->Valid());
  ASSERT_EQ(iter->key().ToString(), "0202");

  iter->Next();
  ASSERT_TRUE(!iter->Valid());
V
Venkatesh Radhakrishnan 已提交
10055
  XFUNC_TEST("", "dbtest_prefix", prefix_skip1, XFuncPoint::SetSkip, 0);
T
Tomislav Novak 已提交
10056 10057
}

I
Igor Sugak 已提交
10058
TEST_F(DBTest, TailingIteratorIncomplete) {
L
Lei Jin 已提交
10059
  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
10060 10061 10062 10063 10064 10065 10066 10067 10068 10069 10070 10071 10072 10073
  ReadOptions read_options;
  read_options.tailing = true;
  read_options.read_tier = kBlockCacheTier;

  std::string key("key");
  std::string value("value");

  ASSERT_OK(db_->Put(WriteOptions(), key, value));

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
  iter->SeekToFirst();
  // we either see the entry or it's not in cache
  ASSERT_TRUE(iter->Valid() || iter->status().IsIncomplete());

10074
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
10075 10076 10077 10078 10079
  iter->SeekToFirst();
  // should still be true after compaction
  ASSERT_TRUE(iter->Valid() || iter->status().IsIncomplete());
}

I
Igor Sugak 已提交
10080
TEST_F(DBTest, TailingIteratorSeekToSame) {
T
Tomislav Novak 已提交
10081 10082 10083
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 1000;
L
Lei Jin 已提交
10084
  CreateAndReopenWithCF({"pikachu"}, options);
T
Tomislav Novak 已提交
10085 10086 10087 10088 10089 10090 10091 10092 10093 10094 10095 10096 10097 10098 10099 10100 10101 10102 10103 10104 10105 10106 10107

  ReadOptions read_options;
  read_options.tailing = true;

  const int NROWS = 10000;
  // Write rows with keys 00000, 00002, 00004 etc.
  for (int i = 0; i < NROWS; ++i) {
    char buf[100];
    snprintf(buf, sizeof(buf), "%05d", 2*i);
    std::string key(buf);
    std::string value("value");
    ASSERT_OK(db_->Put(WriteOptions(), key, value));
  }

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
  // Seek to 00001.  We expect to find 00002.
  std::string start_key = "00001";
  iter->Seek(start_key);
  ASSERT_TRUE(iter->Valid());

  std::string found = iter->key().ToString();
  ASSERT_EQ("00002", found);

V
Venkatesh Radhakrishnan 已提交
10108 10109 10110 10111 10112 10113 10114
  // Now seek to the same key.  The iterator should remain in the same
  // position.
  iter->Seek(found);
  ASSERT_TRUE(iter->Valid());
  ASSERT_EQ(found, iter->key().ToString());
}

I
Igor Sugak 已提交
10115
TEST_F(DBTest, ManagedTailingIteratorSingle) {
V
Venkatesh Radhakrishnan 已提交
10116 10117 10118 10119 10120 10121 10122 10123 10124 10125 10126 10127 10128 10129 10130 10131 10132 10133
  ReadOptions read_options;
  read_options.tailing = true;
  read_options.managed = true;

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
  iter->SeekToFirst();
  ASSERT_TRUE(!iter->Valid());

  // add a record and check that iter can see it
  ASSERT_OK(db_->Put(WriteOptions(), "mirko", "fodor"));
  iter->SeekToFirst();
  ASSERT_TRUE(iter->Valid());
  ASSERT_EQ(iter->key().ToString(), "mirko");

  iter->Next();
  ASSERT_TRUE(!iter->Valid());
}

I
Igor Sugak 已提交
10134
TEST_F(DBTest, ManagedTailingIteratorKeepAdding) {
V
Venkatesh Radhakrishnan 已提交
10135 10136 10137 10138 10139 10140 10141 10142 10143 10144 10145 10146 10147 10148 10149 10150 10151 10152 10153 10154 10155 10156
  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
  ReadOptions read_options;
  read_options.tailing = true;
  read_options.managed = true;

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options, handles_[1]));
  std::string value(1024, 'a');

  const int num_records = 10000;
  for (int i = 0; i < num_records; ++i) {
    char buf[32];
    snprintf(buf, sizeof(buf), "%016d", i);

    Slice key(buf, 16);
    ASSERT_OK(Put(1, key, value));

    iter->Seek(key);
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(key), 0);
  }
}

I
Igor Sugak 已提交
10157
TEST_F(DBTest, ManagedTailingIteratorSeekToNext) {
V
Venkatesh Radhakrishnan 已提交
10158 10159 10160 10161 10162 10163 10164 10165 10166 10167 10168 10169 10170 10171 10172 10173 10174 10175 10176 10177 10178 10179 10180 10181 10182 10183 10184 10185 10186 10187 10188 10189 10190 10191 10192 10193 10194 10195 10196 10197 10198 10199 10200 10201 10202 10203 10204
  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
  ReadOptions read_options;
  read_options.tailing = true;
  read_options.managed = true;

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options, handles_[1]));
  std::string value(1024, 'a');

  const int num_records = 1000;
  for (int i = 1; i < num_records; ++i) {
    char buf1[32];
    char buf2[32];
    snprintf(buf1, sizeof(buf1), "00a0%016d", i * 5);

    Slice key(buf1, 20);
    ASSERT_OK(Put(1, key, value));

    if (i % 100 == 99) {
      ASSERT_OK(Flush(1));
    }

    snprintf(buf2, sizeof(buf2), "00a0%016d", i * 5 - 2);
    Slice target(buf2, 20);
    iter->Seek(target);
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(key), 0);
  }
  for (int i = 2 * num_records; i > 0; --i) {
    char buf1[32];
    char buf2[32];
    snprintf(buf1, sizeof(buf1), "00a0%016d", i * 5);

    Slice key(buf1, 20);
    ASSERT_OK(Put(1, key, value));

    if (i % 100 == 99) {
      ASSERT_OK(Flush(1));
    }

    snprintf(buf2, sizeof(buf2), "00a0%016d", i * 5 - 2);
    Slice target(buf2, 20);
    iter->Seek(target);
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(key), 0);
  }
}

I
Igor Sugak 已提交
10205
TEST_F(DBTest, ManagedTailingIteratorDeletes) {
V
Venkatesh Radhakrishnan 已提交
10206 10207 10208 10209 10210 10211 10212 10213 10214 10215 10216 10217 10218 10219 10220 10221 10222 10223 10224 10225 10226 10227 10228 10229 10230 10231 10232 10233 10234 10235 10236 10237 10238 10239 10240 10241 10242 10243 10244 10245
  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
  ReadOptions read_options;
  read_options.tailing = true;
  read_options.managed = true;

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options, handles_[1]));

  // write a single record, read it using the iterator, then delete it
  ASSERT_OK(Put(1, "0test", "test"));
  iter->SeekToFirst();
  ASSERT_TRUE(iter->Valid());
  ASSERT_EQ(iter->key().ToString(), "0test");
  ASSERT_OK(Delete(1, "0test"));

  // write many more records
  const int num_records = 10000;
  std::string value(1024, 'A');

  for (int i = 0; i < num_records; ++i) {
    char buf[32];
    snprintf(buf, sizeof(buf), "1%015d", i);

    Slice key(buf, 16);
    ASSERT_OK(Put(1, key, value));
  }

  // force a flush to make sure that no records are read from memtable
  ASSERT_OK(Flush(1));

  // skip "0test"
  iter->Next();

  // make sure we can read all new records using the existing iterator
  int count = 0;
  for (; iter->Valid(); iter->Next(), ++count) {
  }

  ASSERT_EQ(count, num_records);
}

I
Igor Sugak 已提交
10246
TEST_F(DBTest, ManagedTailingIteratorPrefixSeek) {
V
Venkatesh Radhakrishnan 已提交
10247 10248 10249 10250 10251 10252 10253 10254 10255 10256 10257 10258 10259 10260 10261 10262 10263 10264 10265 10266 10267 10268 10269 10270 10271 10272 10273 10274 10275 10276 10277 10278 10279 10280 10281
  XFUNC_TEST("", "dbtest_prefix", prefix_skip1, XFuncPoint::SetSkip,
             kSkipNoPrefix);
  ReadOptions read_options;
  read_options.tailing = true;
  read_options.managed = true;

  Options options = CurrentOptions();
  options.env = env_;
  options.create_if_missing = true;
  options.disable_auto_compactions = true;
  options.prefix_extractor.reset(NewFixedPrefixTransform(2));
  options.memtable_factory.reset(NewHashSkipListRepFactory(16));
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options, handles_[1]));
  ASSERT_OK(Put(1, "0101", "test"));

  ASSERT_OK(Flush(1));

  ASSERT_OK(Put(1, "0202", "test"));

  // Seek(0102) shouldn't find any records since 0202 has a different prefix
  iter->Seek("0102");
  ASSERT_TRUE(!iter->Valid());

  iter->Seek("0202");
  ASSERT_TRUE(iter->Valid());
  ASSERT_EQ(iter->key().ToString(), "0202");

  iter->Next();
  ASSERT_TRUE(!iter->Valid());
  XFUNC_TEST("", "dbtest_prefix", prefix_skip1, XFuncPoint::SetSkip, 0);
}

I
Igor Sugak 已提交
10282
TEST_F(DBTest, ManagedTailingIteratorIncomplete) {
V
Venkatesh Radhakrishnan 已提交
10283 10284 10285 10286 10287 10288 10289 10290 10291 10292 10293 10294 10295 10296 10297 10298
  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
  ReadOptions read_options;
  read_options.tailing = true;
  read_options.managed = true;
  read_options.read_tier = kBlockCacheTier;

  std::string key = "key";
  std::string value = "value";

  ASSERT_OK(db_->Put(WriteOptions(), key, value));

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
  iter->SeekToFirst();
  // we either see the entry or it's not in cache
  ASSERT_TRUE(iter->Valid() || iter->status().IsIncomplete());

10299
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
V
Venkatesh Radhakrishnan 已提交
10300 10301 10302 10303 10304
  iter->SeekToFirst();
  // should still be true after compaction
  ASSERT_TRUE(iter->Valid() || iter->status().IsIncomplete());
}

I
Igor Sugak 已提交
10305
TEST_F(DBTest, ManagedTailingIteratorSeekToSame) {
V
Venkatesh Radhakrishnan 已提交
10306 10307 10308 10309 10310 10311 10312 10313 10314 10315 10316 10317 10318 10319 10320 10321 10322 10323 10324 10325 10326 10327 10328 10329 10330 10331 10332 10333
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 1000;
  CreateAndReopenWithCF({"pikachu"}, options);

  ReadOptions read_options;
  read_options.tailing = true;
  read_options.managed = true;

  const int NROWS = 10000;
  // Write rows with keys 00000, 00002, 00004 etc.
  for (int i = 0; i < NROWS; ++i) {
    char buf[100];
    snprintf(buf, sizeof(buf), "%05d", 2 * i);
    std::string key(buf);
    std::string value("value");
    ASSERT_OK(db_->Put(WriteOptions(), key, value));
  }

  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
  // Seek to 00001.  We expect to find 00002.
  std::string start_key = "00001";
  iter->Seek(start_key);
  ASSERT_TRUE(iter->Valid());

  std::string found = iter->key().ToString();
  ASSERT_EQ("00002", found);

T
Tomislav Novak 已提交
10334 10335 10336 10337 10338 10339 10340
  // Now seek to the same key.  The iterator should remain in the same
  // position.
  iter->Seek(found);
  ASSERT_TRUE(iter->Valid());
  ASSERT_EQ(found, iter->key().ToString());
}

I
Igor Sugak 已提交
10341
TEST_F(DBTest, BlockBasedTablePrefixIndexTest) {
10342 10343 10344 10345 10346 10347 10348 10349
  // create a DB with block prefix index
  BlockBasedTableOptions table_options;
  Options options = CurrentOptions();
  table_options.index_type = BlockBasedTableOptions::kHashSearch;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  options.prefix_extractor.reset(NewFixedPrefixTransform(1));


L
Lei Jin 已提交
10350
  Reopen(options);
10351 10352 10353 10354 10355 10356 10357 10358 10359 10360
  ASSERT_OK(Put("k1", "v1"));
  Flush();
  ASSERT_OK(Put("k2", "v2"));

  // Reopen it without prefix extractor, make sure everything still works.
  // RocksDB should just fall back to the binary index.
  table_options.index_type = BlockBasedTableOptions::kBinarySearch;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  options.prefix_extractor.reset();

L
Lei Jin 已提交
10361
  Reopen(options);
10362 10363 10364 10365
  ASSERT_EQ("v1", Get("k1"));
  ASSERT_EQ("v2", Get("k2"));
}

I
Igor Sugak 已提交
10366
TEST_F(DBTest, ChecksumTest) {
I
xxHash  
Igor Canadi 已提交
10367 10368 10369 10370 10371
  BlockBasedTableOptions table_options;
  Options options = CurrentOptions();

  table_options.checksum = kCRC32c;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
10372
  Reopen(options);
I
xxHash  
Igor Canadi 已提交
10373 10374 10375 10376 10377 10378
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
  ASSERT_OK(Flush());  // table with crc checksum

  table_options.checksum = kxxHash;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
10379
  Reopen(options);
I
xxHash  
Igor Canadi 已提交
10380 10381 10382 10383 10384 10385
  ASSERT_OK(Put("e", "f"));
  ASSERT_OK(Put("g", "h"));
  ASSERT_OK(Flush());  // table with xxhash checksum

  table_options.checksum = kCRC32c;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
10386
  Reopen(options);
I
xxHash  
Igor Canadi 已提交
10387 10388 10389 10390
  ASSERT_EQ("b", Get("a"));
  ASSERT_EQ("d", Get("c"));
  ASSERT_EQ("f", Get("e"));
  ASSERT_EQ("h", Get("g"));
T
Tomislav Novak 已提交
10391

I
xxHash  
Igor Canadi 已提交
10392 10393
  table_options.checksum = kCRC32c;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
L
Lei Jin 已提交
10394
  Reopen(options);
I
xxHash  
Igor Canadi 已提交
10395 10396 10397 10398 10399
  ASSERT_EQ("b", Get("a"));
  ASSERT_EQ("d", Get("c"));
  ASSERT_EQ("f", Get("e"));
  ASSERT_EQ("h", Get("g"));
}
I
Igor Canadi 已提交
10400

I
Igor Sugak 已提交
10401
TEST_F(DBTest, FIFOCompactionTest) {
I
Igor Canadi 已提交
10402 10403 10404 10405 10406 10407 10408 10409 10410 10411 10412 10413
  for (int iter = 0; iter < 2; ++iter) {
    // first iteration -- auto compaction
    // second iteration -- manual compaction
    Options options;
    options.compaction_style = kCompactionStyleFIFO;
    options.write_buffer_size = 100 << 10;                             // 100KB
    options.compaction_options_fifo.max_table_files_size = 500 << 10;  // 500KB
    options.compression = kNoCompression;
    options.create_if_missing = true;
    if (iter == 1) {
      options.disable_auto_compactions = true;
    }
10414
    options = CurrentOptions(options);
L
Lei Jin 已提交
10415
    DestroyAndReopen(options);
I
Igor Canadi 已提交
10416 10417 10418 10419

    Random rnd(301);
    for (int i = 0; i < 6; ++i) {
      for (int j = 0; j < 100; ++j) {
10420
        ASSERT_OK(Put(ToString(i * 100 + j), RandomString(&rnd, 1024)));
I
Igor Canadi 已提交
10421 10422
      }
      // flush should happen here
10423
      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
I
Igor Canadi 已提交
10424 10425 10426 10427
    }
    if (iter == 0) {
      ASSERT_OK(dbfull()->TEST_WaitForCompact());
    } else {
10428
      ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
I
Igor Canadi 已提交
10429 10430 10431 10432 10433
    }
    // only 5 files should survive
    ASSERT_EQ(NumTableFilesAtLevel(0), 5);
    for (int i = 0; i < 50; ++i) {
      // these keys should be deleted in previous compaction
10434
      ASSERT_EQ("NOT_FOUND", Get(ToString(i)));
I
Igor Canadi 已提交
10435 10436 10437
    }
  }
}
10438

I
Igor Sugak 已提交
10439
TEST_F(DBTest, SimpleWriteTimeoutTest) {
I
Igor Canadi 已提交
10440 10441 10442 10443 10444 10445 10446 10447
  // Block compaction thread, which will also block the flushes because
  // max_background_flushes == 0, so flushes are getting executed by the
  // compaction thread
  env_->SetBackgroundThreads(1, Env::LOW);
  SleepingBackgroundTask sleeping_task_low;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
                 Env::Priority::LOW);

10448 10449 10450 10451 10452 10453 10454
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.write_buffer_size = 100000;
  options.max_background_flushes = 0;
  options.max_write_buffer_number = 2;
  options.max_total_wal_size = std::numeric_limits<uint64_t>::max();
L
Lei Jin 已提交
10455
  WriteOptions write_opt;
10456
  write_opt.timeout_hint_us = 0;
L
Lei Jin 已提交
10457
  DestroyAndReopen(options);
I
Igor Canadi 已提交
10458
  // fill the two write buffers
10459 10460 10461 10462
  ASSERT_OK(Put(Key(1), Key(1) + std::string(100000, 'v'), write_opt));
  ASSERT_OK(Put(Key(2), Key(2) + std::string(100000, 'v'), write_opt));
  // As the only two write buffers are full in this moment, the third
  // Put is expected to be timed-out.
10463
  write_opt.timeout_hint_us = 50;
10464 10465
  ASSERT_TRUE(
      Put(Key(3), Key(3) + std::string(100000, 'v'), write_opt).IsTimedOut());
I
Igor Canadi 已提交
10466 10467 10468

  sleeping_task_low.WakeUp();
  sleeping_task_low.WaitUntilDone();
10469 10470 10471 10472 10473 10474 10475 10476 10477 10478 10479 10480 10481 10482 10483 10484 10485 10486 10487 10488 10489 10490
}

// Multi-threaded Timeout Test
namespace {

static const int kValueSize = 1000;
static const int kWriteBufferSize = 100000;

struct TimeoutWriterState {
  int id;
  DB* db;
  std::atomic<bool> done;
  std::map<int, std::string> success_kvs;
};

static void RandomTimeoutWriter(void* arg) {
  TimeoutWriterState* state = reinterpret_cast<TimeoutWriterState*>(arg);
  static const uint64_t kTimerBias = 50;
  int thread_id = state->id;
  DB* db = state->db;

  Random rnd(1000 + thread_id);
L
Lei Jin 已提交
10491
  WriteOptions write_opt;
10492 10493 10494 10495 10496 10497 10498 10499 10500 10501 10502 10503 10504 10505 10506 10507 10508 10509 10510 10511 10512 10513 10514 10515 10516 10517 10518 10519 10520 10521 10522 10523 10524 10525 10526 10527 10528 10529 10530 10531 10532
  write_opt.timeout_hint_us = 500;
  int timeout_count = 0;
  int num_keys = kNumKeys * 5;

  for (int k = 0; k < num_keys; ++k) {
    int key = k + thread_id * num_keys;
    std::string value = RandomString(&rnd, kValueSize);
    // only the second-half is randomized
    if (k > num_keys / 2) {
      switch (rnd.Next() % 5) {
        case 0:
          write_opt.timeout_hint_us = 500 * thread_id;
          break;
        case 1:
          write_opt.timeout_hint_us = num_keys - k;
          break;
        case 2:
          write_opt.timeout_hint_us = 1;
          break;
        default:
          write_opt.timeout_hint_us = 0;
          state->success_kvs.insert({key, value});
      }
    }

    uint64_t time_before_put = db->GetEnv()->NowMicros();
    Status s = db->Put(write_opt, Key(key), value);
    uint64_t put_duration = db->GetEnv()->NowMicros() - time_before_put;
    if (write_opt.timeout_hint_us == 0 ||
        put_duration + kTimerBias < write_opt.timeout_hint_us) {
      ASSERT_OK(s);
    }
    if (s.IsTimedOut()) {
      timeout_count++;
      ASSERT_GT(put_duration + kTimerBias, write_opt.timeout_hint_us);
    }
  }

  state->done = true;
}

I
Igor Sugak 已提交
10533
TEST_F(DBTest, MTRandomTimeoutTest) {
10534 10535 10536 10537 10538 10539 10540 10541
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.max_write_buffer_number = 2;
  options.compression = kNoCompression;
  options.level0_slowdown_writes_trigger = 10;
  options.level0_stop_writes_trigger = 20;
  options.write_buffer_size = kWriteBufferSize;
L
Lei Jin 已提交
10542
  DestroyAndReopen(options);
10543 10544 10545 10546 10547 10548 10549 10550 10551 10552 10553 10554 10555 10556 10557 10558 10559 10560 10561 10562 10563 10564 10565 10566 10567

  TimeoutWriterState thread_states[kNumThreads];
  for (int tid = 0; tid < kNumThreads; ++tid) {
    thread_states[tid].id = tid;
    thread_states[tid].db = db_;
    thread_states[tid].done = false;
    env_->StartThread(RandomTimeoutWriter, &thread_states[tid]);
  }

  for (int tid = 0; tid < kNumThreads; ++tid) {
    while (thread_states[tid].done == false) {
      env_->SleepForMicroseconds(100000);
    }
  }

  Flush();

  for (int tid = 0; tid < kNumThreads; ++tid) {
    auto& success_kvs = thread_states[tid].success_kvs;
    for (auto it = success_kvs.begin(); it != success_kvs.end(); ++it) {
      ASSERT_EQ(Get(Key(it->first)), it->second);
    }
  }
}

I
Igor Sugak 已提交
10568
TEST_F(DBTest, Level0StopWritesTest) {
10569 10570 10571
  Options options = CurrentOptions();
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 4;
10572
  options.disable_auto_compactions = true;
10573
  options.max_mem_compaction_level = 0;
L
Lei Jin 已提交
10574
  Reopen(options);
10575 10576 10577 10578 10579 10580 10581 10582 10583 10584 10585 10586 10587

  // create 4 level0 tables
  for (int i = 0; i < 4; ++i) {
    Put("a", "b");
    Flush();
  }

  WriteOptions woptions;
  woptions.timeout_hint_us = 30 * 1000;  // 30 ms
  Status s = Put("a", "b", woptions);
  ASSERT_TRUE(s.IsTimedOut());
}

10588 10589
}  // anonymous namespace

L
Lei Jin 已提交
10590 10591
/*
 * This test is not reliable enough as it heavily depends on disk behavior.
L
Lei Jin 已提交
10592
 */
I
Igor Sugak 已提交
10593
TEST_F(DBTest, RateLimitingTest) {
L
Lei Jin 已提交
10594
  Options options = CurrentOptions();
L
Lei Jin 已提交
10595 10596 10597 10598 10599
  options.write_buffer_size = 1 << 20;         // 1MB
  options.level0_file_num_compaction_trigger = 2;
  options.target_file_size_base = 1 << 20;     // 1MB
  options.max_bytes_for_level_base = 4 << 20;  // 4MB
  options.max_bytes_for_level_multiplier = 4;
L
Lei Jin 已提交
10600 10601 10602
  options.compression = kNoCompression;
  options.create_if_missing = true;
  options.env = env_;
L
Lei Jin 已提交
10603
  options.IncreaseParallelism(4);
L
Lei Jin 已提交
10604
  DestroyAndReopen(options);
L
Lei Jin 已提交
10605

L
Lei Jin 已提交
10606 10607 10608
  WriteOptions wo;
  wo.disableWAL = true;

L
Lei Jin 已提交
10609 10610 10611
  // # no rate limiting
  Random rnd(301);
  uint64_t start = env_->NowMicros();
L
Lei Jin 已提交
10612 10613 10614 10615
  // Write ~96M data
  for (int64_t i = 0; i < (96 << 10); ++i) {
    ASSERT_OK(Put(RandomString(&rnd, 32),
                  RandomString(&rnd, (1 << 10) + 1), wo));
L
Lei Jin 已提交
10616 10617 10618 10619 10620 10621 10622
  }
  uint64_t elapsed = env_->NowMicros() - start;
  double raw_rate = env_->bytes_written_ * 1000000 / elapsed;
  Close();

  // # rate limiting with 0.7 x threshold
  options.rate_limiter.reset(
L
Lei Jin 已提交
10623
    NewGenericRateLimiter(static_cast<int64_t>(0.7 * raw_rate)));
L
Lei Jin 已提交
10624
  env_->bytes_written_ = 0;
L
Lei Jin 已提交
10625
  DestroyAndReopen(options);
L
Lei Jin 已提交
10626 10627

  start = env_->NowMicros();
L
Lei Jin 已提交
10628 10629 10630 10631
  // Write ~96M data
  for (int64_t i = 0; i < (96 << 10); ++i) {
    ASSERT_OK(Put(RandomString(&rnd, 32),
                  RandomString(&rnd, (1 << 10) + 1), wo));
L
Lei Jin 已提交
10632 10633 10634 10635 10636 10637 10638
  }
  elapsed = env_->NowMicros() - start;
  Close();
  ASSERT_TRUE(options.rate_limiter->GetTotalBytesThrough() ==
              env_->bytes_written_);
  double ratio = env_->bytes_written_ * 1000000 / elapsed / raw_rate;
  fprintf(stderr, "write rate ratio = %.2lf, expected 0.7\n", ratio);
L
Lei Jin 已提交
10639
  ASSERT_TRUE(ratio < 0.8);
L
Lei Jin 已提交
10640 10641 10642

  // # rate limiting with half of the raw_rate
  options.rate_limiter.reset(
L
Lei Jin 已提交
10643
    NewGenericRateLimiter(static_cast<int64_t>(raw_rate / 2)));
L
Lei Jin 已提交
10644
  env_->bytes_written_ = 0;
L
Lei Jin 已提交
10645
  DestroyAndReopen(options);
L
Lei Jin 已提交
10646 10647

  start = env_->NowMicros();
L
Lei Jin 已提交
10648 10649 10650 10651
  // Write ~96M data
  for (int64_t i = 0; i < (96 << 10); ++i) {
    ASSERT_OK(Put(RandomString(&rnd, 32),
                  RandomString(&rnd, (1 << 10) + 1), wo));
L
Lei Jin 已提交
10652 10653 10654 10655 10656 10657 10658
  }
  elapsed = env_->NowMicros() - start;
  Close();
  ASSERT_TRUE(options.rate_limiter->GetTotalBytesThrough() ==
              env_->bytes_written_);
  ratio = env_->bytes_written_ * 1000000 / elapsed / raw_rate;
  fprintf(stderr, "write rate ratio = %.2lf, expected 0.5\n", ratio);
L
Lei Jin 已提交
10659
  ASSERT_TRUE(ratio < 0.6);
L
Lei Jin 已提交
10660 10661
}

10662 10663 10664 10665 10666 10667 10668 10669 10670 10671 10672 10673 10674 10675 10676 10677 10678 10679 10680 10681 10682 10683 10684 10685 10686 10687 10688 10689 10690 10691 10692 10693 10694 10695 10696 10697 10698 10699 10700 10701 10702 10703 10704 10705 10706 10707 10708 10709 10710 10711 10712 10713
namespace {
  bool HaveOverlappingKeyRanges(
      const Comparator* c,
      const SstFileMetaData& a, const SstFileMetaData& b) {
    if (c->Compare(a.smallestkey, b.smallestkey) >= 0) {
      if (c->Compare(a.smallestkey, b.largestkey) <= 0) {
        // b.smallestkey <= a.smallestkey <= b.largestkey
        return true;
      }
    } else if (c->Compare(a.largestkey, b.smallestkey) >= 0) {
      // a.smallestkey < b.smallestkey <= a.largestkey
      return true;
    }
    if (c->Compare(a.largestkey, b.largestkey) <= 0) {
      if (c->Compare(a.largestkey, b.smallestkey) >= 0) {
        // b.smallestkey <= a.largestkey <= b.largestkey
        return true;
      }
    } else if (c->Compare(a.smallestkey, b.largestkey) <= 0) {
      // a.smallestkey <= b.largestkey < a.largestkey
      return true;
    }
    return false;
  }

  // Identifies all files between level "min_level" and "max_level"
  // which has overlapping key range with "input_file_meta".
  void GetOverlappingFileNumbersForLevelCompaction(
      const ColumnFamilyMetaData& cf_meta,
      const Comparator* comparator,
      int min_level, int max_level,
      const SstFileMetaData* input_file_meta,
      std::set<std::string>* overlapping_file_names) {
    std::set<const SstFileMetaData*> overlapping_files;
    overlapping_files.insert(input_file_meta);
    for (int m = min_level; m <= max_level; ++m) {
      for (auto& file : cf_meta.levels[m].files) {
        for (auto* included_file : overlapping_files) {
          if (HaveOverlappingKeyRanges(
                  comparator, *included_file, file)) {
            overlapping_files.insert(&file);
            overlapping_file_names->insert(file.name);
            break;
          }
        }
      }
    }
  }

  void VerifyCompactionResult(
      const ColumnFamilyMetaData& cf_meta,
      const std::set<std::string>& overlapping_file_numbers) {
C
Chris BeHanna 已提交
10714
#ifndef NDEBUG
10715 10716 10717 10718 10719 10720
    for (auto& level : cf_meta.levels) {
      for (auto& file : level.files) {
        assert(overlapping_file_numbers.find(file.name) ==
               overlapping_file_numbers.end());
      }
    }
C
Chris BeHanna 已提交
10721
#endif
10722 10723 10724 10725 10726 10727 10728 10729 10730 10731 10732 10733 10734 10735 10736 10737 10738 10739 10740 10741 10742 10743 10744
  }

  const SstFileMetaData* PickFileRandomly(
      const ColumnFamilyMetaData& cf_meta,
      Random* rand,
      int* level = nullptr) {
    auto file_id = rand->Uniform(static_cast<int>(
        cf_meta.file_count)) + 1;
    for (auto& level_meta : cf_meta.levels) {
      if (file_id <= level_meta.files.size()) {
        if (level != nullptr) {
          *level = level_meta.level;
        }
        auto result = rand->Uniform(file_id);
        return &(level_meta.files[result]);
      }
      file_id -= level_meta.files.size();
    }
    assert(false);
    return nullptr;
  }
}  // namespace

10745 10746
// TODO t6534343 -- Don't run two level 0 CompactFiles concurrently
TEST_F(DBTest, DISABLED_CompactFilesOnLevelCompaction) {
10747 10748 10749
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
10750 10751 10752 10753 10754 10755 10756 10757 10758 10759 10760 10761 10762 10763 10764
  const int kEntriesPerBuffer = 100;
  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
  options.target_file_size_base = options.write_buffer_size;
  options.max_bytes_for_level_base = options.target_file_size_base * 2;
  options.level0_stop_writes_trigger = 2;
  options.max_bytes_for_level_multiplier = 2;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  Random rnd(301);
  for (int key = 64 * kEntriesPerBuffer; key >= 0; --key) {
10765
    ASSERT_OK(Put(1, ToString(key), RandomString(&rnd, kTestValueSize)));
10766 10767 10768 10769 10770 10771
  }
  dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
  dbfull()->TEST_WaitForCompact();

  ColumnFamilyMetaData cf_meta;
  dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
10772
  int output_level = static_cast<int>(cf_meta.levels.size()) - 1;
10773 10774 10775 10776 10777 10778 10779 10780 10781 10782 10783 10784 10785 10786 10787 10788 10789 10790 10791 10792 10793 10794 10795 10796
  for (int file_picked = 5; file_picked > 0; --file_picked) {
    std::set<std::string> overlapping_file_names;
    std::vector<std::string> compaction_input_file_names;
    for (int f = 0; f < file_picked; ++f) {
      int level;
      auto file_meta = PickFileRandomly(cf_meta, &rnd, &level);
      compaction_input_file_names.push_back(file_meta->name);
      GetOverlappingFileNumbersForLevelCompaction(
          cf_meta, options.comparator, level, output_level,
          file_meta, &overlapping_file_names);
    }

    ASSERT_OK(dbfull()->CompactFiles(
        CompactionOptions(), handles_[1],
        compaction_input_file_names,
        output_level));

    // Make sure all overlapping files do not exist after compaction
    dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
    VerifyCompactionResult(cf_meta, overlapping_file_names);
  }

  // make sure all key-values are still there.
  for (int key = 64 * kEntriesPerBuffer; key >= 0; --key) {
10797
    ASSERT_NE(Get(1, ToString(key)), "NOT_FOUND");
10798 10799 10800
  }
}

I
Igor Sugak 已提交
10801
TEST_F(DBTest, CompactFilesOnUniversalCompaction) {
10802 10803 10804
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
10805 10806 10807 10808 10809 10810 10811
  const int kEntriesPerBuffer = 10;

  ChangeCompactOptions();
  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
S
sdong 已提交
10812
  options.num_levels = 1;
10813 10814 10815 10816 10817 10818 10819
  options.target_file_size_base = options.write_buffer_size;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_EQ(options.compaction_style, kCompactionStyleUniversal);
  Random rnd(301);
  for (int key = 1024 * kEntriesPerBuffer; key >= 0; --key) {
10820
    ASSERT_OK(Put(1, ToString(key), RandomString(&rnd, kTestValueSize)));
10821 10822 10823 10824 10825 10826 10827 10828 10829 10830 10831 10832 10833 10834 10835 10836 10837 10838 10839 10840 10841 10842 10843 10844 10845 10846 10847 10848 10849 10850 10851 10852 10853 10854 10855 10856 10857 10858 10859 10860 10861 10862 10863 10864 10865 10866 10867 10868 10869 10870
  }
  dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
  dbfull()->TEST_WaitForCompact();
  ColumnFamilyMetaData cf_meta;
  dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
  std::vector<std::string> compaction_input_file_names;
  for (auto file : cf_meta.levels[0].files) {
    if (rnd.OneIn(2)) {
      compaction_input_file_names.push_back(file.name);
    }
  }

  if (compaction_input_file_names.size() == 0) {
    compaction_input_file_names.push_back(
        cf_meta.levels[0].files[0].name);
  }

  // expect fail since universal compaction only allow L0 output
  ASSERT_TRUE(!dbfull()->CompactFiles(
      CompactionOptions(), handles_[1],
      compaction_input_file_names, 1).ok());

  // expect ok and verify the compacted files no longer exist.
  ASSERT_OK(dbfull()->CompactFiles(
      CompactionOptions(), handles_[1],
      compaction_input_file_names, 0));

  dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
  VerifyCompactionResult(
      cf_meta,
      std::set<std::string>(compaction_input_file_names.begin(),
          compaction_input_file_names.end()));

  compaction_input_file_names.clear();

  // Pick the first and the last file, expect everything is
  // compacted into one single file.
  compaction_input_file_names.push_back(
      cf_meta.levels[0].files[0].name);
  compaction_input_file_names.push_back(
      cf_meta.levels[0].files[
          cf_meta.levels[0].files.size() - 1].name);
  ASSERT_OK(dbfull()->CompactFiles(
      CompactionOptions(), handles_[1],
      compaction_input_file_names, 0));

  dbfull()->GetColumnFamilyMetaData(handles_[1], &cf_meta);
  ASSERT_EQ(cf_meta.levels[0].files.size(), 1U);
}

I
Igor Sugak 已提交
10871
TEST_F(DBTest, TableOptionsSanitizeTest) {
10872 10873
  Options options = CurrentOptions();
  options.create_if_missing = true;
L
Lei Jin 已提交
10874
  DestroyAndReopen(options);
10875 10876 10877 10878
  ASSERT_EQ(db_->GetOptions().allow_mmap_reads, false);

  options.table_factory.reset(new PlainTableFactory());
  options.prefix_extractor.reset(NewNoopTransform());
L
Lei Jin 已提交
10879
  Destroy(options);
L
Lei Jin 已提交
10880
  ASSERT_TRUE(TryReopen(options).IsNotSupported());
10881 10882 10883 10884 10885

  // Test for check of prefix_extractor when hash index is used for
  // block-based table
  BlockBasedTableOptions to;
  to.index_type = BlockBasedTableOptions::kHashSearch;
10886
  options = CurrentOptions();
10887 10888
  options.create_if_missing = true;
  options.table_factory.reset(NewBlockBasedTableFactory(to));
L
Lei Jin 已提交
10889
  ASSERT_TRUE(TryReopen(options).IsInvalidArgument());
10890
  options.prefix_extractor.reset(NewFixedPrefixTransform(1));
L
Lei Jin 已提交
10891
  ASSERT_OK(TryReopen(options));
10892 10893
}

I
Igor Sugak 已提交
10894
TEST_F(DBTest, SanitizeNumThreads) {
10895 10896 10897 10898 10899 10900 10901 10902 10903 10904 10905 10906 10907 10908 10909 10910 10911 10912 10913 10914 10915 10916 10917 10918 10919 10920 10921 10922 10923 10924 10925 10926 10927 10928 10929 10930 10931 10932
  for (int attempt = 0; attempt < 2; attempt++) {
    const size_t kTotalTasks = 8;
    SleepingBackgroundTask sleeping_tasks[kTotalTasks];

    Options options = CurrentOptions();
    if (attempt == 0) {
      options.max_background_compactions = 3;
      options.max_background_flushes = 2;
    }
    options.create_if_missing = true;
    DestroyAndReopen(options);

    for (size_t i = 0; i < kTotalTasks; i++) {
      // Insert 5 tasks to low priority queue and 5 tasks to high priority queue
      env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_tasks[i],
                     (i < 4) ? Env::Priority::LOW : Env::Priority::HIGH);
    }

    // Wait 100 milliseconds for they are scheduled.
    env_->SleepForMicroseconds(100000);

    // pool size 3, total task 4. Queue size should be 1.
    ASSERT_EQ(1U, options.env->GetThreadPoolQueueLen(Env::Priority::LOW));
    // pool size 2, total task 4. Queue size should be 2.
    ASSERT_EQ(2U, options.env->GetThreadPoolQueueLen(Env::Priority::HIGH));

    for (size_t i = 0; i < kTotalTasks; i++) {
      sleeping_tasks[i].WakeUp();
      sleeping_tasks[i].WaitUntilDone();
    }

    ASSERT_OK(Put("abc", "def"));
    ASSERT_EQ("def", Get("abc"));
    Flush();
    ASSERT_EQ("def", Get("abc"));
  }
}

I
Igor Sugak 已提交
10933
TEST_F(DBTest, DBIteratorBoundTest) {
10934
  Options options = CurrentOptions();
10935 10936 10937 10938
  options.env = env_;
  options.create_if_missing = true;

  options.prefix_extractor = nullptr;
L
Lei Jin 已提交
10939
  DestroyAndReopen(options);
10940 10941 10942 10943 10944 10945 10946 10947 10948 10949 10950 10951 10952 10953 10954 10955 10956 10957 10958 10959 10960 10961 10962 10963 10964 10965 10966 10967 10968 10969 10970
  ASSERT_OK(Put("a", "0"));
  ASSERT_OK(Put("foo", "bar"));
  ASSERT_OK(Put("foo1", "bar1"));
  ASSERT_OK(Put("g1", "0"));

  // testing basic case with no iterate_upper_bound and no prefix_extractor
  {
    ReadOptions ro;
    ro.iterate_upper_bound = nullptr;

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->Seek("foo");

    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("foo")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("foo1")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("g1")), 0);
  }

  // testing iterate_upper_bound and forward iterator
  // to make sure it stops at bound
  {
    ReadOptions ro;
    // iterate_upper_bound points beyond the last expected entry
10971 10972
    Slice prefix("foo2");
    ro.iterate_upper_bound = &prefix;
10973 10974 10975 10976 10977 10978 10979 10980 10981 10982 10983 10984 10985 10986 10987 10988

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->Seek("foo");

    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("foo")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(("foo1")), 0);

    iter->Next();
    // should stop here...
    ASSERT_TRUE(!iter->Valid());
  }
10989 10990 10991 10992 10993 10994 10995 10996 10997 10998 10999 11000 11001
  // Testing SeekToLast with iterate_upper_bound set
  {
    ReadOptions ro;

    Slice prefix("foo");
    ro.iterate_upper_bound = &prefix;

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->SeekToLast();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("a")), 0);
  }
11002 11003 11004 11005

  // prefix is the first letter of the key
  options.prefix_extractor.reset(NewFixedPrefixTransform(1));

L
Lei Jin 已提交
11006
  DestroyAndReopen(options);
11007 11008 11009 11010 11011 11012 11013 11014 11015 11016
  ASSERT_OK(Put("a", "0"));
  ASSERT_OK(Put("foo", "bar"));
  ASSERT_OK(Put("foo1", "bar1"));
  ASSERT_OK(Put("g1", "0"));

  // testing with iterate_upper_bound and prefix_extractor
  // Seek target and iterate_upper_bound are not is same prefix
  // This should be an error
  {
    ReadOptions ro;
11017 11018
    Slice prefix("g1");
    ro.iterate_upper_bound = &prefix;
11019 11020 11021 11022 11023 11024 11025 11026 11027 11028 11029 11030 11031

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->Seek("foo");

    ASSERT_TRUE(!iter->Valid());
    ASSERT_TRUE(iter->status().IsInvalidArgument());
  }

  // testing that iterate_upper_bound prevents iterating over deleted items
  // if the bound has already reached
  {
    options.prefix_extractor = nullptr;
L
Lei Jin 已提交
11032
    DestroyAndReopen(options);
11033 11034 11035 11036 11037 11038 11039 11040 11041 11042 11043 11044 11045 11046 11047 11048 11049 11050 11051 11052 11053 11054 11055 11056 11057 11058 11059 11060 11061 11062
    ASSERT_OK(Put("a", "0"));
    ASSERT_OK(Put("b", "0"));
    ASSERT_OK(Put("b1", "0"));
    ASSERT_OK(Put("c", "0"));
    ASSERT_OK(Put("d", "0"));
    ASSERT_OK(Put("e", "0"));
    ASSERT_OK(Delete("c"));
    ASSERT_OK(Delete("d"));

    // base case with no bound
    ReadOptions ro;
    ro.iterate_upper_bound = nullptr;

    std::unique_ptr<Iterator> iter(db_->NewIterator(ro));

    iter->Seek("b");
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("b")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(("b1")), 0);

    perf_context.Reset();
    iter->Next();

    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(static_cast<int>(perf_context.internal_delete_skipped_count), 2);

    // now testing with iterate_bound
11063 11064
    Slice prefix("c");
    ro.iterate_upper_bound = &prefix;
11065 11066 11067 11068 11069 11070 11071 11072 11073 11074 11075 11076 11077 11078 11079 11080 11081 11082 11083 11084 11085 11086

    iter.reset(db_->NewIterator(ro));

    perf_context.Reset();

    iter->Seek("b");
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Slice("b")), 0);

    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(("b1")), 0);

    iter->Next();
    // the iteration should stop as soon as the the bound key is reached
    // even though the key is deleted
    // hence internal_delete_skipped_count should be 0
    ASSERT_TRUE(!iter->Valid());
    ASSERT_EQ(static_cast<int>(perf_context.internal_delete_skipped_count), 0);
  }
}

I
Igor Sugak 已提交
11087
TEST_F(DBTest, WriteSingleThreadEntry) {
11088 11089 11090 11091 11092 11093 11094 11095 11096 11097 11098 11099 11100 11101 11102 11103 11104
  std::vector<std::thread> threads;
  dbfull()->TEST_LockMutex();
  auto w = dbfull()->TEST_BeginWrite();
  threads.emplace_back([&] { Put("a", "b"); });
  env_->SleepForMicroseconds(10000);
  threads.emplace_back([&] { Flush(); });
  env_->SleepForMicroseconds(10000);
  dbfull()->TEST_UnlockMutex();
  dbfull()->TEST_LockMutex();
  dbfull()->TEST_EndWrite(w);
  dbfull()->TEST_UnlockMutex();

  for (auto& t : threads) {
    t.join();
  }
}

I
Igor Sugak 已提交
11105
TEST_F(DBTest, DisableDataSyncTest) {
S
sdong 已提交
11106
  env_->sync_counter_.store(0);
11107 11108 11109 11110 11111 11112 11113
  // iter 0 -- no sync
  // iter 1 -- sync
  for (int iter = 0; iter < 2; ++iter) {
    Options options = CurrentOptions();
    options.disableDataSync = iter == 0;
    options.create_if_missing = true;
    options.env = env_;
L
Lei Jin 已提交
11114
    Reopen(options);
L
Lei Jin 已提交
11115
    CreateAndReopenWithCF({"pikachu"}, options);
11116 11117 11118 11119 11120 11121 11122 11123 11124

    MakeTables(10, "a", "z");
    Compact("a", "z");

    if (iter == 0) {
      ASSERT_EQ(env_->sync_counter_.load(), 0);
    } else {
      ASSERT_GT(env_->sync_counter_.load(), 0);
    }
L
Lei Jin 已提交
11125
    Destroy(options);
11126 11127
  }
}
11128

I
Igor Sugak 已提交
11129
TEST_F(DBTest, DynamicMemtableOptions) {
L
Lei Jin 已提交
11130 11131 11132 11133 11134 11135 11136
  const uint64_t k64KB = 1 << 16;
  const uint64_t k128KB = 1 << 17;
  const uint64_t k5KB = 5 * 1024;
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.compression = kNoCompression;
11137
  options.max_background_compactions = 1;
L
Lei Jin 已提交
11138 11139 11140 11141 11142 11143 11144
  options.max_mem_compaction_level = 0;
  options.write_buffer_size = k64KB;
  options.max_write_buffer_number = 2;
  // Don't trigger compact/slowdown/stop
  options.level0_file_num_compaction_trigger = 1024;
  options.level0_slowdown_writes_trigger = 1024;
  options.level0_stop_writes_trigger = 1024;
L
Lei Jin 已提交
11145
  DestroyAndReopen(options);
L
Lei Jin 已提交
11146 11147 11148 11149

  auto gen_l0_kb = [this](int size) {
    Random rnd(301);
    for (int i = 0; i < size; i++) {
L
Lei Jin 已提交
11150
      ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
L
Lei Jin 已提交
11151 11152 11153 11154
    }
    dbfull()->TEST_WaitForFlushMemTable();
  };

L
Lei Jin 已提交
11155
  // Test write_buffer_size
L
Lei Jin 已提交
11156 11157
  gen_l0_kb(64);
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
11158 11159
  ASSERT_LT(SizeAtLevel(0), k64KB + k5KB);
  ASSERT_GT(SizeAtLevel(0), k64KB - k5KB);
L
Lei Jin 已提交
11160 11161

  // Clean up L0
11162
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
11163 11164 11165
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

  // Increase buffer size
11166
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
11167 11168 11169 11170 11171 11172 11173 11174
    {"write_buffer_size", "131072"},
  }));

  // The existing memtable is still 64KB in size, after it becomes immutable,
  // the next memtable will be 128KB in size. Write 256KB total, we should
  // have a 64KB L0 file, a 128KB L0 file, and a memtable with 64KB data
  gen_l0_kb(256);
  ASSERT_EQ(NumTableFilesAtLevel(0), 2);
11175 11176
  ASSERT_LT(SizeAtLevel(0), k128KB + k64KB + 2 * k5KB);
  ASSERT_GT(SizeAtLevel(0), k128KB + k64KB - 2 * k5KB);
L
Lei Jin 已提交
11177 11178 11179 11180 11181 11182

  // Test max_write_buffer_number
  // Block compaction thread, which will also block the flushes because
  // max_background_flushes == 0, so flushes are getting executed by the
  // compaction thread
  env_->SetBackgroundThreads(1, Env::LOW);
L
Lei Jin 已提交
11183 11184
  SleepingBackgroundTask sleeping_task_low1;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low1,
L
Lei Jin 已提交
11185 11186 11187 11188 11189
                 Env::Priority::LOW);
  // Start from scratch and disable compaction/flush. Flush can only happen
  // during compaction but trigger is pretty high
  options.max_background_flushes = 0;
  options.disable_auto_compactions = true;
L
Lei Jin 已提交
11190
  DestroyAndReopen(options);
L
Lei Jin 已提交
11191 11192 11193 11194 11195

  // Put until timeout, bounded by 256 puts. We should see timeout at ~128KB
  int count = 0;
  Random rnd(301);
  WriteOptions wo;
S
sdong 已提交
11196 11197 11198 11199 11200 11201
  wo.timeout_hint_us = 100000;  // Reasonabley long timeout to make sure sleep
                                // triggers but not forever.

  std::atomic<int> sleep_count(0);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::DelayWrite:TimedWait",
11202
      [&](void* arg) { sleep_count.fetch_add(1); });
S
sdong 已提交
11203
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
L
Lei Jin 已提交
11204 11205 11206 11207

  while (Put(Key(count), RandomString(&rnd, 1024), wo).ok() && count < 256) {
    count++;
  }
S
sdong 已提交
11208
  ASSERT_GT(sleep_count.load(), 0);
11209 11210
  ASSERT_GT(static_cast<double>(count), 128 * 0.8);
  ASSERT_LT(static_cast<double>(count), 128 * 1.2);
L
Lei Jin 已提交
11211

L
Lei Jin 已提交
11212 11213
  sleeping_task_low1.WakeUp();
  sleeping_task_low1.WaitUntilDone();
L
Lei Jin 已提交
11214 11215

  // Increase
11216
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
11217 11218 11219
    {"max_write_buffer_number", "8"},
  }));
  // Clean up memtable and L0
11220
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
11221

L
Lei Jin 已提交
11222 11223
  SleepingBackgroundTask sleeping_task_low2;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low2,
L
Lei Jin 已提交
11224 11225
                 Env::Priority::LOW);
  count = 0;
S
sdong 已提交
11226
  sleep_count.store(0);
L
Lei Jin 已提交
11227 11228 11229
  while (Put(Key(count), RandomString(&rnd, 1024), wo).ok() && count < 1024) {
    count++;
  }
S
sdong 已提交
11230
  ASSERT_GT(sleep_count.load(), 0);
D
Dmitri Smirnov 已提交
11231 11232 11233
  // Windows fails this test. Will tune in the future and figure out
  // approp number
#ifndef OS_WIN
11234 11235
  ASSERT_GT(static_cast<double>(count), 512 * 0.8);
  ASSERT_LT(static_cast<double>(count), 512 * 1.2);
D
Dmitri Smirnov 已提交
11236
#endif
L
Lei Jin 已提交
11237 11238
  sleeping_task_low2.WakeUp();
  sleeping_task_low2.WaitUntilDone();
L
Lei Jin 已提交
11239 11240

  // Decrease
11241
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
11242 11243 11244
    {"max_write_buffer_number", "4"},
  }));
  // Clean up memtable and L0
11245
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
11246

L
Lei Jin 已提交
11247 11248 11249
  SleepingBackgroundTask sleeping_task_low3;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low3,
                 Env::Priority::LOW);
S
sdong 已提交
11250

L
Lei Jin 已提交
11251
  count = 0;
S
sdong 已提交
11252
  sleep_count.store(0);
L
Lei Jin 已提交
11253 11254 11255
  while (Put(Key(count), RandomString(&rnd, 1024), wo).ok() && count < 1024) {
    count++;
  }
S
sdong 已提交
11256
  ASSERT_GT(sleep_count.load(), 0);
D
Dmitri Smirnov 已提交
11257 11258 11259
  // Windows fails this test. Will tune in the future and figure out
  // approp number
#ifndef OS_WIN
11260 11261
  ASSERT_GT(static_cast<double>(count), 256 * 0.8);
  ASSERT_LT(static_cast<double>(count), 266 * 1.2);
D
Dmitri Smirnov 已提交
11262
#endif
L
Lei Jin 已提交
11263 11264
  sleeping_task_low3.WakeUp();
  sleeping_task_low3.WaitUntilDone();
S
sdong 已提交
11265 11266

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
L
Lei Jin 已提交
11267 11268
}

Y
Yueh-Hsuan Chiang 已提交
11269
#if ROCKSDB_USING_THREAD_STATUS
11270 11271 11272 11273 11274 11275 11276 11277 11278 11279 11280 11281 11282 11283 11284
namespace {
void VerifyOperationCount(Env* env, ThreadStatus::OperationType op_type,
                          int expected_count) {
  int op_count = 0;
  std::vector<ThreadStatus> thread_list;
  ASSERT_OK(env->GetThreadList(&thread_list));
  for (auto thread : thread_list) {
    if (thread.operation_type == op_type) {
      op_count++;
    }
  }
  ASSERT_EQ(op_count, expected_count);
}
}  // namespace

I
Igor Sugak 已提交
11285
TEST_F(DBTest, GetThreadStatus) {
Y
Yueh-Hsuan Chiang 已提交
11286 11287
  Options options;
  options.env = env_;
11288 11289
  options.enable_thread_tracking = true;
  TryReopen(options);
Y
Yueh-Hsuan Chiang 已提交
11290 11291

  std::vector<ThreadStatus> thread_list;
11292
  Status s = env_->GetThreadList(&thread_list);
Y
Yueh-Hsuan Chiang 已提交
11293 11294 11295 11296 11297 11298 11299 11300 11301 11302 11303 11304

  for (int i = 0; i < 2; ++i) {
    // repeat the test with differet number of high / low priority threads
    const int kTestCount = 3;
    const unsigned int kHighPriCounts[kTestCount] = {3, 2, 5};
    const unsigned int kLowPriCounts[kTestCount] = {10, 15, 3};
    for (int test = 0; test < kTestCount; ++test) {
      // Change the number of threads in high / low priority pool.
      env_->SetBackgroundThreads(kHighPriCounts[test], Env::HIGH);
      env_->SetBackgroundThreads(kLowPriCounts[test], Env::LOW);
      // Wait to ensure the all threads has been registered
      env_->SleepForMicroseconds(100000);
11305
      s = env_->GetThreadList(&thread_list);
Y
Yueh-Hsuan Chiang 已提交
11306
      ASSERT_OK(s);
11307
      unsigned int thread_type_counts[ThreadStatus::NUM_THREAD_TYPES];
Y
Yueh-Hsuan Chiang 已提交
11308 11309
      memset(thread_type_counts, 0, sizeof(thread_type_counts));
      for (auto thread : thread_list) {
11310
        ASSERT_LT(thread.thread_type, ThreadStatus::NUM_THREAD_TYPES);
Y
Yueh-Hsuan Chiang 已提交
11311 11312 11313 11314
        thread_type_counts[thread.thread_type]++;
      }
      // Verify the total number of threades
      ASSERT_EQ(
11315 11316
          thread_type_counts[ThreadStatus::HIGH_PRIORITY] +
              thread_type_counts[ThreadStatus::LOW_PRIORITY],
Y
Yueh-Hsuan Chiang 已提交
11317 11318 11319
          kHighPriCounts[test] + kLowPriCounts[test]);
      // Verify the number of high-priority threads
      ASSERT_EQ(
11320
          thread_type_counts[ThreadStatus::HIGH_PRIORITY],
Y
Yueh-Hsuan Chiang 已提交
11321 11322 11323
          kHighPriCounts[test]);
      // Verify the number of low-priority threads
      ASSERT_EQ(
11324
          thread_type_counts[ThreadStatus::LOW_PRIORITY],
Y
Yueh-Hsuan Chiang 已提交
11325 11326 11327 11328 11329
          kLowPriCounts[test]);
    }
    if (i == 0) {
      // repeat the test with multiple column families
      CreateAndReopenWithCF({"pikachu", "about-to-remove"}, options);
11330 11331
      env_->GetThreadStatusUpdater()->TEST_VerifyColumnFamilyInfoMap(
          handles_, true);
Y
Yueh-Hsuan Chiang 已提交
11332 11333 11334
    }
  }
  db_->DropColumnFamily(handles_[2]);
11335
  delete handles_[2];
Y
Yueh-Hsuan Chiang 已提交
11336
  handles_.erase(handles_.begin() + 2);
11337 11338
  env_->GetThreadStatusUpdater()->TEST_VerifyColumnFamilyInfoMap(
      handles_, true);
Y
Yueh-Hsuan Chiang 已提交
11339
  Close();
11340 11341
  env_->GetThreadStatusUpdater()->TEST_VerifyColumnFamilyInfoMap(
      handles_, true);
11342 11343
}

I
Igor Sugak 已提交
11344
TEST_F(DBTest, DisableThreadStatus) {
11345 11346 11347 11348 11349 11350
  Options options;
  options.env = env_;
  options.enable_thread_tracking = false;
  TryReopen(options);
  CreateAndReopenWithCF({"pikachu", "about-to-remove"}, options);
  // Verify non of the column family info exists
11351 11352
  env_->GetThreadStatusUpdater()->TEST_VerifyColumnFamilyInfoMap(
      handles_, false);
Y
Yueh-Hsuan Chiang 已提交
11353
}
11354

I
Igor Sugak 已提交
11355
TEST_F(DBTest, ThreadStatusFlush) {
11356 11357 11358 11359 11360 11361 11362
  Options options;
  options.env = env_;
  options.write_buffer_size = 100000;  // Small write buffer
  options.enable_thread_tracking = true;
  options = CurrentOptions(options);

  rocksdb::SyncPoint::GetInstance()->LoadDependency({
11363 11364
      {"FlushJob::FlushJob()", "DBTest::ThreadStatusFlush:1"},
      {"DBTest::ThreadStatusFlush:2", "FlushJob::~FlushJob()"},
11365 11366 11367 11368 11369 11370 11371 11372 11373 11374 11375 11376 11377 11378 11379 11380 11381 11382 11383 11384 11385 11386
  });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  CreateAndReopenWithCF({"pikachu"}, options);
  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0);

  ASSERT_OK(Put(1, "foo", "v1"));
  ASSERT_EQ("v1", Get(1, "foo"));
  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0);

  Put(1, "k1", std::string(100000, 'x'));  // Fill memtable
  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0);
  Put(1, "k2", std::string(100000, 'y'));  // Trigger flush
  // wait for flush to be scheduled
  env_->SleepForMicroseconds(250000);
  TEST_SYNC_POINT("DBTest::ThreadStatusFlush:1");
  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 1);
  TEST_SYNC_POINT("DBTest::ThreadStatusFlush:2");

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

I
Igor Sugak 已提交
11387
TEST_F(DBTest, ThreadStatusSingleCompaction) {
11388 11389 11390 11391 11392 11393 11394 11395 11396 11397 11398 11399 11400 11401 11402 11403 11404
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
  const int kEntriesPerBuffer = 100;
  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
  options.target_file_size_base = options.write_buffer_size;
  options.max_bytes_for_level_base = options.target_file_size_base * 2;
  options.max_bytes_for_level_multiplier = 2;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  options.env = env_;
  options.enable_thread_tracking = true;
  const int kNumL0Files = 4;
  options.level0_file_num_compaction_trigger = kNumL0Files;
11405 11406

  rocksdb::SyncPoint::GetInstance()->LoadDependency({
11407 11408 11409
      {"DBTest::ThreadStatusSingleCompaction:0", "DBImpl::BGWorkCompaction"},
      {"CompactionJob::Run():Start", "DBTest::ThreadStatusSingleCompaction:1"},
      {"DBTest::ThreadStatusSingleCompaction:2", "CompactionJob::Run():End"},
11410
  });
11411
  for (int tests = 0; tests < 2; ++tests) {
11412
    DestroyAndReopen(options);
11413 11414
    rocksdb::SyncPoint::GetInstance()->ClearTrace();
    rocksdb::SyncPoint::GetInstance()->EnableProcessing();
11415 11416

    Random rnd(301);
11417
    // The Put Phase.
11418 11419 11420 11421 11422 11423
    for (int file = 0; file < kNumL0Files; ++file) {
      for (int key = 0; key < kEntriesPerBuffer; ++key) {
        ASSERT_OK(Put(ToString(key + file * kEntriesPerBuffer),
                      RandomString(&rnd, kTestValueSize)));
      }
      Flush();
11424
    }
11425 11426 11427
    // This makes sure a compaction won't be scheduled until
    // we have done with the above Put Phase.
    TEST_SYNC_POINT("DBTest::ThreadStatusSingleCompaction:0");
11428 11429
    ASSERT_GE(NumTableFilesAtLevel(0),
              options.level0_file_num_compaction_trigger);
11430

11431
    // This makes sure at least one compaction is running.
11432
    TEST_SYNC_POINT("DBTest::ThreadStatusSingleCompaction:1");
11433

11434 11435
    if (options.enable_thread_tracking) {
      // expecting one single L0 to L1 compaction
11436
      VerifyOperationCount(env_, ThreadStatus::OP_COMPACTION, 1);
11437 11438
    } else {
      // If thread tracking is not enabled, compaction count should be 0.
11439
      VerifyOperationCount(env_, ThreadStatus::OP_COMPACTION, 0);
11440
    }
11441
    // TODO(yhchiang): adding assert to verify each compaction stage.
11442
    TEST_SYNC_POINT("DBTest::ThreadStatusSingleCompaction:2");
11443 11444 11445

    // repeat the test with disabling thread tracking.
    options.enable_thread_tracking = false;
11446
    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
11447 11448 11449
  }
}

I
Igor Sugak 已提交
11450
TEST_F(DBTest, PreShutdownManualCompaction) {
11451 11452 11453 11454 11455 11456 11457 11458 11459 11460 11461 11462 11463 11464 11465 11466 11467 11468 11469 11470 11471 11472 11473 11474 11475 11476 11477 11478 11479 11480 11481 11482 11483 11484 11485 11486
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_EQ(dbfull()->MaxMemCompactionLevel(), 2)
      << "Need to update this test to match kMaxMemCompactLevel";

  // iter - 0 with 7 levels
  // iter - 1 with 3 levels
  for (int iter = 0; iter < 2; ++iter) {
    MakeTables(3, "p", "q", 1);
    ASSERT_EQ("1,1,1", FilesPerLevel(1));

    // Compaction range falls before files
    Compact(1, "", "c");
    ASSERT_EQ("1,1,1", FilesPerLevel(1));

    // Compaction range falls after files
    Compact(1, "r", "z");
    ASSERT_EQ("1,1,1", FilesPerLevel(1));

    // Compaction range overlaps files
    Compact(1, "p1", "p9");
    ASSERT_EQ("0,0,1", FilesPerLevel(1));

    // Populate a different range
    MakeTables(3, "c", "e", 1);
    ASSERT_EQ("1,1,2", FilesPerLevel(1));

    // Compact just the new range
    Compact(1, "b", "f");
    ASSERT_EQ("0,0,2", FilesPerLevel(1));

    // Compact all
    MakeTables(1, "a", "z", 1);
    ASSERT_EQ("0,1,2", FilesPerLevel(1));
    CancelAllBackgroundWork(db_);
11487
    db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
11488 11489 11490 11491 11492 11493 11494 11495 11496 11497 11498 11499 11500
    ASSERT_EQ("0,1,2", FilesPerLevel(1));

    if (iter == 0) {
      options = CurrentOptions();
      options.max_background_flushes = 0;
      options.num_levels = 3;
      options.create_if_missing = true;
      DestroyAndReopen(options);
      CreateAndReopenWithCF({"pikachu"}, options);
    }
  }
}

11501 11502 11503 11504 11505 11506 11507 11508 11509 11510 11511
TEST_F(DBTest, PreShutdownFlush) {
  Options options = CurrentOptions();
  options.max_background_flushes = 0;
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_OK(Put(1, "key", "value"));
  CancelAllBackgroundWork(db_);
  Status s =
      db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
  ASSERT_TRUE(s.IsShutdownInProgress());
}

I
Igor Sugak 已提交
11512
TEST_F(DBTest, PreShutdownMultipleCompaction) {
11513 11514 11515
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
11516
  const int kEntriesPerBuffer = 40;
11517 11518 11519 11520 11521 11522 11523 11524 11525 11526 11527 11528 11529 11530 11531 11532 11533 11534 11535 11536 11537
  const int kNumL0Files = 4;

  const int kHighPriCount = 3;
  const int kLowPriCount = 5;
  env_->SetBackgroundThreads(kHighPriCount, Env::HIGH);
  env_->SetBackgroundThreads(kLowPriCount, Env::LOW);

  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
  options.target_file_size_base = options.write_buffer_size;
  options.max_bytes_for_level_base =
      options.target_file_size_base * kNumL0Files;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  options.env = env_;
  options.enable_thread_tracking = true;
  options.level0_file_num_compaction_trigger = kNumL0Files;
  options.max_bytes_for_level_multiplier = 2;
  options.max_background_compactions = kLowPriCount;
11538 11539
  options.level0_stop_writes_trigger = 1 << 10;
  options.level0_slowdown_writes_trigger = 1 << 10;
11540 11541 11542 11543 11544 11545 11546

  TryReopen(options);
  Random rnd(301);

  std::vector<ThreadStatus> thread_list;
  // Delay both flush and compaction
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
11547 11548
      {{"FlushJob::FlushJob()", "CompactionJob::Run():Start"},
       {"CompactionJob::Run():Start",
11549
        "DBTest::PreShutdownMultipleCompaction:Preshutdown"},
11550 11551
        {"CompactionJob::Run():Start",
        "DBTest::PreShutdownMultipleCompaction:VerifyCompaction"},
11552
       {"DBTest::PreShutdownMultipleCompaction:Preshutdown",
11553 11554
        "CompactionJob::Run():End"},
       {"CompactionJob::Run():End",
11555 11556 11557 11558 11559 11560 11561 11562
        "DBTest::PreShutdownMultipleCompaction:VerifyPreshutdown"}});

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  // Make rocksdb busy
  int key = 0;
  // check how many threads are doing compaction using GetThreadList
  int operation_count[ThreadStatus::NUM_OP_TYPES] = {0};
11563
  for (int file = 0; file < 16 * kNumL0Files; ++file) {
11564 11565 11566 11567 11568 11569 11570 11571 11572 11573
    for (int k = 0; k < kEntriesPerBuffer; ++k) {
      ASSERT_OK(Put(ToString(key++), RandomString(&rnd, kTestValueSize)));
    }

    Status s = env_->GetThreadList(&thread_list);
    for (auto thread : thread_list) {
      operation_count[thread.operation_type]++;
    }

    // Speed up the test
11574 11575
    if (operation_count[ThreadStatus::OP_FLUSH] > 1 &&
        operation_count[ThreadStatus::OP_COMPACTION] >
11576 11577 11578
            0.6 * options.max_background_compactions) {
      break;
    }
11579 11580 11581
    if (file == 15 * kNumL0Files) {
      TEST_SYNC_POINT("DBTest::PreShutdownMultipleCompaction:Preshutdown");
    }
11582 11583 11584
  }

  TEST_SYNC_POINT("DBTest::PreShutdownMultipleCompaction:Preshutdown");
11585
  ASSERT_GE(operation_count[ThreadStatus::OP_COMPACTION], 1);
11586 11587 11588 11589 11590 11591 11592 11593 11594 11595 11596 11597 11598 11599
  CancelAllBackgroundWork(db_);
  TEST_SYNC_POINT("DBTest::PreShutdownMultipleCompaction:VerifyPreshutdown");
  dbfull()->TEST_WaitForCompact();
  // Record the number of compactions at a time.
  for (int i = 0; i < ThreadStatus::NUM_OP_TYPES; ++i) {
    operation_count[i] = 0;
  }
  Status s = env_->GetThreadList(&thread_list);
  for (auto thread : thread_list) {
    operation_count[thread.operation_type]++;
  }
  ASSERT_EQ(operation_count[ThreadStatus::OP_COMPACTION], 0);
}

I
Igor Sugak 已提交
11600
TEST_F(DBTest, PreShutdownCompactionMiddle) {
11601 11602 11603
  const int kTestKeySize = 16;
  const int kTestValueSize = 984;
  const int kEntrySize = kTestKeySize + kTestValueSize;
11604
  const int kEntriesPerBuffer = 40;
11605 11606 11607 11608 11609 11610 11611 11612 11613 11614 11615 11616 11617 11618 11619 11620 11621 11622 11623 11624 11625
  const int kNumL0Files = 4;

  const int kHighPriCount = 3;
  const int kLowPriCount = 5;
  env_->SetBackgroundThreads(kHighPriCount, Env::HIGH);
  env_->SetBackgroundThreads(kLowPriCount, Env::LOW);

  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
  options.target_file_size_base = options.write_buffer_size;
  options.max_bytes_for_level_base =
      options.target_file_size_base * kNumL0Files;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
  options.env = env_;
  options.enable_thread_tracking = true;
  options.level0_file_num_compaction_trigger = kNumL0Files;
  options.max_bytes_for_level_multiplier = 2;
  options.max_background_compactions = kLowPriCount;
11626 11627
  options.level0_stop_writes_trigger = 1 << 10;
  options.level0_slowdown_writes_trigger = 1 << 10;
11628 11629 11630 11631 11632 11633 11634

  TryReopen(options);
  Random rnd(301);

  std::vector<ThreadStatus> thread_list;
  // Delay both flush and compaction
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
11635
      {{"DBTest::PreShutdownCompactionMiddle:Preshutdown",
11636
        "CompactionJob::Run():Inprogress"},
11637 11638
        {"CompactionJob::Run():Start",
        "DBTest::PreShutdownCompactionMiddle:VerifyCompaction"},
11639 11640
       {"CompactionJob::Run():Inprogress", "CompactionJob::Run():End"},
       {"CompactionJob::Run():End",
11641
        "DBTest::PreShutdownCompactionMiddle:VerifyPreshutdown"}});
11642 11643 11644 11645 11646 11647 11648

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  // Make rocksdb busy
  int key = 0;
  // check how many threads are doing compaction using GetThreadList
  int operation_count[ThreadStatus::NUM_OP_TYPES] = {0};
11649
  for (int file = 0; file < 16 * kNumL0Files; ++file) {
11650 11651 11652 11653 11654 11655 11656 11657 11658 11659
    for (int k = 0; k < kEntriesPerBuffer; ++k) {
      ASSERT_OK(Put(ToString(key++), RandomString(&rnd, kTestValueSize)));
    }

    Status s = env_->GetThreadList(&thread_list);
    for (auto thread : thread_list) {
      operation_count[thread.operation_type]++;
    }

    // Speed up the test
11660 11661
    if (operation_count[ThreadStatus::OP_FLUSH] > 1 &&
        operation_count[ThreadStatus::OP_COMPACTION] >
11662 11663 11664
            0.6 * options.max_background_compactions) {
      break;
    }
11665 11666 11667
    if (file == 15 * kNumL0Files) {
      TEST_SYNC_POINT("DBTest::PreShutdownCompactionMiddle:VerifyCompaction");
    }
11668 11669
  }

11670
  ASSERT_GE(operation_count[ThreadStatus::OP_COMPACTION], 1);
11671
  CancelAllBackgroundWork(db_);
11672 11673
  TEST_SYNC_POINT("DBTest::PreShutdownCompactionMiddle:Preshutdown");
  TEST_SYNC_POINT("DBTest::PreShutdownCompactionMiddle:VerifyPreshutdown");
11674 11675 11676 11677 11678 11679 11680 11681 11682 11683 11684 11685
  dbfull()->TEST_WaitForCompact();
  // Record the number of compactions at a time.
  for (int i = 0; i < ThreadStatus::NUM_OP_TYPES; ++i) {
    operation_count[i] = 0;
  }
  Status s = env_->GetThreadList(&thread_list);
  for (auto thread : thread_list) {
    operation_count[thread.operation_type]++;
  }
  ASSERT_EQ(operation_count[ThreadStatus::OP_COMPACTION], 0);
}

Y
Yueh-Hsuan Chiang 已提交
11686 11687
#endif  // ROCKSDB_USING_THREAD_STATUS

11688 11689 11690 11691 11692 11693 11694
TEST_F(DBTest, FlushOnDestroy) {
  WriteOptions wo;
  wo.disableWAL = true;
  ASSERT_OK(Put("foo", "v1", wo));
  CancelAllBackgroundWork(db_);
}

I
Igor Sugak 已提交
11695
TEST_F(DBTest, DynamicLevelMaxBytesBase) {
11696 11697 11698
  if (!Snappy_Supported() || !LZ4_Supported()) {
    return;
  }
11699 11700 11701 11702 11703 11704 11705 11706 11707 11708 11709 11710 11711 11712 11713 11714 11715 11716 11717 11718 11719 11720 11721 11722 11723 11724 11725 11726 11727 11728 11729 11730 11731 11732 11733 11734 11735 11736 11737 11738 11739
  // Use InMemoryEnv, or it would be too slow.
  unique_ptr<Env> env(new MockEnv(env_));

  const int kNKeys = 1000;
  int keys[kNKeys];

  auto verify_func = [&]() {
    for (int i = 0; i < kNKeys; i++) {
      ASSERT_NE("NOT_FOUND", Get(Key(i)));
      ASSERT_NE("NOT_FOUND", Get(Key(kNKeys * 2 + i)));
      if (i < kNKeys / 10) {
        ASSERT_EQ("NOT_FOUND", Get(Key(kNKeys + keys[i])));
      } else {
        ASSERT_NE("NOT_FOUND", Get(Key(kNKeys + keys[i])));
      }
    }
  };

  Random rnd(301);
  for (int ordered_insert = 0; ordered_insert <= 1; ordered_insert++) {
    for (int i = 0; i < kNKeys; i++) {
      keys[i] = i;
    }
    if (ordered_insert == 0) {
      std::random_shuffle(std::begin(keys), std::end(keys));
    }
    for (int max_background_compactions = 1; max_background_compactions < 4;
         max_background_compactions += 2) {
      Options options;
      options.env = env.get();
      options.create_if_missing = true;
      options.db_write_buffer_size = 2048;
      options.write_buffer_size = 2048;
      options.max_write_buffer_number = 2;
      options.level0_file_num_compaction_trigger = 2;
      options.level0_slowdown_writes_trigger = 2;
      options.level0_stop_writes_trigger = 2;
      options.target_file_size_base = 2048;
      options.level_compaction_dynamic_level_bytes = true;
      options.max_bytes_for_level_base = 10240;
      options.max_bytes_for_level_multiplier = 4;
S
sdong 已提交
11740
      options.soft_rate_limit = 1.1;
11741 11742 11743
      options.max_background_compactions = max_background_compactions;
      options.num_levels = 5;

11744 11745 11746 11747 11748
      options.compression_per_level.resize(3);
      options.compression_per_level[0] = kNoCompression;
      options.compression_per_level[1] = kLZ4Compression;
      options.compression_per_level[2] = kSnappyCompression;

11749 11750 11751 11752 11753 11754 11755 11756 11757 11758 11759 11760 11761 11762 11763 11764 11765 11766 11767 11768 11769 11770 11771 11772
      DestroyAndReopen(options);

      for (int i = 0; i < kNKeys; i++) {
        int key = keys[i];
        ASSERT_OK(Put(Key(kNKeys + key), RandomString(&rnd, 102)));
        ASSERT_OK(Put(Key(key), RandomString(&rnd, 102)));
        ASSERT_OK(Put(Key(kNKeys * 2 + key), RandomString(&rnd, 102)));
        ASSERT_OK(Delete(Key(kNKeys + keys[i / 10])));
        env_->SleepForMicroseconds(5000);
      }

      uint64_t int_prop;
      ASSERT_TRUE(db_->GetIntProperty("rocksdb.background-errors", &int_prop));
      ASSERT_EQ(0U, int_prop);

      // Verify DB
      for (int j = 0; j < 2; j++) {
        verify_func();
        if (j == 0) {
          Reopen(options);
        }
      }

      // Test compact range works
11773
      dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
11774 11775 11776 11777 11778 11779 11780 11781 11782 11783 11784 11785 11786 11787 11788 11789 11790 11791 11792
      // All data should be in the last level.
      ColumnFamilyMetaData cf_meta;
      db_->GetColumnFamilyMetaData(&cf_meta);
      ASSERT_EQ(5U, cf_meta.levels.size());
      for (int i = 0; i < 4; i++) {
        ASSERT_EQ(0U, cf_meta.levels[i].files.size());
      }
      ASSERT_GT(cf_meta.levels[4U].files.size(), 0U);
      verify_func();

      Close();
    }
  }

  env_->SetBackgroundThreads(1, Env::LOW);
  env_->SetBackgroundThreads(1, Env::HIGH);
}

// Test specific cases in dynamic max bytes
I
Igor Sugak 已提交
11793
TEST_F(DBTest, DynamicLevelMaxBytesBase2) {
11794 11795 11796 11797 11798 11799 11800 11801 11802 11803 11804 11805 11806 11807 11808 11809 11810 11811 11812 11813 11814 11815 11816 11817 11818 11819 11820 11821 11822 11823 11824 11825 11826 11827 11828 11829 11830 11831 11832 11833 11834 11835 11836 11837 11838 11839 11840 11841 11842 11843 11844 11845 11846 11847 11848 11849 11850 11851 11852 11853 11854 11855 11856 11857
  Random rnd(301);
  int kMaxKey = 1000000;

  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.db_write_buffer_size = 2048;
  options.write_buffer_size = 2048;
  options.max_write_buffer_number = 2;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 9999;
  options.level0_stop_writes_trigger = 9999;
  options.target_file_size_base = 2048;
  options.level_compaction_dynamic_level_bytes = true;
  options.max_bytes_for_level_base = 10240;
  options.max_bytes_for_level_multiplier = 4;
  options.max_background_compactions = 2;
  options.num_levels = 5;
  options.expanded_compaction_factor = 0;  // Force not expanding in compactions
  BlockBasedTableOptions table_options;
  table_options.block_size = 1024;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  DestroyAndReopen(options);
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "true"},
  }));

  uint64_t int_prop;
  std::string str_prop;

  // Initial base level is the last level
  ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
  ASSERT_EQ(4U, int_prop);

  // Put about 7K to L0
  for (int i = 0; i < 70; i++) {
    ASSERT_OK(Put(Key(static_cast<int>(rnd.Uniform(kMaxKey))),
                  RandomString(&rnd, 80)));
  }
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "false"},
  }));
  Flush();
  dbfull()->TEST_WaitForCompact();
  ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
  ASSERT_EQ(4U, int_prop);

  // Insert extra about 3.5K to L0. After they are compacted to L4, base level
  // should be changed to L3.
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "true"},
  }));
  for (int i = 0; i < 70; i++) {
    ASSERT_OK(Put(Key(static_cast<int>(rnd.Uniform(kMaxKey))),
                  RandomString(&rnd, 80)));
  }

  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "false"},
  }));
  Flush();
  dbfull()->TEST_WaitForCompact();
  ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
  ASSERT_EQ(3U, int_prop);
11858 11859 11860
  ASSERT_TRUE(db_->GetProperty("rocksdb.num-files-at-level1", &str_prop));
  ASSERT_EQ("0", str_prop);
  ASSERT_TRUE(db_->GetProperty("rocksdb.num-files-at-level2", &str_prop));
11861 11862 11863 11864 11865 11866
  ASSERT_EQ("0", str_prop);

  // Trigger parallel compaction, and the first one would change the base
  // level.
  // Hold compaction jobs to make sure
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
11867
      "CompactionJob::Run():Start",
11868
      [&](void* arg) { env_->SleepForMicroseconds(100000); });
11869 11870 11871 11872 11873 11874 11875 11876 11877 11878 11879 11880 11881 11882 11883 11884 11885 11886 11887 11888 11889 11890 11891 11892 11893 11894 11895 11896 11897 11898 11899 11900 11901 11902 11903 11904 11905 11906 11907 11908 11909 11910 11911 11912 11913 11914 11915 11916 11917 11918 11919 11920 11921 11922 11923 11924 11925 11926 11927 11928 11929 11930 11931 11932 11933 11934 11935 11936 11937
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "true"},
  }));
  // Write about 10K more
  for (int i = 0; i < 100; i++) {
    ASSERT_OK(Put(Key(static_cast<int>(rnd.Uniform(kMaxKey))),
                  RandomString(&rnd, 80)));
  }
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "false"},
  }));
  Flush();
  // Wait for 200 milliseconds before proceeding compactions to make sure two
  // parallel ones are executed.
  env_->SleepForMicroseconds(200000);
  dbfull()->TEST_WaitForCompact();
  ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
  ASSERT_EQ(3U, int_prop);
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();

  // Trigger a condition that the compaction changes base level and L0->Lbase
  // happens at the same time.
  // We try to make last levels' targets to be 10K, 40K, 160K, add triggers
  // another compaction from 40K->160K.
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "true"},
  }));
  // Write about 150K more
  for (int i = 0; i < 1350; i++) {
    ASSERT_OK(Put(Key(static_cast<int>(rnd.Uniform(kMaxKey))),
                  RandomString(&rnd, 80)));
  }
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "false"},
  }));
  Flush();
  dbfull()->TEST_WaitForCompact();
  ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
  ASSERT_EQ(2U, int_prop);

  // Keep Writing data until base level changed 2->1. There will be L0->L2
  // compaction going on at the same time.
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
  for (int attempt = 0; attempt <= 20; attempt++) {
    // Write about 5K more data with two flushes. It should be flush to level 2
    // but when it is applied, base level is already 1.
    for (int i = 0; i < 50; i++) {
      ASSERT_OK(Put(Key(static_cast<int>(rnd.Uniform(kMaxKey))),
                    RandomString(&rnd, 80)));
    }
    Flush();

    ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
    if (int_prop == 2U) {
      env_->SleepForMicroseconds(50000);
    } else {
      break;
    }
  }
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();

  env_->SleepForMicroseconds(200000);

  ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
  ASSERT_EQ(1U, int_prop);
}

11938 11939 11940 11941 11942 11943 11944 11945 11946 11947 11948 11949 11950 11951 11952 11953 11954 11955 11956 11957 11958 11959 11960 11961 11962 11963 11964 11965
// Test specific cases in dynamic max bytes
TEST_F(DBTest, DynamicLevelMaxBytesCompactRange) {
  Random rnd(301);
  int kMaxKey = 1000000;

  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.db_write_buffer_size = 2048;
  options.write_buffer_size = 2048;
  options.max_write_buffer_number = 2;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 9999;
  options.level0_stop_writes_trigger = 9999;
  options.target_file_size_base = 2;
  options.level_compaction_dynamic_level_bytes = true;
  options.max_bytes_for_level_base = 10240;
  options.max_bytes_for_level_multiplier = 4;
  options.max_background_compactions = 1;
  const int kNumLevels = 5;
  options.num_levels = kNumLevels;
  options.expanded_compaction_factor = 0;  // Force not expanding in compactions
  BlockBasedTableOptions table_options;
  table_options.block_size = 1024;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));

  DestroyAndReopen(options);

  // Compact against empty DB
11966
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
11967 11968 11969 11970 11971 11972 11973 11974 11975 11976 11977 11978 11979 11980 11981

  uint64_t int_prop;
  std::string str_prop;

  // Initial base level is the last level
  ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
  ASSERT_EQ(4U, int_prop);

  // Put about 7K to L0
  for (int i = 0; i < 140; i++) {
    ASSERT_OK(Put(Key(static_cast<int>(rnd.Uniform(kMaxKey))),
                  RandomString(&rnd, 80)));
  }
  Flush();
  dbfull()->TEST_WaitForCompact();
11982 11983 11984 11985 11986 11987
  if (NumTableFilesAtLevel(0) == 0) {
    // Make sure level 0 is not empty
    ASSERT_OK(Put(Key(static_cast<int>(rnd.Uniform(kMaxKey))),
                  RandomString(&rnd, 80)));
    Flush();
  }
11988 11989 11990 11991 11992 11993 11994 11995 11996 11997 11998 11999 12000 12001 12002 12003 12004 12005 12006

  ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
  ASSERT_EQ(3U, int_prop);
  ASSERT_TRUE(db_->GetProperty("rocksdb.num-files-at-level1", &str_prop));
  ASSERT_EQ("0", str_prop);
  ASSERT_TRUE(db_->GetProperty("rocksdb.num-files-at-level2", &str_prop));
  ASSERT_EQ("0", str_prop);

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();

  std::set<int> output_levels;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "CompactionPicker::CompactRange:Return", [&](void* arg) {
        Compaction* compaction = reinterpret_cast<Compaction*>(arg);
        output_levels.insert(compaction->output_level());
      });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

12007
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
12008 12009 12010 12011 12012 12013 12014 12015 12016 12017 12018 12019
  ASSERT_EQ(output_levels.size(), 2);
  ASSERT_TRUE(output_levels.find(3) != output_levels.end());
  ASSERT_TRUE(output_levels.find(4) != output_levels.end());
  ASSERT_TRUE(db_->GetProperty("rocksdb.num-files-at-level0", &str_prop));
  ASSERT_EQ("0", str_prop);
  ASSERT_TRUE(db_->GetProperty("rocksdb.num-files-at-level3", &str_prop));
  ASSERT_EQ("0", str_prop);
  // Base level is still level 3.
  ASSERT_TRUE(db_->GetIntProperty("rocksdb.base-level", &int_prop));
  ASSERT_EQ(3U, int_prop);
}

12020 12021 12022 12023 12024 12025 12026 12027 12028 12029 12030 12031 12032
TEST_F(DBTest, DynamicLevelMaxBytesBaseInc) {
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.db_write_buffer_size = 2048;
  options.write_buffer_size = 2048;
  options.max_write_buffer_number = 2;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 2;
  options.target_file_size_base = 2048;
  options.level_compaction_dynamic_level_bytes = true;
  options.max_bytes_for_level_base = 10240;
  options.max_bytes_for_level_multiplier = 4;
S
sdong 已提交
12033
  options.soft_rate_limit = 1.1;
12034 12035 12036 12037 12038 12039 12040
  options.max_background_compactions = 2;
  options.num_levels = 5;

  DestroyAndReopen(options);

  int non_trivial = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
12041 12042
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial++; });
12043 12044 12045
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Random rnd(301);
S
sdong 已提交
12046 12047 12048 12049 12050 12051
  const int total_keys = 3000;
  const int random_part_size = 100;
  for (int i = 0; i < total_keys; i++) {
    std::string value = RandomString(&rnd, random_part_size);
    PutFixed32(&value, static_cast<uint32_t>(i));
    ASSERT_OK(Put(Key(i), value));
12052 12053 12054 12055 12056 12057 12058
  }
  Flush();
  dbfull()->TEST_WaitForCompact();
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();

  ASSERT_EQ(non_trivial, 0);

S
sdong 已提交
12059 12060 12061 12062 12063 12064
  for (int i = 0; i < total_keys; i++) {
    std::string value = Get(Key(i));
    ASSERT_EQ(DecodeFixed32(value.c_str() + random_part_size),
              static_cast<uint32_t>(i));
  }

12065 12066 12067 12068
  env_->SetBackgroundThreads(1, Env::LOW);
  env_->SetBackgroundThreads(1, Env::HIGH);
}

12069 12070 12071 12072 12073 12074 12075 12076 12077 12078 12079 12080 12081 12082 12083 12084
TEST_F(DBTest, MigrateToDynamicLevelMaxBytesBase) {
  Random rnd(301);
  const int kMaxKey = 2000;

  Options options;
  options.create_if_missing = true;
  options.db_write_buffer_size = 2048;
  options.write_buffer_size = 2048;
  options.max_write_buffer_number = 8;
  options.level0_file_num_compaction_trigger = 4;
  options.level0_slowdown_writes_trigger = 4;
  options.level0_stop_writes_trigger = 8;
  options.target_file_size_base = 2048;
  options.level_compaction_dynamic_level_bytes = false;
  options.max_bytes_for_level_base = 10240;
  options.max_bytes_for_level_multiplier = 4;
S
sdong 已提交
12085
  options.soft_rate_limit = 1.1;
12086 12087 12088 12089
  options.num_levels = 8;

  DestroyAndReopen(options);

12090
  auto verify_func = [&](int num_keys, bool if_sleep) {
12091 12092 12093 12094 12095 12096 12097
    for (int i = 0; i < num_keys; i++) {
      ASSERT_NE("NOT_FOUND", Get(Key(kMaxKey + i)));
      if (i < num_keys / 10) {
        ASSERT_EQ("NOT_FOUND", Get(Key(i)));
      } else {
        ASSERT_NE("NOT_FOUND", Get(Key(i)));
      }
12098 12099 12100 12101 12102 12103
      if (if_sleep && i % 1000 == 0) {
        // Without it, valgrind may choose not to give another
        // thread a chance to run before finishing the function,
        // causing the test to be extremely slow.
        env_->SleepForMicroseconds(1);
      }
12104 12105 12106 12107 12108 12109 12110 12111 12112
    }
  };

  int total_keys = 1000;
  for (int i = 0; i < total_keys; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 102)));
    ASSERT_OK(Put(Key(kMaxKey + i), RandomString(&rnd, 102)));
    ASSERT_OK(Delete(Key(i / 10)));
  }
12113
  verify_func(total_keys, false);
12114 12115 12116 12117 12118
  dbfull()->TEST_WaitForCompact();

  options.level_compaction_dynamic_level_bytes = true;
  options.disable_auto_compactions = true;
  Reopen(options);
12119
  verify_func(total_keys, false);
12120

D
Dmitri Smirnov 已提交
12121 12122
  std::atomic_bool compaction_finished;
  compaction_finished = false;
12123 12124 12125
  // Issue manual compaction in one thread and still verify DB state
  // in main thread.
  std::thread t([&]() {
12126 12127 12128 12129
    CompactRangeOptions compact_options;
    compact_options.change_level = true;
    compact_options.target_level = options.num_levels - 1;
    dbfull()->CompactRange(compact_options, nullptr, nullptr);
12130 12131 12132
    compaction_finished.store(true);
  });
  do {
12133
    verify_func(total_keys, true);
12134 12135 12136 12137 12138 12139 12140 12141 12142 12143 12144 12145 12146 12147
  } while (!compaction_finished.load());
  t.join();

  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "false"},
  }));

  int total_keys2 = 2000;
  for (int i = total_keys; i < total_keys2; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 102)));
    ASSERT_OK(Put(Key(kMaxKey + i), RandomString(&rnd, 102)));
    ASSERT_OK(Delete(Key(i / 10)));
  }

12148
  verify_func(total_keys2, false);
12149
  dbfull()->TEST_WaitForCompact();
12150
  verify_func(total_keys2, false);
12151 12152 12153 12154 12155

  // Base level is not level 1
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
}
12156

12157 12158 12159 12160 12161 12162 12163 12164 12165 12166 12167 12168 12169 12170 12171 12172 12173 12174 12175 12176 12177 12178 12179 12180 12181 12182 12183 12184 12185 12186 12187 12188
namespace {
class OnFileDeletionListener : public EventListener {
 public:
  OnFileDeletionListener() :
      matched_count_(0),
      expected_file_name_("") {}

  void SetExpectedFileName(
      const std::string file_name) {
    expected_file_name_ = file_name;
  }

  void VerifyMatchedCount(size_t expected_value) {
    ASSERT_EQ(matched_count_, expected_value);
  }

  void OnTableFileDeleted(
      const TableFileDeletionInfo& info) override {
    if (expected_file_name_ != "") {
      ASSERT_EQ(expected_file_name_, info.file_path);
      expected_file_name_ = "";
      matched_count_++;
    }
  }

 private:
  size_t matched_count_;
  std::string expected_file_name_;
};

}  // namespace

I
Igor Sugak 已提交
12189
TEST_F(DBTest, DynamicLevelCompressionPerLevel) {
I
Igor Canadi 已提交
12190
  if (!Snappy_Supported()) {
12191 12192
    return;
  }
12193 12194 12195 12196 12197 12198 12199 12200 12201 12202 12203 12204 12205 12206 12207 12208 12209 12210 12211 12212 12213 12214 12215 12216 12217 12218 12219 12220
  const int kNKeys = 120;
  int keys[kNKeys];
  for (int i = 0; i < kNKeys; i++) {
    keys[i] = i;
  }
  std::random_shuffle(std::begin(keys), std::end(keys));

  Random rnd(301);
  Options options;
  options.create_if_missing = true;
  options.db_write_buffer_size = 20480;
  options.write_buffer_size = 20480;
  options.max_write_buffer_number = 2;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 2;
  options.target_file_size_base = 2048;
  options.level_compaction_dynamic_level_bytes = true;
  options.max_bytes_for_level_base = 102400;
  options.max_bytes_for_level_multiplier = 4;
  options.max_background_compactions = 1;
  options.num_levels = 5;

  options.compression_per_level.resize(3);
  options.compression_per_level[0] = kNoCompression;
  options.compression_per_level[1] = kNoCompression;
  options.compression_per_level[2] = kSnappyCompression;

12221 12222 12223
  OnFileDeletionListener* listener = new OnFileDeletionListener();
  options.listeners.emplace_back(listener);

12224 12225 12226 12227 12228 12229 12230 12231 12232 12233 12234 12235 12236 12237 12238 12239 12240 12241 12242 12243 12244 12245 12246 12247 12248 12249 12250 12251 12252 12253 12254 12255
  DestroyAndReopen(options);

  // Insert more than 80K. L4 should be base level. Neither L0 nor L4 should
  // be compressed, so total data size should be more than 80K.
  for (int i = 0; i < 20; i++) {
    ASSERT_OK(Put(Key(keys[i]), CompressibleString(&rnd, 4000)));
  }
  Flush();
  dbfull()->TEST_WaitForCompact();

  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
  ASSERT_EQ(NumTableFilesAtLevel(3), 0);
  ASSERT_GT(SizeAtLevel(0) + SizeAtLevel(4), 20U * 4000U);

  // Insert 400KB. Some data will be compressed
  for (int i = 21; i < 120; i++) {
    ASSERT_OK(Put(Key(keys[i]), CompressibleString(&rnd, 4000)));
  }
  Flush();
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
  ASSERT_LT(SizeAtLevel(0) + SizeAtLevel(3) + SizeAtLevel(4), 120U * 4000U);
  // Make sure data in files in L3 is not compacted by removing all files
  // in L4 and calculate number of rows
  ASSERT_OK(dbfull()->SetOptions({
      {"disable_auto_compactions", "true"},
  }));
  ColumnFamilyMetaData cf_meta;
  db_->GetColumnFamilyMetaData(&cf_meta);
  for (auto file : cf_meta.levels[4].files) {
12256
    listener->SetExpectedFileName(dbname_ + file.name);
12257 12258
    ASSERT_OK(dbfull()->DeleteFile(file.name));
  }
12259 12260
  listener->VerifyMatchedCount(cf_meta.levels[4].files.size());

12261 12262 12263 12264 12265 12266 12267 12268 12269
  int num_keys = 0;
  std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    num_keys++;
  }
  ASSERT_OK(iter->status());
  ASSERT_GT(SizeAtLevel(0) + SizeAtLevel(3), num_keys * 4000U);
}

I
Igor Sugak 已提交
12270
TEST_F(DBTest, DynamicLevelCompressionPerLevel2) {
12271 12272 12273
  if (!Snappy_Supported() || !LZ4_Supported() || !Zlib_Supported()) {
    return;
  }
12274 12275 12276 12277 12278 12279 12280 12281 12282 12283 12284 12285 12286 12287 12288 12289
  const int kNKeys = 500;
  int keys[kNKeys];
  for (int i = 0; i < kNKeys; i++) {
    keys[i] = i;
  }
  std::random_shuffle(std::begin(keys), std::end(keys));

  Random rnd(301);
  Options options;
  options.create_if_missing = true;
  options.db_write_buffer_size = 6000;
  options.write_buffer_size = 6000;
  options.max_write_buffer_number = 2;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 2;
S
sdong 已提交
12290
  options.soft_rate_limit = 1.1;
12291 12292 12293 12294 12295 12296 12297 12298 12299 12300 12301 12302 12303 12304 12305 12306 12307 12308 12309 12310 12311 12312

  // Use file size to distinguish levels
  // L1: 10, L2: 20, L3 40, L4 80
  // L0 is less than 30
  options.target_file_size_base = 10;
  options.target_file_size_multiplier = 2;

  options.level_compaction_dynamic_level_bytes = true;
  options.max_bytes_for_level_base = 200;
  options.max_bytes_for_level_multiplier = 8;
  options.max_background_compactions = 1;
  options.num_levels = 5;
  std::shared_ptr<mock::MockTableFactory> mtf(new mock::MockTableFactory);
  options.table_factory = mtf;

  options.compression_per_level.resize(3);
  options.compression_per_level[0] = kNoCompression;
  options.compression_per_level[1] = kLZ4Compression;
  options.compression_per_level[2] = kZlibCompression;

  DestroyAndReopen(options);
  // When base level is L4, L4 is LZ4.
12313 12314 12315
  std::atomic<int> num_zlib(0);
  std::atomic<int> num_lz4(0);
  std::atomic<int> num_no(0);
12316 12317 12318 12319
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
        Compaction* compaction = reinterpret_cast<Compaction*>(arg);
        if (compaction->output_level() == 4) {
12320
          ASSERT_TRUE(compaction->output_compression() == kLZ4Compression);
12321
          num_lz4.fetch_add(1);
12322 12323
        }
      });
12324 12325 12326 12327 12328 12329
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "FlushJob::WriteLevel0Table:output_compression", [&](void* arg) {
        auto* compression = reinterpret_cast<CompressionType*>(arg);
        ASSERT_TRUE(*compression == kNoCompression);
        num_no.fetch_add(1);
      });
12330 12331
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

12332 12333 12334 12335 12336
  for (int i = 0; i < 100; i++) {
    ASSERT_OK(Put(Key(keys[i]), RandomString(&rnd, 200)));
  }
  Flush();
  dbfull()->TEST_WaitForCompact();
12337 12338
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
12339 12340 12341 12342

  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
  ASSERT_EQ(NumTableFilesAtLevel(3), 0);
12343
  ASSERT_GT(NumTableFilesAtLevel(4), 0);
12344 12345
  ASSERT_GT(num_no.load(), 2);
  ASSERT_GT(num_lz4.load(), 0);
12346
  int prev_num_files_l4 = NumTableFilesAtLevel(4);
12347 12348

  // After base level turn L4->L3, L3 becomes LZ4 and L4 becomes Zlib
12349 12350
  num_lz4.store(0);
  num_no.store(0);
12351 12352 12353 12354
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
        Compaction* compaction = reinterpret_cast<Compaction*>(arg);
        if (compaction->output_level() == 4 && compaction->start_level() == 3) {
12355
          ASSERT_TRUE(compaction->output_compression() == kZlibCompression);
12356
          num_zlib.fetch_add(1);
12357
        } else {
12358
          ASSERT_TRUE(compaction->output_compression() == kLZ4Compression);
12359
          num_lz4.fetch_add(1);
12360 12361
        }
      });
12362 12363 12364 12365 12366 12367 12368
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "FlushJob::WriteLevel0Table:output_compression", [&](void* arg) {
        auto* compression = reinterpret_cast<CompressionType*>(arg);
        ASSERT_TRUE(*compression == kNoCompression);
        num_no.fetch_add(1);
      });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
12369

12370 12371 12372 12373 12374 12375 12376
  for (int i = 101; i < 500; i++) {
    ASSERT_OK(Put(Key(keys[i]), RandomString(&rnd, 200)));
    if (i % 100 == 99) {
      Flush();
      dbfull()->TEST_WaitForCompact();
    }
  }
12377 12378 12379

  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
12380 12381
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
12382 12383
  ASSERT_GT(NumTableFilesAtLevel(3), 0);
  ASSERT_GT(NumTableFilesAtLevel(4), prev_num_files_l4);
12384 12385 12386
  ASSERT_GT(num_no.load(), 2);
  ASSERT_GT(num_lz4.load(), 0);
  ASSERT_GT(num_zlib.load(), 0);
12387 12388
}

I
Igor Sugak 已提交
12389
TEST_F(DBTest, DynamicCompactionOptions) {
12390 12391
  // minimum write buffer size is enforced at 64KB
  const uint64_t k32KB = 1 << 15;
12392 12393
  const uint64_t k64KB = 1 << 16;
  const uint64_t k128KB = 1 << 17;
12394
  const uint64_t k1MB = 1 << 20;
12395
  const uint64_t k4KB = 1 << 12;
12396 12397 12398 12399
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.compression = kNoCompression;
S
sdong 已提交
12400
  options.soft_rate_limit = 1.1;
12401
  options.write_buffer_size = k64KB;
12402 12403 12404
  options.max_write_buffer_number = 2;
  // Compaction related options
  options.level0_file_num_compaction_trigger = 3;
L
Lei Jin 已提交
12405 12406
  options.level0_slowdown_writes_trigger = 4;
  options.level0_stop_writes_trigger = 8;
12407 12408 12409
  options.max_grandparent_overlap_factor = 10;
  options.expanded_compaction_factor = 25;
  options.source_compaction_factor = 1;
12410
  options.target_file_size_base = k64KB;
12411
  options.target_file_size_multiplier = 1;
12412
  options.max_bytes_for_level_base = k128KB;
12413
  options.max_bytes_for_level_multiplier = 4;
L
Lei Jin 已提交
12414 12415 12416 12417

  // Block flush thread and disable compaction thread
  env_->SetBackgroundThreads(1, Env::LOW);
  env_->SetBackgroundThreads(1, Env::HIGH);
L
Lei Jin 已提交
12418
  DestroyAndReopen(options);
12419

12420
  auto gen_l0_kb = [this](int start, int size, int stride) {
12421 12422
    Random rnd(301);
    for (int i = 0; i < size; i++) {
L
Lei Jin 已提交
12423
      ASSERT_OK(Put(Key(start + stride * i), RandomString(&rnd, 1024)));
12424 12425 12426 12427
    }
    dbfull()->TEST_WaitForFlushMemTable();
  };

12428 12429 12430
  // Write 3 files that have the same key range.
  // Since level0_file_num_compaction_trigger is 3, compaction should be
  // triggered. The compaction should result in one L1 file
12431
  gen_l0_kb(0, 64, 1);
12432
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
12433
  gen_l0_kb(0, 64, 1);
12434
  ASSERT_EQ(NumTableFilesAtLevel(0), 2);
12435
  gen_l0_kb(0, 64, 1);
12436 12437 12438 12439
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ("0,1", FilesPerLevel());
  std::vector<LiveFileMetaData> metadata;
  db_->GetLiveFilesMetaData(&metadata);
12440
  ASSERT_EQ(1U, metadata.size());
12441 12442
  ASSERT_LE(metadata[0].size, k64KB + k4KB);
  ASSERT_GE(metadata[0].size, k64KB - k4KB);
12443

12444
  // Test compaction trigger and target_file_size_base
12445 12446 12447 12448
  // Reduce compaction trigger to 2, and reduce L1 file size to 32KB.
  // Writing to 64KB L0 files should trigger a compaction. Since these
  // 2 L0 files have the same key range, compaction merge them and should
  // result in 2 32KB L1 files.
12449
  ASSERT_OK(dbfull()->SetOptions({
12450
    {"level0_file_num_compaction_trigger", "2"},
12451
    {"target_file_size_base", ToString(k32KB) }
12452 12453
  }));

12454
  gen_l0_kb(0, 64, 1);
12455
  ASSERT_EQ("1,1", FilesPerLevel());
12456
  gen_l0_kb(0, 64, 1);
12457 12458 12459 12460
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ("0,2", FilesPerLevel());
  metadata.clear();
  db_->GetLiveFilesMetaData(&metadata);
12461
  ASSERT_EQ(2U, metadata.size());
12462 12463
  ASSERT_LE(metadata[0].size, k32KB + k4KB);
  ASSERT_GE(metadata[0].size, k32KB - k4KB);
12464 12465
  ASSERT_LE(metadata[1].size, k32KB + k4KB);
  ASSERT_GE(metadata[1].size, k32KB - k4KB);
12466

12467
  // Test max_bytes_for_level_base
12468 12469 12470
  // Increase level base size to 256KB and write enough data that will
  // fill L1 and L2. L1 size should be around 256KB while L2 size should be
  // around 256KB x 4.
12471
  ASSERT_OK(dbfull()->SetOptions({
12472
    {"max_bytes_for_level_base", ToString(k1MB) }
12473
  }));
12474

12475 12476 12477 12478
  // writing 96 x 64KB => 6 * 1024KB
  // (L1 + L2) = (1 + 4) * 1024KB
  for (int i = 0; i < 96; ++i) {
    gen_l0_kb(i, 64, 96);
12479 12480
  }
  dbfull()->TEST_WaitForCompact();
12481 12482 12483 12484 12485 12486
  ASSERT_GT(SizeAtLevel(1), k1MB / 2);
  ASSERT_LT(SizeAtLevel(1), k1MB + k1MB / 2);

  // Within (0.5, 1.5) of 4MB.
  ASSERT_GT(SizeAtLevel(2), 2 * k1MB);
  ASSERT_LT(SizeAtLevel(2), 6 * k1MB);
12487

12488
  // Test max_bytes_for_level_multiplier and
12489 12490 12491
  // max_bytes_for_level_base. Now, reduce both mulitplier and level base,
  // After filling enough data that can fit in L1 - L3, we should see L1 size
  // reduces to 128KB from 256KB which was asserted previously. Same for L2.
12492
  ASSERT_OK(dbfull()->SetOptions({
12493
    {"max_bytes_for_level_multiplier", "2"},
12494
    {"max_bytes_for_level_base", ToString(k128KB) }
12495 12496
  }));

12497 12498 12499 12500
  // writing 20 x 64KB = 10 x 128KB
  // (L1 + L2 + L3) = (1 + 2 + 4) * 128KB
  for (int i = 0; i < 20; ++i) {
    gen_l0_kb(i, 64, 32);
12501 12502
  }
  dbfull()->TEST_WaitForCompact();
12503 12504 12505
  uint64_t total_size =
    SizeAtLevel(1) + SizeAtLevel(2) + SizeAtLevel(3);
  ASSERT_TRUE(total_size < k128KB * 7 * 1.5);
L
Lei Jin 已提交
12506

12507 12508 12509 12510
  // Test level0_stop_writes_trigger.
  // Clean up memtable and L0. Block compaction threads. If continue to write
  // and flush memtables. We should see put timeout after 8 memtable flushes
  // since level0_stop_writes_trigger = 8
12511
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
12512 12513 12514 12515 12516 12517 12518 12519 12520 12521 12522 12523 12524
  // Block compaction
  SleepingBackgroundTask sleeping_task_low1;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low1,
                 Env::Priority::LOW);
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  int count = 0;
  Random rnd(301);
  WriteOptions wo;
  wo.timeout_hint_us = 10000;
  while (Put(Key(count), RandomString(&rnd, 1024), wo).ok() && count < 64) {
    dbfull()->TEST_FlushMemTable(true);
    count++;
  }
12525
  // Stop trigger = 8
L
Lei Jin 已提交
12526 12527 12528 12529 12530
  ASSERT_EQ(count, 8);
  // Unblock
  sleeping_task_low1.WakeUp();
  sleeping_task_low1.WaitUntilDone();

12531 12532 12533
  // Now reduce level0_stop_writes_trigger to 6. Clear up memtables and L0.
  // Block compaction thread again. Perform the put and memtable flushes
  // until we see timeout after 6 memtable flushes.
12534
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
12535 12536
    {"level0_stop_writes_trigger", "6"}
  }));
12537
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
12538 12539 12540 12541 12542 12543 12544 12545 12546 12547 12548 12549 12550 12551 12552 12553 12554
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

  // Block compaction
  SleepingBackgroundTask sleeping_task_low2;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low2,
                 Env::Priority::LOW);
  count = 0;
  while (Put(Key(count), RandomString(&rnd, 1024), wo).ok() && count < 64) {
    dbfull()->TEST_FlushMemTable(true);
    count++;
  }
  ASSERT_EQ(count, 6);
  // Unblock
  sleeping_task_low2.WakeUp();
  sleeping_task_low2.WaitUntilDone();

  // Test disable_auto_compactions
12555 12556 12557 12558
  // Compaction thread is unblocked but auto compaction is disabled. Write
  // 4 L0 files and compaction should be triggered. If auto compaction is
  // disabled, then TEST_WaitForCompact will be waiting for nothing. Number of
  // L0 files do not change after the call.
12559
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
12560 12561
    {"disable_auto_compactions", "true"}
  }));
12562
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
12563 12564 12565 12566 12567 12568 12569 12570 12571 12572
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

  for (int i = 0; i < 4; ++i) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
    // Wait for compaction so that put won't timeout
    dbfull()->TEST_FlushMemTable(true);
  }
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ(NumTableFilesAtLevel(0), 4);

12573 12574
  // Enable auto compaction and perform the same test, # of L0 files should be
  // reduced after compaction.
12575
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
12576 12577
    {"disable_auto_compactions", "false"}
  }));
12578
  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
L
Lei Jin 已提交
12579 12580 12581 12582 12583 12584 12585 12586 12587
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

  for (int i = 0; i < 4; ++i) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
    // Wait for compaction so that put won't timeout
    dbfull()->TEST_FlushMemTable(true);
  }
  dbfull()->TEST_WaitForCompact();
  ASSERT_LT(NumTableFilesAtLevel(0), 4);
12588

L
Lei Jin 已提交
12589
  // Test max_mem_compaction_level.
C
clark.kang 已提交
12590
  // Destroy DB and start from scratch
L
Lei Jin 已提交
12591 12592 12593
  options.max_background_compactions = 1;
  options.max_background_flushes = 0;
  options.max_mem_compaction_level = 2;
L
Lei Jin 已提交
12594
  DestroyAndReopen(options);
L
Lei Jin 已提交
12595 12596 12597 12598
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 0);

S
sdong 已提交
12599
  ASSERT_OK(Put("max_mem_compaction_level_key", RandomString(&rnd, 8)));
L
Lei Jin 已提交
12600 12601 12602 12603 12604 12605 12606 12607
  dbfull()->TEST_FlushMemTable(true);
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2), 1);

  ASSERT_TRUE(Put("max_mem_compaction_level_key",
              RandomString(&rnd, 8)).ok());
  // Set new value and it becomes effective in this flush
12608
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
12609 12610 12611 12612 12613 12614 12615 12616 12617 12618
    {"max_mem_compaction_level", "1"}
  }));
  dbfull()->TEST_FlushMemTable(true);
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_EQ(NumTableFilesAtLevel(2), 1);

  ASSERT_TRUE(Put("max_mem_compaction_level_key",
              RandomString(&rnd, 8)).ok());
  // Set new value and it becomes effective in this flush
12619
  ASSERT_OK(dbfull()->SetOptions({
L
Lei Jin 已提交
12620 12621 12622 12623 12624 12625
    {"max_mem_compaction_level", "0"}
  }));
  dbfull()->TEST_FlushMemTable(true);
  ASSERT_EQ(NumTableFilesAtLevel(0), 1);
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_EQ(NumTableFilesAtLevel(2), 1);
12626
}
12627

I
Igor Sugak 已提交
12628
TEST_F(DBTest, FileCreationRandomFailure) {
12629 12630 12631 12632 12633 12634 12635 12636
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.write_buffer_size = 100000;  // Small write buffer
  options.target_file_size_base = 200000;
  options.max_bytes_for_level_base = 1000000;
  options.max_bytes_for_level_multiplier = 2;

L
Lei Jin 已提交
12637
  DestroyAndReopen(options);
12638 12639 12640 12641 12642 12643 12644 12645 12646 12647 12648 12649 12650 12651 12652 12653 12654 12655 12656 12657 12658 12659 12660 12661 12662 12663 12664 12665 12666 12667 12668 12669 12670 12671 12672 12673 12674 12675 12676 12677 12678 12679
  Random rnd(301);

  const int kTestSize = kCDTKeysPerBuffer * 4096;
  const int kTotalIteration = 100;
  // the second half of the test involves in random failure
  // of file creation.
  const int kRandomFailureTest = kTotalIteration / 2;
  std::vector<std::string> values;
  for (int i = 0; i < kTestSize; ++i) {
    values.push_back("NOT_FOUND");
  }
  for (int j = 0; j < kTotalIteration; ++j) {
    if (j == kRandomFailureTest) {
      env_->non_writeable_rate_.store(90);
    }
    for (int k = 0; k < kTestSize; ++k) {
      // here we expect some of the Put fails.
      std::string value = RandomString(&rnd, 100);
      Status s = Put(Key(k), Slice(value));
      if (s.ok()) {
        // update the latest successful put
        values[k] = value;
      }
      // But everything before we simulate the failure-test should succeed.
      if (j < kRandomFailureTest) {
        ASSERT_OK(s);
      }
    }
  }

  // If rocksdb does not do the correct job, internal assert will fail here.
  dbfull()->TEST_WaitForFlushMemTable();
  dbfull()->TEST_WaitForCompact();

  // verify we have the latest successful update
  for (int k = 0; k < kTestSize; ++k) {
    auto v = Get(Key(k));
    ASSERT_EQ(v, values[k]);
  }

  // reopen and reverify we have the latest successful update
  env_->non_writeable_rate_.store(0);
L
Lei Jin 已提交
12680
  Reopen(options);
12681 12682 12683 12684 12685 12686
  for (int k = 0; k < kTestSize; ++k) {
    auto v = Get(Key(k));
    ASSERT_EQ(v, values[k]);
  }
}

I
Igor Sugak 已提交
12687
TEST_F(DBTest, PartialCompactionFailure) {
12688 12689 12690 12691 12692 12693 12694 12695 12696 12697 12698 12699 12700 12701 12702 12703 12704 12705
  Options options;
  const int kKeySize = 16;
  const int kKvSize = 1000;
  const int kKeysPerBuffer = 100;
  const int kNumL1Files = 5;
  options.create_if_missing = true;
  options.write_buffer_size = kKeysPerBuffer * kKvSize;
  options.max_write_buffer_number = 2;
  options.target_file_size_base =
      options.write_buffer_size *
      (options.max_write_buffer_number - 1);
  options.level0_file_num_compaction_trigger = kNumL1Files;
  options.max_bytes_for_level_base =
      options.level0_file_num_compaction_trigger *
      options.target_file_size_base;
  options.max_bytes_for_level_multiplier = 2;
  options.compression = kNoCompression;

12706 12707 12708 12709 12710 12711 12712
  env_->SetBackgroundThreads(1, Env::HIGH);
  env_->SetBackgroundThreads(1, Env::LOW);
  // stop the compaction thread until we simulate the file creation failure.
  SleepingBackgroundTask sleeping_task_low;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
                 Env::Priority::LOW);

12713 12714
  options.env = env_;

L
Lei Jin 已提交
12715
  DestroyAndReopen(options);
12716

I
Igor Canadi 已提交
12717
  const int kNumInsertedKeys =
12718 12719
      options.level0_file_num_compaction_trigger *
      (options.max_write_buffer_number - 1) *
12720
      kKeysPerBuffer;
12721 12722 12723 12724

  Random rnd(301);
  std::vector<std::string> keys;
  std::vector<std::string> values;
I
Igor Canadi 已提交
12725
  for (int k = 0; k < kNumInsertedKeys; ++k) {
12726 12727 12728 12729 12730
    keys.emplace_back(RandomString(&rnd, kKeySize));
    values.emplace_back(RandomString(&rnd, kKvSize - kKeySize));
    ASSERT_OK(Put(Slice(keys[k]), Slice(values[k])));
  }

12731 12732 12733 12734 12735
  dbfull()->TEST_FlushMemTable(true);
  // Make sure the number of L0 files can trigger compaction.
  ASSERT_GE(NumTableFilesAtLevel(0),
            options.level0_file_num_compaction_trigger);

12736
  auto previous_num_level0_files = NumTableFilesAtLevel(0);
12737

12738 12739 12740 12741
  // Fail the first file creation.
  env_->non_writable_count_ = 1;
  sleeping_task_low.WakeUp();
  sleeping_task_low.WaitUntilDone();
12742

12743 12744
  // Expect compaction to fail here as one file will fail its
  // creation.
12745
  ASSERT_TRUE(!dbfull()->TEST_WaitForCompact().ok());
12746

12747 12748
  // Verify L0 -> L1 compaction does fail.
  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
12749

12750
  // Verify all L0 files are still there.
12751
  ASSERT_EQ(NumTableFilesAtLevel(0), previous_num_level0_files);
12752 12753

  // All key-values must exist after compaction fails.
I
Igor Canadi 已提交
12754
  for (int k = 0; k < kNumInsertedKeys; ++k) {
12755 12756 12757
    ASSERT_EQ(values[k], Get(keys[k]));
  }

12758
  env_->non_writable_count_ = 0;
12759

12760
  // Make sure RocksDB will not get into corrupted state.
L
Lei Jin 已提交
12761
  Reopen(options);
12762 12763

  // Verify again after reopen.
I
Igor Canadi 已提交
12764
  for (int k = 0; k < kNumInsertedKeys; ++k) {
12765 12766 12767 12768
    ASSERT_EQ(values[k], Get(keys[k]));
  }
}

I
Igor Sugak 已提交
12769
TEST_F(DBTest, DynamicMiscOptions) {
12770 12771 12772 12773 12774 12775 12776
  // Test max_sequential_skip_in_iterations
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  options.max_sequential_skip_in_iterations = 16;
  options.compression = kNoCompression;
  options.statistics = rocksdb::CreateDBStatistics();
L
Lei Jin 已提交
12777
  DestroyAndReopen(options);
12778 12779 12780 12781 12782 12783 12784 12785 12786 12787 12788 12789 12790 12791 12792 12793 12794 12795 12796 12797 12798 12799 12800 12801

  auto assert_reseek_count = [this, &options](int key_start, int num_reseek) {
    int key0 = key_start;
    int key1 = key_start + 1;
    int key2 = key_start + 2;
    Random rnd(301);
    ASSERT_OK(Put(Key(key0), RandomString(&rnd, 8)));
    for (int i = 0; i < 10; ++i) {
      ASSERT_OK(Put(Key(key1), RandomString(&rnd, 8)));
    }
    ASSERT_OK(Put(Key(key2), RandomString(&rnd, 8)));
    std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
    iter->Seek(Key(key1));
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Key(key1)), 0);
    iter->Next();
    ASSERT_TRUE(iter->Valid());
    ASSERT_EQ(iter->key().compare(Key(key2)), 0);
    ASSERT_EQ(num_reseek,
              TestGetTickerCount(options, NUMBER_OF_RESEEKS_IN_ITERATION));
  };
  // No reseek
  assert_reseek_count(100, 0);

12802
  ASSERT_OK(dbfull()->SetOptions({
12803 12804 12805 12806 12807 12808 12809
    {"max_sequential_skip_in_iterations", "4"}
  }));
  // Clear memtable and make new option effective
  dbfull()->TEST_FlushMemTable(true);
  // Trigger reseek
  assert_reseek_count(200, 1);

12810
  ASSERT_OK(dbfull()->SetOptions({
12811 12812 12813 12814 12815 12816 12817 12818
    {"max_sequential_skip_in_iterations", "16"}
  }));
  // Clear memtable and make new option effective
  dbfull()->TEST_FlushMemTable(true);
  // No reseek
  assert_reseek_count(300, 1);
}

I
Igor Sugak 已提交
12819
TEST_F(DBTest, DontDeletePendingOutputs) {
I
Igor Canadi 已提交
12820 12821 12822 12823 12824 12825 12826 12827
  Options options;
  options.env = env_;
  options.create_if_missing = true;
  DestroyAndReopen(options);

  // Every time we write to a table file, call FOF/POF with full DB scan. This
  // will make sure our pending_outputs_ protection work correctly
  std::function<void()> purge_obsolete_files_function = [&]() {
12828
    JobContext job_context(0);
I
Igor Canadi 已提交
12829 12830 12831 12832
    dbfull()->TEST_LockMutex();
    dbfull()->FindObsoleteFiles(&job_context, true /*force*/);
    dbfull()->TEST_UnlockMutex();
    dbfull()->PurgeObsoleteFiles(job_context);
Y
Yueh-Hsuan Chiang 已提交
12833
    job_context.Clean();
I
Igor Canadi 已提交
12834 12835 12836 12837 12838 12839 12840 12841 12842 12843 12844 12845 12846 12847 12848 12849 12850
  };

  env_->table_write_callback_ = &purge_obsolete_files_function;

  for (int i = 0; i < 2; ++i) {
    ASSERT_OK(Put("a", "begin"));
    ASSERT_OK(Put("z", "end"));
    ASSERT_OK(Flush());
  }

  // If pending output guard does not work correctly, PurgeObsoleteFiles() will
  // delete the file that Compaction is trying to create, causing this: error
  // db/db_test.cc:975: IO error:
  // /tmp/rocksdbtest-1552237650/db_test/000009.sst: No such file or directory
  Compact("a", "b");
}

I
Igor Sugak 已提交
12851
TEST_F(DBTest, DontDeleteMovedFile) {
I
Igor Canadi 已提交
12852 12853 12854 12855 12856 12857 12858 12859 12860 12861 12862 12863 12864 12865 12866 12867 12868 12869 12870 12871 12872 12873 12874 12875 12876 12877 12878 12879 12880
  // This test triggers move compaction and verifies that the file is not
  // deleted when it's part of move compaction
  Options options = CurrentOptions();
  options.env = env_;
  options.create_if_missing = true;
  options.max_bytes_for_level_base = 1024 * 1024;  // 1 MB
  options.level0_file_num_compaction_trigger =
      2;  // trigger compaction when we have 2 files
  DestroyAndReopen(options);

  Random rnd(301);
  // Create two 1MB sst files
  for (int i = 0; i < 2; ++i) {
    // Create 1MB sst file
    for (int j = 0; j < 100; ++j) {
      ASSERT_OK(Put(Key(i * 50 + j), RandomString(&rnd, 10 * 1024)));
    }
    ASSERT_OK(Flush());
  }
  // this should execute both L0->L1 and L1->(move)->L2 compactions
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ("0,0,1", FilesPerLevel(0));

  // If the moved file is actually deleted (the move-safeguard in
  // ~Version::Version() is not there), we get this failure:
  // Corruption: Can't access /000009.sst
  Reopen(options);
}

I
Igor Sugak 已提交
12881
TEST_F(DBTest, DeleteMovedFileAfterCompaction) {
I
Igor Canadi 已提交
12882 12883 12884 12885 12886 12887 12888 12889 12890 12891 12892 12893
  // iter 1 -- delete_obsolete_files_period_micros == 0
  for (int iter = 0; iter < 2; ++iter) {
    // This test triggers move compaction and verifies that the file is not
    // deleted when it's part of move compaction
    Options options = CurrentOptions();
    options.env = env_;
    if (iter == 1) {
      options.delete_obsolete_files_period_micros = 0;
    }
    options.create_if_missing = true;
    options.level0_file_num_compaction_trigger =
        2;  // trigger compaction when we have 2 files
12894 12895
    OnFileDeletionListener* listener = new OnFileDeletionListener();
    options.listeners.emplace_back(listener);
I
Igor Canadi 已提交
12896 12897 12898 12899 12900 12901 12902 12903 12904 12905 12906 12907 12908 12909 12910 12911 12912 12913 12914 12915 12916 12917 12918 12919 12920 12921 12922 12923 12924 12925 12926 12927 12928 12929 12930 12931 12932 12933 12934 12935 12936 12937 12938 12939 12940 12941 12942 12943 12944 12945 12946 12947
    DestroyAndReopen(options);

    Random rnd(301);
    // Create two 1MB sst files
    for (int i = 0; i < 2; ++i) {
      // Create 1MB sst file
      for (int j = 0; j < 100; ++j) {
        ASSERT_OK(Put(Key(i * 50 + j), RandomString(&rnd, 10 * 1024)));
      }
      ASSERT_OK(Flush());
    }
    // this should execute L0->L1
    dbfull()->TEST_WaitForCompact();
    ASSERT_EQ("0,1", FilesPerLevel(0));

    // block compactions
    SleepingBackgroundTask sleeping_task;
    env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task,
                   Env::Priority::LOW);

    options.max_bytes_for_level_base = 1024 * 1024;  // 1 MB
    Reopen(options);
    std::unique_ptr<Iterator> iterator(db_->NewIterator(ReadOptions()));
    ASSERT_EQ("0,1", FilesPerLevel(0));
    // let compactions go
    sleeping_task.WakeUp();
    sleeping_task.WaitUntilDone();

    // this should execute L1->L2 (move)
    dbfull()->TEST_WaitForCompact();

    ASSERT_EQ("0,0,1", FilesPerLevel(0));

    std::vector<LiveFileMetaData> metadata;
    db_->GetLiveFilesMetaData(&metadata);
    ASSERT_EQ(metadata.size(), 1U);
    auto moved_file_name = metadata[0].name;

    // Create two more 1MB sst files
    for (int i = 0; i < 2; ++i) {
      // Create 1MB sst file
      for (int j = 0; j < 100; ++j) {
        ASSERT_OK(Put(Key(i * 50 + j + 100), RandomString(&rnd, 10 * 1024)));
      }
      ASSERT_OK(Flush());
    }
    // this should execute both L0->L1 and L1->L2 (merge with previous file)
    dbfull()->TEST_WaitForCompact();

    ASSERT_EQ("0,0,2", FilesPerLevel(0));

    // iterator is holding the file
12948
    ASSERT_TRUE(env_->FileExists(dbname_ + moved_file_name));
I
Igor Canadi 已提交
12949

12950
    listener->SetExpectedFileName(dbname_ + moved_file_name);
I
Igor Canadi 已提交
12951 12952 12953
    iterator.reset();

    // this file should have been compacted away
12954 12955
    ASSERT_TRUE(!env_->FileExists(dbname_ + moved_file_name));
    listener->VerifyMatchedCount(1);
I
Igor Canadi 已提交
12956 12957 12958
  }
}

I
Igor Sugak 已提交
12959
TEST_F(DBTest, OptimizeFiltersForHits) {
12960
  Options options = CurrentOptions();
12961 12962
  options.write_buffer_size = 256 * 1024;
  options.target_file_size_base = 256 * 1024;
12963 12964 12965
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 4;
12966
  options.max_bytes_for_level_base = 256 * 1024;
12967 12968 12969 12970 12971 12972 12973 12974 12975 12976 12977 12978 12979 12980 12981 12982 12983 12984 12985 12986 12987 12988 12989 12990 12991 12992 12993 12994 12995 12996 12997 12998 12999 13000 13001 13002 13003 13004 13005 13006 13007 13008 13009 13010
  options.max_write_buffer_number = 2;
  options.max_background_compactions = 8;
  options.max_background_flushes = 8;
  options.compaction_style = kCompactionStyleLevel;
  BlockBasedTableOptions bbto;
  bbto.filter_policy.reset(NewBloomFilterPolicy(10, true));
  bbto.whole_key_filtering = true;
  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  options.optimize_filters_for_hits = true;
  options.statistics = rocksdb::CreateDBStatistics();
  CreateAndReopenWithCF({"mypikachu"}, options);

  int numkeys = 200000;
  for (int i = 0; i < 20; i += 2) {
    for (int j = i; j < numkeys; j += 20) {
      ASSERT_OK(Put(1, Key(j), "val"));
    }
  }


  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();

  for (int i = 1; i < numkeys; i += 2) {
    ASSERT_EQ(Get(1, Key(i)), "NOT_FOUND");
  }

  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L0));
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L1));
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L2_AND_UP));

  // When the skip_filters_on_last_level is ON, the last level which has
  // most of the keys does not use bloom filters. We end up using
  // bloom filters in a very small number of cases. Without the flag.
  // this number would be close to 150000 (all the key at the last level) +
  // some use in the upper levels
  //
  ASSERT_GT(90000, TestGetTickerCount(options, BLOOM_FILTER_USEFUL));

  for (int i = 0; i < numkeys; i += 2) {
    ASSERT_EQ(Get(1, Key(i)), "val");
  }
}

I
Igor Sugak 已提交
13011
TEST_F(DBTest, L0L1L2AndUpHitCounter) {
13012 13013 13014 13015 13016 13017 13018 13019 13020 13021 13022 13023 13024 13025 13026 13027 13028 13029 13030 13031 13032 13033 13034 13035 13036 13037 13038 13039 13040 13041 13042 13043 13044 13045 13046 13047 13048
  Options options = CurrentOptions();
  options.write_buffer_size = 32 * 1024;
  options.target_file_size_base = 32 * 1024;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 4;
  options.max_bytes_for_level_base = 64 * 1024;
  options.max_write_buffer_number = 2;
  options.max_background_compactions = 8;
  options.max_background_flushes = 8;
  options.statistics = rocksdb::CreateDBStatistics();
  CreateAndReopenWithCF({"mypikachu"}, options);

  int numkeys = 20000;
  for (int i = 0; i < numkeys; i++) {
    ASSERT_OK(Put(1, Key(i), "val"));
  }
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L0));
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L1));
  ASSERT_EQ(0, TestGetTickerCount(options, GET_HIT_L2_AND_UP));

  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();

  for (int i = 0; i < numkeys; i++) {
    ASSERT_EQ(Get(1, Key(i)), "val");
  }

  ASSERT_GT(TestGetTickerCount(options, GET_HIT_L0), 100);
  ASSERT_GT(TestGetTickerCount(options, GET_HIT_L1), 100);
  ASSERT_GT(TestGetTickerCount(options, GET_HIT_L2_AND_UP), 100);

  ASSERT_EQ(numkeys, TestGetTickerCount(options, GET_HIT_L0) +
                         TestGetTickerCount(options, GET_HIT_L1) +
                         TestGetTickerCount(options, GET_HIT_L2_AND_UP));
}

I
Igor Sugak 已提交
13049
TEST_F(DBTest, EncodeDecompressedBlockSizeTest) {
13050 13051 13052 13053 13054 13055 13056
  // iter 0 -- zlib
  // iter 1 -- bzip2
  // iter 2 -- lz4
  // iter 3 -- lz4HC
  CompressionType compressions[] = {kZlibCompression, kBZip2Compression,
                                    kLZ4Compression,  kLZ4HCCompression};
  for (int iter = 0; iter < 4; ++iter) {
13057 13058 13059
    if (!CompressionTypeSupported(compressions[iter])) {
      continue;
    }
13060 13061 13062 13063 13064 13065 13066 13067 13068 13069 13070 13071 13072 13073 13074 13075 13076 13077 13078 13079 13080 13081 13082 13083 13084 13085 13086 13087 13088 13089 13090 13091 13092 13093
    // first_table_version 1 -- generate with table_version == 1, read with
    // table_version == 2
    // first_table_version 2 -- generate with table_version == 2, read with
    // table_version == 1
    for (int first_table_version = 1; first_table_version <= 2;
         ++first_table_version) {
      BlockBasedTableOptions table_options;
      table_options.format_version = first_table_version;
      table_options.filter_policy.reset(NewBloomFilterPolicy(10));
      Options options = CurrentOptions();
      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
      options.create_if_missing = true;
      options.compression = compressions[iter];
      DestroyAndReopen(options);

      int kNumKeysWritten = 100000;

      Random rnd(301);
      for (int i = 0; i < kNumKeysWritten; ++i) {
        // compressible string
        ASSERT_OK(Put(Key(i), RandomString(&rnd, 128) + std::string(128, 'a')));
      }

      table_options.format_version = first_table_version == 1 ? 2 : 1;
      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
      Reopen(options);
      for (int i = 0; i < kNumKeysWritten; ++i) {
        auto r = Get(Key(i));
        ASSERT_EQ(r.substr(128), std::string(128, 'a'));
      }
    }
  }
}

I
Igor Sugak 已提交
13094
TEST_F(DBTest, MutexWaitStats) {
13095 13096 13097 13098 13099 13100 13101 13102 13103 13104 13105 13106 13107 13108
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
  CreateAndReopenWithCF({"pikachu"}, options);
  const int64_t kMutexWaitDelay = 100;
  ThreadStatusUtil::TEST_SetStateDelay(
      ThreadStatus::STATE_MUTEX_WAIT, kMutexWaitDelay);
  ASSERT_OK(Put("hello", "rocksdb"));
  ASSERT_GE(TestGetTickerCount(
            options, DB_MUTEX_WAIT_MICROS), kMutexWaitDelay);
  ThreadStatusUtil::TEST_SetStateDelay(
      ThreadStatus::STATE_MUTEX_WAIT, 0);
}

I
Igor Canadi 已提交
13109 13110 13111 13112 13113 13114 13115 13116 13117 13118 13119 13120 13121 13122
// This reproduces a bug where we don't delete a file because when it was
// supposed to be deleted, it was blocked by pending_outputs
// Consider:
// 1. current file_number is 13
// 2. compaction (1) starts, blocks deletion of all files starting with 13
// (pending outputs)
// 3. file 13 is created by compaction (2)
// 4. file 13 is consumed by compaction (3) and file 15 was created. Since file
// 13 has no references, it is put into VersionSet::obsolete_files_
// 5. FindObsoleteFiles() gets file 13 from VersionSet::obsolete_files_. File 13
// is deleted from obsolete_files_ set.
// 6. PurgeObsoleteFiles() tries to delete file 13, but this file is blocked by
// pending outputs since compaction (1) is still running. It is not deleted and
// it is not present in obsolete_files_ anymore. Therefore, we never delete it.
I
Igor Sugak 已提交
13123
TEST_F(DBTest, DeleteObsoleteFilesPendingOutputs) {
I
Igor Canadi 已提交
13124 13125 13126 13127 13128 13129 13130 13131
  Options options = CurrentOptions();
  options.env = env_;
  options.write_buffer_size = 2 * 1024 * 1024;     // 2 MB
  options.max_bytes_for_level_base = 1024 * 1024;  // 1 MB
  options.level0_file_num_compaction_trigger =
      2;  // trigger compaction when we have 2 files
  options.max_background_flushes = 2;
  options.max_background_compactions = 2;
13132 13133 13134 13135

  OnFileDeletionListener* listener = new OnFileDeletionListener();
  options.listeners.emplace_back(listener);

I
Igor Canadi 已提交
13136 13137 13138 13139 13140 13141 13142 13143 13144 13145 13146 13147 13148 13149 13150 13151 13152 13153 13154 13155 13156 13157 13158 13159 13160 13161 13162 13163 13164 13165 13166 13167 13168 13169 13170 13171 13172 13173 13174 13175 13176 13177 13178 13179 13180 13181 13182 13183
  Reopen(options);

  Random rnd(301);
  // Create two 1MB sst files
  for (int i = 0; i < 2; ++i) {
    // Create 1MB sst file
    for (int j = 0; j < 100; ++j) {
      ASSERT_OK(Put(Key(i * 50 + j), RandomString(&rnd, 10 * 1024)));
    }
    ASSERT_OK(Flush());
  }
  // this should execute both L0->L1 and L1->(move)->L2 compactions
  dbfull()->TEST_WaitForCompact();
  ASSERT_EQ("0,0,1", FilesPerLevel(0));

  SleepingBackgroundTask blocking_thread;
  port::Mutex mutex_;
  bool already_blocked(false);

  // block the flush
  std::function<void()> block_first_time = [&]() {
    bool blocking = false;
    {
      MutexLock l(&mutex_);
      if (!already_blocked) {
        blocking = true;
        already_blocked = true;
      }
    }
    if (blocking) {
      blocking_thread.DoSleep();
    }
  };
  env_->table_write_callback_ = &block_first_time;
  // Create 1MB sst file
  for (int j = 0; j < 256; ++j) {
    ASSERT_OK(Put(Key(j), RandomString(&rnd, 10 * 1024)));
  }
  // this should trigger a flush, which is blocked with block_first_time
  // pending_file is protecting all the files created after

  ASSERT_OK(dbfull()->TEST_CompactRange(2, nullptr, nullptr));

  ASSERT_EQ("0,0,0,1", FilesPerLevel(0));
  std::vector<LiveFileMetaData> metadata;
  db_->GetLiveFilesMetaData(&metadata);
  ASSERT_EQ(metadata.size(), 1U);
  auto file_on_L2 = metadata[0].name;
13184
  listener->SetExpectedFileName(dbname_ + file_on_L2);
I
Igor Canadi 已提交
13185

13186 13187
  ASSERT_OK(dbfull()->TEST_CompactRange(3, nullptr, nullptr, nullptr,
                                        true /* disallow trivial move */));
I
Igor Canadi 已提交
13188 13189 13190 13191 13192 13193 13194 13195 13196 13197 13198 13199
  ASSERT_EQ("0,0,0,0,1", FilesPerLevel(0));

  // finish the flush!
  blocking_thread.WakeUp();
  blocking_thread.WaitUntilDone();
  dbfull()->TEST_WaitForFlushMemTable();
  ASSERT_EQ("1,0,0,0,1", FilesPerLevel(0));

  metadata.clear();
  db_->GetLiveFilesMetaData(&metadata);
  ASSERT_EQ(metadata.size(), 2U);

13200
  // This file should have been deleted during last compaction
13201 13202
  ASSERT_TRUE(!env_->FileExists(dbname_ + file_on_L2));
  listener->VerifyMatchedCount(1);
I
Igor Canadi 已提交
13203 13204
}

I
Igor Sugak 已提交
13205
TEST_F(DBTest, CloseSpeedup) {
13206 13207 13208 13209 13210 13211 13212 13213 13214 13215 13216 13217 13218 13219 13220 13221 13222 13223 13224 13225 13226 13227 13228 13229 13230 13231 13232 13233 13234 13235 13236 13237 13238 13239 13240 13241 13242 13243 13244 13245 13246 13247 13248 13249 13250 13251 13252 13253 13254 13255 13256 13257
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 4;
  options.max_bytes_for_level_base = 400 * 1024;
  options.max_write_buffer_number = 16;

  // Block background threads
  env_->SetBackgroundThreads(1, Env::LOW);
  env_->SetBackgroundThreads(1, Env::HIGH);
  SleepingBackgroundTask sleeping_task_low;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_low,
                 Env::Priority::LOW);
  SleepingBackgroundTask sleeping_task_high;
  env_->Schedule(&SleepingBackgroundTask::DoSleepTask, &sleeping_task_high,
                 Env::Priority::HIGH);

  std::vector<std::string> filenames;
  env_->GetChildren(dbname_, &filenames);
  // Delete archival files.
  for (size_t i = 0; i < filenames.size(); ++i) {
    env_->DeleteFile(dbname_ + "/" + filenames[i]);
  }
  env_->DeleteDir(dbname_);
  DestroyAndReopen(options);

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
  env_->SetBackgroundThreads(1, Env::LOW);
  env_->SetBackgroundThreads(1, Env::HIGH);
  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are not going to level 2
  // After that, (100K, 200K)
  for (int num = 0; num < 5; num++) {
    GenerateNewFile(&rnd, &key_idx, true);
  }

  ASSERT_EQ(0, GetSstFileCount(dbname_));

  Close();
  ASSERT_EQ(0, GetSstFileCount(dbname_));

  // Unblock background threads
  sleeping_task_high.WakeUp();
  sleeping_task_high.WaitUntilDone();
  sleeping_task_low.WakeUp();
  sleeping_task_low.WaitUntilDone();

  Destroy(options);
}
13258 13259 13260 13261 13262 13263 13264 13265 13266 13267

class DelayedMergeOperator : public AssociativeMergeOperator {
 private:
  DBTest* db_test_;

 public:
  explicit DelayedMergeOperator(DBTest* d) : db_test_(d) {}
  virtual bool Merge(const Slice& key, const Slice* existing_value,
                     const Slice& value, std::string* new_value,
                     Logger* logger) const override {
S
sdong 已提交
13268
    db_test_->env_->addon_time_.fetch_add(1000);
13269 13270 13271 13272 13273 13274 13275 13276 13277 13278 13279 13280 13281 13282
    return true;
  }

  virtual const char* Name() const override { return "DelayedMergeOperator"; }
};

TEST_F(DBTest, MergeTestTime) {
  std::string one, two, three;
  PutFixed64(&one, 1);
  PutFixed64(&two, 2);
  PutFixed64(&three, 3);

  // Enable time profiling
  SetPerfLevel(kEnableTime);
S
sdong 已提交
13283
  this->env_->addon_time_.store(0);
13284 13285 13286 13287 13288 13289 13290 13291 13292 13293 13294 13295 13296 13297 13298 13299 13300 13301 13302 13303
  Options options;
  options = CurrentOptions(options);
  options.statistics = rocksdb::CreateDBStatistics();
  options.merge_operator.reset(new DelayedMergeOperator(this));
  DestroyAndReopen(options);

  ASSERT_EQ(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 0);
  db_->Put(WriteOptions(), "foo", one);
  ASSERT_OK(Flush());
  ASSERT_OK(db_->Merge(WriteOptions(), "foo", two));
  ASSERT_OK(Flush());
  ASSERT_OK(db_->Merge(WriteOptions(), "foo", three));
  ASSERT_OK(Flush());

  ReadOptions opt;
  opt.verify_checksums = true;
  opt.snapshot = nullptr;
  std::string result;
  db_->Get(opt, "foo", &result);

S
sdong 已提交
13304 13305
  ASSERT_LT(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 2800000);
  ASSERT_GT(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 1200000);
13306 13307 13308 13309 13310 13311 13312 13313 13314 13315 13316

  ReadOptions read_options;
  std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
  int count = 0;
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    ASSERT_OK(iter->status());
    ++count;
  }

  ASSERT_EQ(1, count);

S
sdong 已提交
13317 13318
  ASSERT_LT(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 6000000);
  ASSERT_GT(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 3200000);
13319 13320 13321 13322 13323 13324 13325 13326 13327 13328 13329 13330 13331 13332 13333 13334 13335 13336 13337 13338 13339 13340 13341 13342 13343 13344 13345 13346 13347 13348 13349 13350 13351 13352 13353 13354 13355 13356 13357 13358
}

TEST_F(DBTest, MergeCompactionTimeTest) {
  SetPerfLevel(kEnableTime);
  Options options;
  options = CurrentOptions(options);
  options.compaction_filter_factory = std::make_shared<KeepFilterFactory>();
  options.statistics = rocksdb::CreateDBStatistics();
  options.merge_operator.reset(new DelayedMergeOperator(this));
  options.compaction_style = kCompactionStyleUniversal;
  DestroyAndReopen(options);

  for (int i = 0; i < 1000; i++) {
    ASSERT_OK(db_->Merge(WriteOptions(), "foo", "TEST"));
    ASSERT_OK(Flush());
  }
  dbfull()->TEST_WaitForFlushMemTable();
  dbfull()->TEST_WaitForCompact();

  ASSERT_NE(TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME), 0);
}

TEST_F(DBTest, FilterCompactionTimeTest) {
  Options options;
  options.compaction_filter_factory =
      std::make_shared<DelayFilterFactory>(this);
  options.disable_auto_compactions = true;
  options.create_if_missing = true;
  options.statistics = rocksdb::CreateDBStatistics();
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  // put some data
  for (int table = 0; table < 4; ++table) {
    for (int i = 0; i < 10 + table; ++i) {
      Put(ToString(table * 100 + i), "val");
    }
    Flush();
  }

13359
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
13360 13361 13362 13363 13364 13365 13366 13367 13368 13369
  ASSERT_EQ(0U, CountLiveFiles());

  Reopen(options);

  Iterator* itr = db_->NewIterator(ReadOptions());
  itr->SeekToFirst();
  ASSERT_NE(TestGetTickerCount(options, FILTER_OPERATION_TOTAL_TIME), 0);
  delete itr;
}

13370 13371 13372 13373 13374 13375 13376 13377 13378 13379 13380 13381 13382 13383 13384
TEST_F(DBTest, TestLogCleanup) {
  Options options = CurrentOptions();
  options.write_buffer_size = 64 * 1024;  // very small
  // only two memtables allowed ==> only two log files
  options.max_write_buffer_number = 2;
  Reopen(options);

  for (int i = 0; i < 100000; ++i) {
    Put(Key(i), "val");
    // only 2 memtables will be alive, so logs_to_free needs to always be below
    // 2
    ASSERT_LT(dbfull()->TEST_LogsToFreeSize(), static_cast<size_t>(3));
  }
}

13385 13386 13387 13388 13389 13390 13391 13392 13393 13394 13395
TEST_F(DBTest, EmptyCompactedDB) {
  Options options;
  options.max_open_files = -1;
  options = CurrentOptions(options);
  Close();
  ASSERT_OK(ReadOnlyReopen(options));
  Status s = Put("new", "value");
  ASSERT_TRUE(s.IsNotSupported());
  Close();
}

13396
TEST_F(DBTest, CompressLevelCompaction) {
13397 13398 13399
  if (!Zlib_Supported()) {
    return;
  }
13400 13401 13402 13403 13404 13405 13406 13407 13408 13409 13410 13411 13412 13413 13414
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 4;
  options.max_bytes_for_level_base = 400 * 1024;
  // First two levels have no compression, so that a trivial move between
  // them will be allowed. Level 2 has Zlib compression so that a trivial
  // move to level 3 will not be allowed
  options.compression_per_level = {kNoCompression, kNoCompression,
                                   kZlibCompression};
  int matches = 0, didnt_match = 0, trivial_move = 0, non_trivial = 0;

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "Compaction::InputCompressionMatchesOutput:Matches",
13415
      [&](void* arg) { matches++; });
13416 13417
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "Compaction::InputCompressionMatchesOutput:DidntMatch",
13418
      [&](void* arg) { didnt_match++; });
13419
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
13420 13421
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial++; });
13422
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
13423 13424
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
13425 13426 13427 13428 13429 13430 13431 13432 13433 13434 13435 13436 13437 13438 13439 13440 13441 13442 13443 13444 13445 13446 13447 13448 13449 13450 13451 13452 13453 13454 13455 13456 13457 13458 13459 13460 13461 13462 13463 13464 13465 13466 13467 13468 13469 13470 13471 13472 13473 13474 13475 13476 13477 13478
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Reopen(options);

  Random rnd(301);
  int key_idx = 0;

  // First three 110KB files are going to level 0
  // After that, (100K, 200K)
  for (int num = 0; num < 3; num++) {
    GenerateNewFile(&rnd, &key_idx);
  }

  // Another 110KB triggers a compaction to 400K file to fill up level 0
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ(4, GetSstFileCount(dbname_));

  // (1, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4", FilesPerLevel(0));

  // (1, 4, 1)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,1", FilesPerLevel(0));

  // (1, 4, 2)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,2", FilesPerLevel(0));

  // (1, 4, 3)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,3", FilesPerLevel(0));

  // (1, 4, 4)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,4", FilesPerLevel(0));

  // (1, 4, 5)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,5", FilesPerLevel(0));

  // (1, 4, 6)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,6", FilesPerLevel(0));

  // (1, 4, 7)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,7", FilesPerLevel(0));

  // (1, 4, 8)
  GenerateNewFile(&rnd, &key_idx);
  ASSERT_EQ("1,4,8", FilesPerLevel(0));

  ASSERT_EQ(matches, 12);
13479 13480 13481 13482
  // Currently, the test relies on the number of calls to
  // InputCompressionMatchesOutput() per compaction.
  const int kCallsToInputCompressionMatch = 2;
  ASSERT_EQ(didnt_match, 8 * kCallsToInputCompressionMatch);
13483 13484 13485 13486 13487 13488 13489 13490 13491 13492 13493 13494 13495 13496 13497 13498 13499 13500 13501 13502 13503 13504
  ASSERT_EQ(trivial_move, 12);
  ASSERT_EQ(non_trivial, 8);

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Reopen(options);

  for (int i = 0; i < key_idx; i++) {
    auto v = Get(Key(i));
    ASSERT_NE(v, "NOT_FOUND");
    ASSERT_TRUE(v.size() == 1 || v.size() == 10000);
  }

  Destroy(options);
}

13505 13506 13507 13508 13509 13510 13511 13512 13513 13514 13515 13516 13517 13518 13519 13520 13521 13522 13523 13524 13525 13526 13527 13528 13529 13530 13531 13532 13533 13534 13535 13536 13537 13538 13539 13540 13541 13542 13543 13544 13545 13546 13547 13548 13549 13550 13551 13552 13553 13554 13555 13556
class CountingDeleteTabPropCollector : public TablePropertiesCollector {
 public:
  const char* Name() const override { return "CountingDeleteTabPropCollector"; }

  Status AddUserKey(const Slice& user_key, const Slice& value, EntryType type,
                    SequenceNumber seq, uint64_t file_size) override {
    if (type == kEntryDelete) {
      num_deletes_++;
    }
    return Status::OK();
  }

  bool NeedCompact() const override { return num_deletes_ > 10; }

  UserCollectedProperties GetReadableProperties() const override {
    return UserCollectedProperties{};
  }

  Status Finish(UserCollectedProperties* properties) override {
    *properties =
        UserCollectedProperties{{"num_delete", ToString(num_deletes_)}};
    return Status::OK();
  }

 private:
  uint32_t num_deletes_ = 0;
};

class CountingDeleteTabPropCollectorFactory
    : public TablePropertiesCollectorFactory {
 public:
  virtual TablePropertiesCollector* CreateTablePropertiesCollector() override {
    return new CountingDeleteTabPropCollector();
  }
  const char* Name() const override {
    return "CountingDeleteTabPropCollectorFactory";
  }
};

TEST_F(DBTest, TablePropertiesNeedCompactTest) {
  Random rnd(301);

  Options options;
  options.create_if_missing = true;
  options.write_buffer_size = 4096;
  options.max_write_buffer_number = 8;
  options.level0_file_num_compaction_trigger = 2;
  options.level0_slowdown_writes_trigger = 2;
  options.level0_stop_writes_trigger = 4;
  options.target_file_size_base = 2048;
  options.max_bytes_for_level_base = 10240;
  options.max_bytes_for_level_multiplier = 4;
S
sdong 已提交
13557
  options.soft_rate_limit = 1.1;
13558 13559 13560 13561 13562 13563 13564 13565 13566 13567 13568 13569 13570 13571 13572 13573 13574 13575 13576 13577 13578 13579 13580 13581 13582 13583 13584 13585 13586 13587 13588 13589 13590 13591 13592 13593 13594 13595 13596 13597 13598 13599 13600 13601 13602 13603 13604 13605 13606 13607 13608 13609 13610 13611 13612 13613 13614 13615 13616 13617 13618 13619
  options.num_levels = 8;

  std::shared_ptr<TablePropertiesCollectorFactory> collector_factory(
      new CountingDeleteTabPropCollectorFactory);
  options.table_properties_collector_factories.resize(1);
  options.table_properties_collector_factories[0] = collector_factory;

  DestroyAndReopen(options);

  const int kMaxKey = 1000;
  for (int i = 0; i < kMaxKey; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 102)));
    ASSERT_OK(Put(Key(kMaxKey + i), RandomString(&rnd, 102)));
  }
  Flush();
  dbfull()->TEST_WaitForCompact();
  if (NumTableFilesAtLevel(0) == 1) {
    // Clear Level 0 so that when later flush a file with deletions,
    // we don't trigger an organic compaction.
    ASSERT_OK(Put(Key(0), ""));
    ASSERT_OK(Put(Key(kMaxKey * 2), ""));
    Flush();
    dbfull()->TEST_WaitForCompact();
  }
  ASSERT_EQ(NumTableFilesAtLevel(0), 0);

  {
    int c = 0;
    std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
    iter->Seek(Key(kMaxKey - 100));
    while (iter->Valid() && iter->key().compare(Key(kMaxKey + 100)) < 0) {
      iter->Next();
      ++c;
    }
    ASSERT_EQ(c, 200);
  }

  Delete(Key(0));
  for (int i = kMaxKey - 100; i < kMaxKey + 100; i++) {
    Delete(Key(i));
  }
  Delete(Key(kMaxKey * 2));

  Flush();
  dbfull()->TEST_WaitForCompact();

  {
    SetPerfLevel(kEnableCount);
    perf_context.Reset();
    int c = 0;
    std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
    iter->Seek(Key(kMaxKey - 100));
    while (iter->Valid() && iter->key().compare(Key(kMaxKey + 100)) < 0) {
      iter->Next();
    }
    ASSERT_EQ(c, 0);
    ASSERT_LT(perf_context.internal_delete_skipped_count, 30u);
    ASSERT_LT(perf_context.internal_key_skipped_count, 30u);
    SetPerfLevel(kDisable);
  }
}

13620
TEST_F(DBTest, SuggestCompactRangeTest) {
13621 13622 13623
  class CompactionFilterFactoryGetContext : public CompactionFilterFactory {
   public:
    virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
I
Igor Canadi 已提交
13624
        const CompactionFilter::Context& context) override {
13625 13626 13627 13628 13629 13630 13631 13632 13633
      saved_context = context;
      std::unique_ptr<CompactionFilter> empty_filter;
      return empty_filter;
    }
    const char* Name() const override {
      return "CompactionFilterFactoryGetContext";
    }
    static bool IsManual(CompactionFilterFactory* compaction_filter_factory) {
      return reinterpret_cast<CompactionFilterFactoryGetContext*>(
13634
                 compaction_filter_factory)->saved_context.is_manual_compaction;
13635 13636 13637 13638
    }
    CompactionFilter::Context saved_context;
  };

13639 13640
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleLevel;
13641 13642 13643 13644
  options.compaction_filter_factory.reset(
      new CompactionFilterFactoryGetContext());
  options.write_buffer_size = 110 << 10;
  options.level0_file_num_compaction_trigger = 4;
13645
  options.num_levels = 4;
13646 13647 13648 13649
  options.compression = kNoCompression;
  options.max_bytes_for_level_base = 450 << 10;
  options.target_file_size_base = 98 << 10;
  options.max_grandparent_overlap_factor = 1 << 20;  // inf
13650 13651 13652 13653 13654 13655

  Reopen(options);

  Random rnd(301);

  for (int num = 0; num < 3; num++) {
13656
    GenerateNewRandomFile(&rnd);
13657 13658
  }

13659 13660 13661 13662
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("0,4", FilesPerLevel(0));
  ASSERT_TRUE(!CompactionFilterFactoryGetContext::IsManual(
                   options.compaction_filter_factory.get()));
13663

13664
  GenerateNewRandomFile(&rnd);
13665 13666
  ASSERT_EQ("1,4", FilesPerLevel(0));

13667 13668
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("2,4", FilesPerLevel(0));
13669

13670 13671
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("3,4", FilesPerLevel(0));
13672

13673 13674
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("0,4,4", FilesPerLevel(0));
13675

13676
  GenerateNewRandomFile(&rnd);
13677 13678
  ASSERT_EQ("1,4,4", FilesPerLevel(0));

13679 13680
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("2,4,4", FilesPerLevel(0));
13681

13682 13683
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("3,4,4", FilesPerLevel(0));
13684

13685 13686
  GenerateNewRandomFile(&rnd);
  ASSERT_EQ("0,4,8", FilesPerLevel(0));
13687

13688
  GenerateNewRandomFile(&rnd);
13689 13690 13691 13692 13693 13694 13695 13696 13697 13698
  ASSERT_EQ("1,4,8", FilesPerLevel(0));

  // compact it three times
  for (int i = 0; i < 3; ++i) {
    ASSERT_OK(experimental::SuggestCompactRange(db_, nullptr, nullptr));
    dbfull()->TEST_WaitForCompact();
  }

  ASSERT_EQ("0,0,13", FilesPerLevel(0));

13699
  GenerateNewRandomFile(&rnd);
13700 13701 13702 13703 13704 13705 13706 13707 13708 13709 13710 13711 13712 13713
  ASSERT_EQ("1,0,13", FilesPerLevel(0));

  // nonoverlapping with the file on level 0
  Slice start("a"), end("b");
  ASSERT_OK(experimental::SuggestCompactRange(db_, &start, &end));
  dbfull()->TEST_WaitForCompact();

  // should not compact the level 0 file
  ASSERT_EQ("1,0,13", FilesPerLevel(0));

  start = Slice("j");
  end = Slice("m");
  ASSERT_OK(experimental::SuggestCompactRange(db_, &start, &end));
  dbfull()->TEST_WaitForCompact();
13714 13715
  ASSERT_TRUE(CompactionFilterFactoryGetContext::IsManual(
      options.compaction_filter_factory.get()));
13716 13717 13718 13719 13720

  // now it should compact the level 0 file
  ASSERT_EQ("0,1,13", FilesPerLevel(0));
}

13721 13722 13723 13724 13725 13726 13727 13728 13729 13730 13731 13732 13733 13734 13735 13736 13737 13738 13739 13740 13741 13742 13743 13744 13745 13746 13747 13748 13749 13750 13751 13752 13753 13754 13755 13756 13757 13758 13759 13760 13761 13762 13763 13764 13765 13766 13767 13768 13769 13770 13771 13772 13773 13774 13775
TEST_F(DBTest, PromoteL0) {
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.write_buffer_size = 10 * 1024 * 1024;
  DestroyAndReopen(options);

  // non overlapping ranges
  std::vector<std::pair<int32_t, int32_t>> ranges = {
      {81, 160}, {0, 80}, {161, 240}, {241, 320}};

  int32_t value_size = 10 * 1024;  // 10 KB

  Random rnd(301);
  std::map<int32_t, std::string> values;
  for (const auto& range : ranges) {
    for (int32_t j = range.first; j < range.second; j++) {
      values[j] = RandomString(&rnd, value_size);
      ASSERT_OK(Put(Key(j), values[j]));
    }
    ASSERT_OK(Flush());
  }

  int32_t level0_files = NumTableFilesAtLevel(0, 0);
  ASSERT_EQ(level0_files, ranges.size());
  ASSERT_EQ(NumTableFilesAtLevel(1, 0), 0);  // No files in L1

  // Promote L0 level to L2.
  ASSERT_OK(experimental::PromoteL0(db_, db_->DefaultColumnFamily(), 2));
  // We expect that all the files were trivially moved from L0 to L2
  ASSERT_EQ(NumTableFilesAtLevel(0, 0), 0);
  ASSERT_EQ(NumTableFilesAtLevel(2, 0), level0_files);

  for (const auto& kv : values) {
    ASSERT_EQ(Get(Key(kv.first)), kv.second);
  }
}

TEST_F(DBTest, PromoteL0Failure) {
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
  options.write_buffer_size = 10 * 1024 * 1024;
  DestroyAndReopen(options);

  // Produce two L0 files with overlapping ranges.
  ASSERT_OK(Put(Key(0), ""));
  ASSERT_OK(Put(Key(3), ""));
  ASSERT_OK(Flush());
  ASSERT_OK(Put(Key(1), ""));
  ASSERT_OK(Flush());

  Status status;
  // Fails because L0 has overlapping files.
  status = experimental::PromoteL0(db_, db_->DefaultColumnFamily());
  ASSERT_TRUE(status.IsInvalidArgument());

13776
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
13777 13778 13779 13780 13781 13782 13783 13784 13785 13786
  // Now there is a file in L1.
  ASSERT_GE(NumTableFilesAtLevel(1, 0), 1);

  ASSERT_OK(Put(Key(5), ""));
  ASSERT_OK(Flush());
  // Fails because L1 is non-empty.
  status = experimental::PromoteL0(db_, db_->DefaultColumnFamily());
  ASSERT_TRUE(status.IsInvalidArgument());
}

13787 13788 13789 13790 13791 13792 13793 13794 13795 13796 13797 13798 13799 13800 13801 13802
// Github issue #596
TEST_F(DBTest, HugeNumberOfLevels) {
  Options options = CurrentOptions();
  options.write_buffer_size = 2 * 1024 * 1024;         // 2MB
  options.max_bytes_for_level_base = 2 * 1024 * 1024;  // 2MB
  options.num_levels = 12;
  options.max_background_compactions = 10;
  options.max_bytes_for_level_multiplier = 2;
  options.level_compaction_dynamic_level_bytes = true;
  DestroyAndReopen(options);

  Random rnd(301);
  for (int i = 0; i < 300000; ++i) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
  }

13803
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
13804 13805
}

13806 13807 13808 13809 13810 13811 13812 13813 13814 13815 13816 13817 13818 13819 13820 13821 13822
// Github issue #595
// Large write batch with column families
TEST_F(DBTest, LargeBatchWithColumnFamilies) {
  Options options;
  options.env = env_;
  options = CurrentOptions(options);
  options.write_buffer_size = 100000;  // Small write buffer
  CreateAndReopenWithCF({"pikachu"}, options);
  int64_t j = 0;
  for (int i = 0; i < 5; i++) {
    for (int pass = 1; pass <= 3; pass++) {
      WriteBatch batch;
      size_t write_size = 1024 * 1024 * (5 + i);
      fprintf(stderr, "prepare: %ld MB, pass:%d\n", (write_size / 1024 / 1024),
              pass);
      for (;;) {
        std::string data(3000, j++ % 127 + 20);
S
sdong 已提交
13823
        data += ToString(j);
13824 13825 13826 13827 13828 13829 13830 13831 13832 13833 13834 13835 13836 13837
        batch.Put(handles_[0], Slice(data), Slice(data));
        if (batch.GetDataSize() > write_size) {
          break;
        }
      }
      fprintf(stderr, "write: %ld MB\n", (batch.GetDataSize() / 1024 / 1024));
      ASSERT_OK(dbfull()->Write(WriteOptions(), &batch));
      fprintf(stderr, "done\n");
    }
  }
  // make sure we can re-open it.
  ASSERT_OK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
}

13838 13839 13840 13841 13842 13843 13844 13845 13846 13847 13848 13849 13850 13851 13852 13853 13854 13855 13856 13857 13858 13859 13860 13861 13862 13863 13864 13865 13866 13867 13868 13869 13870 13871 13872 13873 13874 13875 13876 13877 13878 13879 13880 13881 13882 13883 13884 13885 13886 13887 13888 13889 13890 13891 13892 13893 13894 13895 13896 13897 13898 13899 13900
// Make sure that Flushes can proceed in parallel with CompactRange()
TEST_F(DBTest, FlushesInParallelWithCompactRange) {
  // iter == 0 -- leveled
  // iter == 1 -- leveled, but throw in a flush between two levels compacting
  // iter == 2 -- universal
  for (int iter = 0; iter < 3; ++iter) {
    Options options = CurrentOptions();
    if (iter < 2) {
      options.compaction_style = kCompactionStyleLevel;
    } else {
      options.compaction_style = kCompactionStyleUniversal;
    }
    options.write_buffer_size = 110 << 10;
    options.level0_file_num_compaction_trigger = 4;
    options.num_levels = 4;
    options.compression = kNoCompression;
    options.max_bytes_for_level_base = 450 << 10;
    options.target_file_size_base = 98 << 10;
    options.max_write_buffer_number = 2;

    DestroyAndReopen(options);

    Random rnd(301);
    for (int num = 0; num < 14; num++) {
      GenerateNewRandomFile(&rnd);
    }

    if (iter == 1) {
    rocksdb::SyncPoint::GetInstance()->LoadDependency(
        {{"DBImpl::RunManualCompaction()::1",
          "DBTest::FlushesInParallelWithCompactRange:1"},
         {"DBTest::FlushesInParallelWithCompactRange:2",
          "DBImpl::RunManualCompaction()::2"}});
    } else {
      rocksdb::SyncPoint::GetInstance()->LoadDependency(
          {{"CompactionJob::Run():Start",
            "DBTest::FlushesInParallelWithCompactRange:1"},
           {"DBTest::FlushesInParallelWithCompactRange:2",
            "CompactionJob::Run():End"}});
    }
    rocksdb::SyncPoint::GetInstance()->EnableProcessing();

    std::vector<std::thread> threads;
    threads.emplace_back([&]() { Compact("a", "z"); });

    TEST_SYNC_POINT("DBTest::FlushesInParallelWithCompactRange:1");

    // this has to start a flush. if flushes are blocked, this will try to
    // create
    // 3 memtables, and that will fail because max_write_buffer_number is 2
    for (int num = 0; num < 3; num++) {
      GenerateNewRandomFile(&rnd, /* nowait */ true);
    }

    TEST_SYNC_POINT("DBTest::FlushesInParallelWithCompactRange:2");

    for (auto& t : threads) {
      t.join();
    }
    rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  }
}

13901 13902 13903 13904 13905 13906 13907 13908 13909 13910 13911 13912 13913 13914 13915 13916 13917 13918 13919 13920 13921 13922 13923 13924 13925 13926 13927 13928
TEST_F(DBTest, UniversalCompactionTargetLevel) {
  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;     // 100KB
  options.num_levels = 7;
  options.disable_auto_compactions = true;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  // Generate 3 overlapping files
  Random rnd(301);
  for (int i = 0; i < 210; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 100)));
  }
  ASSERT_OK(Flush());

  for (int i = 200; i < 300; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 100)));
  }
  ASSERT_OK(Flush());

  for (int i = 250; i < 260; i++) {
    ASSERT_OK(Put(Key(i), RandomString(&rnd, 100)));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("3", FilesPerLevel(0));
  // Compact all files into 1 file and put it in L4
13929 13930 13931 13932
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 4;
  db_->CompactRange(compact_options, nullptr, nullptr);
13933 13934 13935
  ASSERT_EQ("0,0,0,0,1", FilesPerLevel(0));
}

13936 13937 13938 13939 13940 13941 13942 13943 13944 13945 13946 13947 13948 13949 13950 13951 13952 13953 13954 13955 13956
// This tests for a bug that could cause two level0 compactions running
// concurrently
TEST_F(DBTest, SuggestCompactRangeNoTwoLevel0Compactions) {
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 110 << 10;
  options.level0_file_num_compaction_trigger = 4;
  options.num_levels = 4;
  options.compression = kNoCompression;
  options.max_bytes_for_level_base = 450 << 10;
  options.target_file_size_base = 98 << 10;
  options.max_write_buffer_number = 2;
  options.max_background_compactions = 2;

  DestroyAndReopen(options);

  // fill up the DB
  Random rnd(301);
  for (int num = 0; num < 10; num++) {
    GenerateNewRandomFile(&rnd);
  }
13957
  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
13958 13959 13960 13961 13962 13963 13964 13965 13966 13967 13968 13969 13970 13971 13972 13973 13974 13975 13976 13977 13978 13979 13980 13981 13982 13983 13984 13985

  rocksdb::SyncPoint::GetInstance()->LoadDependency(
      {{"CompactionJob::Run():Start",
        "DBTest::SuggestCompactRangeNoTwoLevel0Compactions:1"},
       {"DBTest::SuggestCompactRangeNoTwoLevel0Compactions:2",
        "CompactionJob::Run():End"}});

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  // trigger L0 compaction
  for (int num = 0; num < options.level0_file_num_compaction_trigger + 1;
       num++) {
    GenerateNewRandomFile(&rnd, /* nowait */ true);
  }

  TEST_SYNC_POINT("DBTest::SuggestCompactRangeNoTwoLevel0Compactions:1");

  GenerateNewRandomFile(&rnd, /* nowait */ true);
  dbfull()->TEST_WaitForFlushMemTable();
  ASSERT_OK(experimental::SuggestCompactRange(db_, nullptr, nullptr));
  for (int num = 0; num < options.level0_file_num_compaction_trigger + 1;
       num++) {
    GenerateNewRandomFile(&rnd, /* nowait */ true);
  }

  TEST_SYNC_POINT("DBTest::SuggestCompactRangeNoTwoLevel0Compactions:2");
}

S
sdong 已提交
13986 13987 13988 13989 13990 13991 13992 13993 13994 13995 13996 13997 13998 13999 14000 14001 14002 14003 14004 14005 14006 14007 14008 14009 14010 14011 14012 14013 14014 14015 14016 14017 14018 14019 14020 14021 14022 14023 14024 14025 14026 14027 14028 14029 14030 14031 14032 14033 14034 14035 14036 14037 14038 14039 14040 14041 14042 14043 14044 14045 14046 14047 14048 14049 14050 14051 14052 14053 14054 14055 14056 14057 14058 14059 14060 14061 14062 14063 14064 14065 14066 14067 14068 14069 14070 14071 14072 14073 14074 14075 14076 14077 14078 14079 14080 14081 14082 14083 14084 14085 14086 14087 14088 14089 14090 14091 14092 14093 14094 14095 14096 14097 14098 14099 14100 14101 14102 14103 14104 14105 14106 14107 14108 14109 14110 14111 14112 14113 14114 14115 14116 14117 14118 14119 14120 14121 14122 14123 14124 14125 14126 14127 14128 14129 14130 14131 14132 14133 14134 14135 14136 14137 14138 14139 14140 14141 14142 14143 14144 14145 14146 14147 14148 14149 14150 14151 14152 14153
TEST_F(DBTest, DelayedWriteRate) {
  Options options;
  options.env = env_;
  env_->no_sleep_ = true;
  options = CurrentOptions(options);
  options.write_buffer_size = 100000;  // Small write buffer
  options.max_write_buffer_number = 256;
  options.disable_auto_compactions = true;
  options.level0_file_num_compaction_trigger = 3;
  options.level0_slowdown_writes_trigger = 3;
  options.level0_stop_writes_trigger = 999999;
  options.delayed_write_rate = 200000;  // About 200KB/s limited rate

  CreateAndReopenWithCF({"pikachu"}, options);

  for (int i = 0; i < 3; i++) {
    Put(Key(i), std::string(10000, 'x'));
    Flush();
  }

  // These writes will be slowed down to 1KB/s
  size_t estimated_total_size = 0;
  Random rnd(301);
  for (int i = 0; i < 3000; i++) {
    auto rand_num = rnd.Uniform(20);
    // Spread the size range to more.
    size_t entry_size = rand_num * rand_num * rand_num;
    WriteOptions wo;
    // For a small chance, set a timeout.
    if (rnd.Uniform(20) == 6) {
      wo.timeout_hint_us = 1500;
    }
    Put(Key(i), std::string(entry_size, 'x'), wo);
    estimated_total_size += entry_size + 20;
    // Ocassionally sleep a while
    if (rnd.Uniform(20) == 6) {
      env_->SleepForMicroseconds(2666);
    }
  }
  uint64_t estimated_sleep_time =
      estimated_total_size / options.delayed_write_rate * 1000000U;
  ASSERT_GT(env_->addon_time_.load(), estimated_sleep_time * 0.8);
  ASSERT_LT(env_->addon_time_.load(), estimated_sleep_time * 1.1);

  env_->no_sleep_ = false;
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

TEST_F(DBTest, SoftLimit) {
  Options options;
  options.env = env_;
  options = CurrentOptions(options);
  options.write_buffer_size = 100000;  // Small write buffer
  options.max_write_buffer_number = 256;
  options.level0_file_num_compaction_trigger = 3;
  options.level0_slowdown_writes_trigger = 3;
  options.level0_stop_writes_trigger = 999999;
  options.delayed_write_rate = 200000;  // About 200KB/s limited rate
  options.soft_rate_limit = 1.1;
  options.target_file_size_base = 99999999;  // All into one file
  options.max_bytes_for_level_base = 50000;
  options.compression = kNoCompression;

  Reopen(options);
  Put(Key(0), "");

  // Only allow two compactions
  port::Mutex mut;
  port::CondVar cv(&mut);
  std::atomic<int> compaction_cnt(0);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "VersionSet::LogAndApply:WriteManifest", [&](void* arg) {
        // Three flushes and the first compaction,
        // three flushes and the second compaction go through.
        MutexLock l(&mut);
        while (compaction_cnt.load() >= 8) {
          cv.Wait();
        }
        compaction_cnt.fetch_add(1);
      });

  std::atomic<int> sleep_count(0);
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::DelayWrite:Sleep", [&](void* arg) { sleep_count.fetch_add(1); });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  for (int i = 0; i < 3; i++) {
    Put(Key(i), std::string(5000, 'x'));
    Put(Key(100 - i), std::string(5000, 'x'));
    Flush();
  }
  while (compaction_cnt.load() < 4 || NumTableFilesAtLevel(0) > 0) {
    env_->SleepForMicroseconds(1000);
  }
  // Now there is one L1 file but doesn't trigger soft_rate_limit
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_EQ(sleep_count.load(), 0);

  for (int i = 0; i < 3; i++) {
    Put(Key(10 + i), std::string(5000, 'x'));
    Put(Key(90 - i), std::string(5000, 'x'));
    Flush();
  }
  while (compaction_cnt.load() < 8 || NumTableFilesAtLevel(0) > 0) {
    env_->SleepForMicroseconds(1000);
  }
  ASSERT_EQ(NumTableFilesAtLevel(1), 1);
  ASSERT_EQ(sleep_count.load(), 0);

  // Slowdown is triggered now
  for (int i = 0; i < 10; i++) {
    Put(Key(i), std::string(100, 'x'));
  }
  ASSERT_GT(sleep_count.load(), 0);

  {
    MutexLock l(&mut);
    compaction_cnt.store(7);
    cv.SignalAll();
  }
  while (NumTableFilesAtLevel(1) > 0) {
    env_->SleepForMicroseconds(1000);
  }

  // Slowdown is not triggered any more.
  sleep_count.store(0);
  // Slowdown is not triggered now
  for (int i = 0; i < 10; i++) {
    Put(Key(i), std::string(100, 'x'));
  }
  ASSERT_EQ(sleep_count.load(), 0);

  // shrink level base so L2 will hit soft limit easier.
  ASSERT_OK(dbfull()->SetOptions({
      {"max_bytes_for_level_base", "5000"},
  }));
  compaction_cnt.store(7);
  Flush();

  while (NumTableFilesAtLevel(0) == 0) {
    env_->SleepForMicroseconds(1000);
  }

  // Slowdown is triggered now
  for (int i = 0; i < 10; i++) {
    Put(Key(i), std::string(100, 'x'));
  }
  ASSERT_GT(sleep_count.load(), 0);

  {
    MutexLock l(&mut);
    compaction_cnt.store(7);
    cv.SignalAll();
  }

  while (NumTableFilesAtLevel(2) != 0) {
    env_->SleepForMicroseconds(1000);
  }

  // Slowdown is not triggered anymore
  sleep_count.store(0);
  for (int i = 0; i < 10; i++) {
    Put(Key(i), std::string(100, 'x'));
  }
  ASSERT_EQ(sleep_count.load(), 0);
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

14154 14155 14156 14157 14158 14159 14160 14161 14162 14163 14164 14165 14166 14167 14168 14169 14170 14171 14172 14173 14174 14175 14176 14177 14178 14179 14180 14181 14182 14183 14184 14185 14186 14187 14188 14189 14190 14191 14192 14193 14194 14195 14196 14197 14198 14199 14200 14201
TEST_F(DBTest, ForceBottommostLevelCompaction) {
  int32_t trivial_move = 0;
  int32_t non_trivial_move = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:TrivialMove",
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial",
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  Options options;
  options.write_buffer_size = 100000000;
  options = CurrentOptions(options);
  DestroyAndReopen(options);

  int32_t value_size = 10 * 1024;  // 10 KB

  Random rnd(301);
  std::vector<std::string> values;
  // File with keys [ 0 => 99 ]
  for (int i = 0; i < 100; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1", FilesPerLevel(0));
  // Compaction will do L0=>L1 (trivial move) then move L1 files to L3
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
  compact_options.target_level = 3;
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
  ASSERT_EQ("0,0,0,1", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 1);
  ASSERT_EQ(non_trivial_move, 0);

  // File with keys [ 100 => 199 ]
  for (int i = 100; i < 200; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1,0,0,1", FilesPerLevel(0));
  // Compaction will do L0=>L1 L1=>L2 L2=>L3 (3 trivial moves)
  // then compacte the bottommost level L3=>L3 (non trivial move)
  compact_options = CompactRangeOptions();
14202 14203
  compact_options.bottommost_level_compaction =
      BottommostLevelCompaction::kForce;
14204 14205 14206 14207 14208
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
  ASSERT_EQ("0,0,0,1", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 4);
  ASSERT_EQ(non_trivial_move, 1);

14209 14210 14211 14212 14213 14214 14215 14216 14217 14218 14219 14220 14221 14222 14223 14224 14225 14226 14227 14228 14229
  // File with keys [ 200 => 299 ]
  for (int i = 200; i < 300; i++) {
    values.push_back(RandomString(&rnd, value_size));
    ASSERT_OK(Put(Key(i), values[i]));
  }
  ASSERT_OK(Flush());

  ASSERT_EQ("1,0,0,1", FilesPerLevel(0));
  trivial_move = 0;
  non_trivial_move = 0;
  compact_options = CompactRangeOptions();
  compact_options.bottommost_level_compaction =
      BottommostLevelCompaction::kSkip;
  // Compaction will do L0=>L1 L1=>L2 L2=>L3 (3 trivial moves)
  // and will skip bottommost level compaction
  ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
  ASSERT_EQ("0,0,0,2", FilesPerLevel(0));
  ASSERT_EQ(trivial_move, 3);
  ASSERT_EQ(non_trivial_move, 0);

  for (int i = 0; i < 300; i++) {
14230 14231 14232 14233 14234 14235
    ASSERT_EQ(Get(Key(i)), values[i]);
  }

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
}

14236 14237 14238 14239 14240 14241 14242 14243 14244 14245 14246 14247 14248 14249 14250 14251 14252 14253 14254 14255
TEST_F(DBTest, FailWhenCompressionNotSupportedTest) {
  CompressionType compressions[] = {kZlibCompression, kBZip2Compression,
                                    kLZ4Compression,  kLZ4HCCompression};
  for (int iter = 0; iter < 4; ++iter) {
    if (!CompressionTypeSupported(compressions[iter])) {
      // not supported, we should fail the Open()
      Options options = CurrentOptions();
      options.compression = compressions[iter];
      ASSERT_TRUE(!TryReopen(options).ok());
      // Try if CreateColumnFamily also fails
      options.compression = kNoCompression;
      ASSERT_OK(TryReopen(options));
      ColumnFamilyOptions cf_options(options);
      cf_options.compression = compressions[iter];
      ColumnFamilyHandle* handle;
      ASSERT_TRUE(!db_->CreateColumnFamily(cf_options, "name", &handle).ok());
    }
  }
}

14256 14257 14258 14259 14260 14261 14262 14263 14264 14265 14266 14267 14268 14269 14270 14271 14272 14273 14274
TEST_F(DBTest, RowCache) {
  Options options = CurrentOptions();
  options.statistics = rocksdb::CreateDBStatistics();
  options.row_cache = NewLRUCache(8192);
  DestroyAndReopen(options);

  ASSERT_OK(Put("foo", "bar"));
  ASSERT_OK(Flush());

  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 0);
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 0);
  ASSERT_EQ(Get("foo"), "bar");
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 0);
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 1);
  ASSERT_EQ(Get("foo"), "bar");
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 1);
  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 1);
}

14275 14276 14277
// TODO(3.13): fix the issue of Seek() + Prev() which might not necessary
//             return the biggest key which is smaller than the seek key.
TEST_F(DBTest, DISABLED_PrevAfterMerge) {
14278 14279 14280 14281 14282 14283 14284 14285 14286 14287 14288 14289 14290 14291 14292 14293 14294 14295 14296 14297 14298 14299
  Options options;
  options.create_if_missing = true;
  options.merge_operator = MergeOperators::CreatePutOperator();
  DestroyAndReopen(options);

  // write three entries with different keys using Merge()
  WriteOptions wopts;
  db_->Merge(wopts, "1", "data1");
  db_->Merge(wopts, "2", "data2");
  db_->Merge(wopts, "3", "data3");

  std::unique_ptr<Iterator> it(db_->NewIterator(ReadOptions()));

  it->Seek("2");
  ASSERT_TRUE(it->Valid());
  ASSERT_EQ("2", it->key().ToString());

  it->Prev();
  ASSERT_TRUE(it->Valid());
  ASSERT_EQ("1", it->key().ToString());
}

14300 14301 14302 14303 14304 14305 14306 14307 14308 14309 14310 14311 14312 14313 14314 14315 14316 14317 14318 14319 14320 14321 14322 14323 14324 14325 14326 14327 14328 14329 14330 14331 14332 14333
TEST_F(DBTest, DeletingOldWalAfterDrop) {
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
      { { "Test:AllowFlushes", "DBImpl::BGWorkFlush" },
        { "DBImpl::BGWorkFlush:done", "Test:WaitForFlush"} });
  rocksdb::SyncPoint::GetInstance()->ClearTrace();

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  Options options = CurrentOptions();
  options.max_total_wal_size = 8192;
  options.compression = kNoCompression;
  options.write_buffer_size = 1 << 20;
  options.level0_file_num_compaction_trigger = (1<<30);
  options.level0_slowdown_writes_trigger = (1<<30);
  options.level0_stop_writes_trigger = (1<<30);
  options.disable_auto_compactions = true;
  DestroyAndReopen(options);
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  CreateColumnFamilies({"cf1", "cf2"}, options);
  ASSERT_OK(Put(0, "key1", DummyString(8192)));
  ASSERT_OK(Put(0, "key2", DummyString(8192)));
  // the oldest wal should now be getting_flushed
  ASSERT_OK(db_->DropColumnFamily(handles_[0]));
  // all flushes should now do nothing because their CF is dropped
  TEST_SYNC_POINT("Test:AllowFlushes");
  TEST_SYNC_POINT("Test:WaitForFlush");
  uint64_t lognum1 = dbfull()->TEST_LogfileNumber();
  ASSERT_OK(Put(1, "key3", DummyString(8192)));
  ASSERT_OK(Put(1, "key4", DummyString(8192)));
  // new wal should have been created
  uint64_t lognum2 = dbfull()->TEST_LogfileNumber();
  EXPECT_GT(lognum2, lognum1);
}

14334
}  // namespace rocksdb
J
jorlow@chromium.org 已提交
14335

D
Dmitri Smirnov 已提交
14336 14337
#endif

J
jorlow@chromium.org 已提交
14338
int main(int argc, char** argv) {
D
Dmitri Smirnov 已提交
14339
#if !(defined NDEBUG) || !defined(OS_WIN)
14340
  rocksdb::port::InstallStackTraceHandler();
I
Igor Sugak 已提交
14341 14342
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
D
Dmitri Smirnov 已提交
14343 14344 14345
#else
  return 0;
#endif
J
jorlow@chromium.org 已提交
14346
}