|
|
|
// 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.
|
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
//
|
|
|
|
// The representation of a DBImpl consists of a set of Versions. The
|
|
|
|
// newest version is called "current". Older versions may be kept
|
|
|
|
// around to provide a consistent view to live iterators.
|
|
|
|
//
|
|
|
|
// Each Version keeps track of a set of Table files per level. The
|
|
|
|
// entire set of versions is maintained in a VersionSet.
|
|
|
|
//
|
|
|
|
// Version,VersionSet are thread-compatible, but require external
|
|
|
|
// synchronization on all accesses.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
#include <map>
|
|
|
|
#include <memory>
|
|
|
|
#include <set>
|
|
|
|
#include <vector>
|
|
|
|
#include <deque>
|
|
|
|
#include <atomic>
|
|
|
|
#include <limits>
|
|
|
|
#include "db/dbformat.h"
|
|
|
|
#include "db/version_builder.h"
|
|
|
|
#include "db/version_edit.h"
|
|
|
|
#include "port/port.h"
|
|
|
|
#include "db/table_cache.h"
|
|
|
|
#include "db/compaction.h"
|
CompactionPicker
Summary:
This is a big one. This diff moves all the code related to picking compactions from VersionSet to new class CompactionPicker. Column families' compactions will be completely separate processes, so we need to have multiple CompactionPickers.
To make this easier to review, most of the code change is just copy/paste. There is also a small change not to use VersionSet::current_, but rather to take `Version* version` as a parameter. Most of the other code is exactly the same.
In future diffs, I will also make some improvements to CompactionPickers. I think the most important part will be encapsulating it better. Currently Version, VersionSet, Compaction and CompactionPicker are all friend classes, which makes it harder to change the implementation.
This diff depends on D15171, D15183, D15189 and D15201
Test Plan: `make check`
Reviewers: kailiu, sdong, dhruba, haobo
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15207
11 years ago
|
|
|
#include "db/compaction_picker.h"
|
|
|
|
#include "db/column_family.h"
|
|
|
|
#include "db/log_reader.h"
|
hints for narrowing down FindFile range and avoiding checking unrelevant L0 files
Summary:
The file tree structure in Version is prebuilt and the range of each file is known.
On the Get() code path, we do binary search in FindFile() by comparing
target key with each file's largest key and also check the range for each L0 file.
With some pre-calculated knowledge, each key comparision that has been done can serve
as a hint to narrow down further searches:
(1) If a key falls within a L0 file's range, we can safely skip the next
file if its range does not overlap with the current one.
(2) If a key falls within a file's range in level L0 - Ln-1, we should only
need to binary search in the next level for files that overlap with the current one.
(1) will be able to skip some files depending one the key distribution.
(2) can greatly reduce the range of binary search, especially for bottom
levels, given that one file most likely only overlaps with N files from
the level below (where N is max_bytes_for_level_multiplier). So on level
L, we will only look at ~N files instead of N^L files.
Some inital results: measured with 500M key DB, when write is light (10k/s = 1.2M/s), this
improves QPS ~7% on top of blocked bloom. When write is heavier (80k/s =
9.6M/s), it gives us ~13% improvement.
Test Plan: make all check
Reviewers: haobo, igor, dhruba, sdong, yhchiang
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D17205
11 years ago
|
|
|
#include "db/file_indexer.h"
|
Push- instead of pull-model for managing Write stalls
Summary:
Introducing WriteController, which is a source of truth about per-DB write delays. Let's define an DB epoch as a period where there are no flushes and compactions (i.e. new epoch is started when flush or compaction finishes). Each epoch can either:
* proceed with all writes without delay
* delay all writes by fixed time
* stop all writes
The three modes are recomputed at each epoch change (flush, compaction), rather than on every write (which is currently the case).
When we have a lot of column families, our current pull behavior adds a big overhead, since we need to loop over every column family for every write. With new push model, overhead on Write code-path is minimal.
This is just the start. Next step is to also take care of stalls introduced by slow memtable flushes. The final goal is to eliminate function MakeRoomForWrite(), which currently needs to be called for every column family by every write.
Test Plan: make check for now. I'll add some unit tests later. Also, perf test.
Reviewers: dhruba, yhchiang, MarkCallaghan, sdong, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D22791
10 years ago
|
|
|
#include "db/write_controller.h"
|
|
|
|
#include "util/instrumented_mutex.h"
|
|
|
|
|
|
|
|
namespace rocksdb {
|
|
|
|
|
|
|
|
namespace log {
|
|
|
|
class Writer;
|
|
|
|
}
|
|
|
|
|
|
|
|
class Compaction;
|
|
|
|
class Iterator;
|
|
|
|
class LogBuffer;
|
|
|
|
class LookupKey;
|
|
|
|
class MemTable;
|
|
|
|
class Version;
|
|
|
|
class VersionSet;
|
|
|
|
class WriteBuffer;
|
|
|
|
class MergeContext;
|
|
|
|
class ColumnFamilyData;
|
|
|
|
class ColumnFamilySet;
|
|
|
|
class TableCache;
|
In DB::NewIterator(), try to allocate the whole iterator tree in an arena
Summary:
In this patch, try to allocate the whole iterator tree starting from DBIter from an arena
1. ArenaWrappedDBIter is created when serves as the entry point of an iterator tree, with an arena in it.
2. Add an option to create iterator from arena for following iterators: DBIter, MergingIterator, MemtableIterator, all mem table's iterators, all table reader's iterators and two level iterator.
3. MergeIteratorBuilder is created to incrementally build the tree of internal iterators. It is passed to mem table list and version set and add iterators to it.
Limitations:
(1) Only DB::NewIterator() without tailing uses the arena. Other cases, including readonly DB and compactions are still from malloc
(2) Two level iterator itself is allocated in arena, but not iterators inside it.
Test Plan: make all check
Reviewers: ljin, haobo
Reviewed By: haobo
Subscribers: leveldb, dhruba, yhchiang, igor
Differential Revision: https://reviews.facebook.net/D18513
11 years ago
|
|
|
class MergeIteratorBuilder;
|
|
|
|
|
create compressed_levels_ in Version, allocate its space using arena. Make Version::Get, Version::FindFile faster
Summary:
Define CompressedFileMetaData that just contains fd, smallest_slice, largest_slice. Create compressed_levels_ in Version, the space is allocated using arena
Thus increase the file meta data locality, speed up "Get" and "FindFile"
benchmark with in-memory tmpfs, could have 4% improvement under "random read" and 2% improvement under "read while writing"
benchmark command:
./db_bench --db=/mnt/db/rocksdb --num_levels=6 --key_size=20 --prefix_size=20 --keys_per_prefix=0 --value_size=100 --block_size=4096 --cache_size=17179869184 --cache_numshardbits=6 --compression_type=none --compression_ratio=1 --min_level_to_compress=-1 --disable_seek_compaction=1 --hard_rate_limit=2 --write_buffer_size=134217728 --max_write_buffer_number=2 --level0_file_num_compaction_trigger=8 --target_file_size_base=33554432 --max_bytes_for_level_base=1073741824 --disable_wal=0 --sync=0 --disable_data_sync=1 --verify_checksum=1 --delete_obsolete_files_period_micros=314572800 --max_grandparent_overlap_factor=10 --max_background_compactions=4 --max_background_flushes=0 --level0_slowdown_writes_trigger=16 --level0_stop_writes_trigger=24 --statistics=0 --stats_per_interval=0 --stats_interval=1048576 --histogram=0 --use_plain_table=1 --open_files=-1 --mmap_read=1 --mmap_write=0 --memtablerep=prefix_hash --bloom_bits=10 --bloom_locality=1 --perf_level=0 --benchmarks=readwhilewriting,readwhilewriting,readwhilewriting --use_existing_db=1 --num=52428800 --threads=1 —writes_per_second=81920
Read Random:
From 1.8363 ms/op, improve to 1.7587 ms/op.
Read while writing:
From 2.985 ms/op, improve to 2.924 ms/op.
Test Plan:
make all check
Reviewers: ljin, haobo, yhchiang, sdong
Reviewed By: sdong
Subscribers: dhruba, igor
Differential Revision: https://reviews.facebook.net/D19419
11 years ago
|
|
|
// Return the smallest index i such that file_level.files[i]->largest >= key.
|
|
|
|
// Return file_level.num_files if there is no such file.
|
|
|
|
// REQUIRES: "file_level.files" contains a sorted list of
|
|
|
|
// non-overlapping files.
|
|
|
|
extern int FindFile(const InternalKeyComparator& icmp,
|
|
|
|
const LevelFilesBrief& file_level,
|
create compressed_levels_ in Version, allocate its space using arena. Make Version::Get, Version::FindFile faster
Summary:
Define CompressedFileMetaData that just contains fd, smallest_slice, largest_slice. Create compressed_levels_ in Version, the space is allocated using arena
Thus increase the file meta data locality, speed up "Get" and "FindFile"
benchmark with in-memory tmpfs, could have 4% improvement under "random read" and 2% improvement under "read while writing"
benchmark command:
./db_bench --db=/mnt/db/rocksdb --num_levels=6 --key_size=20 --prefix_size=20 --keys_per_prefix=0 --value_size=100 --block_size=4096 --cache_size=17179869184 --cache_numshardbits=6 --compression_type=none --compression_ratio=1 --min_level_to_compress=-1 --disable_seek_compaction=1 --hard_rate_limit=2 --write_buffer_size=134217728 --max_write_buffer_number=2 --level0_file_num_compaction_trigger=8 --target_file_size_base=33554432 --max_bytes_for_level_base=1073741824 --disable_wal=0 --sync=0 --disable_data_sync=1 --verify_checksum=1 --delete_obsolete_files_period_micros=314572800 --max_grandparent_overlap_factor=10 --max_background_compactions=4 --max_background_flushes=0 --level0_slowdown_writes_trigger=16 --level0_stop_writes_trigger=24 --statistics=0 --stats_per_interval=0 --stats_interval=1048576 --histogram=0 --use_plain_table=1 --open_files=-1 --mmap_read=1 --mmap_write=0 --memtablerep=prefix_hash --bloom_bits=10 --bloom_locality=1 --perf_level=0 --benchmarks=readwhilewriting,readwhilewriting,readwhilewriting --use_existing_db=1 --num=52428800 --threads=1 —writes_per_second=81920
Read Random:
From 1.8363 ms/op, improve to 1.7587 ms/op.
Read while writing:
From 2.985 ms/op, improve to 2.924 ms/op.
Test Plan:
make all check
Reviewers: ljin, haobo, yhchiang, sdong
Reviewed By: sdong
Subscribers: dhruba, igor
Differential Revision: https://reviews.facebook.net/D19419
11 years ago
|
|
|
const Slice& key);
|
|
|
|
|
|
|
|
// Returns true iff some file in "files" overlaps the user key range
|
|
|
|
// [*smallest,*largest].
|
|
|
|
// smallest==nullptr represents a key smaller than all keys in the DB.
|
|
|
|
// largest==nullptr represents a key largest than all keys in the DB.
|
create compressed_levels_ in Version, allocate its space using arena. Make Version::Get, Version::FindFile faster
Summary:
Define CompressedFileMetaData that just contains fd, smallest_slice, largest_slice. Create compressed_levels_ in Version, the space is allocated using arena
Thus increase the file meta data locality, speed up "Get" and "FindFile"
benchmark with in-memory tmpfs, could have 4% improvement under "random read" and 2% improvement under "read while writing"
benchmark command:
./db_bench --db=/mnt/db/rocksdb --num_levels=6 --key_size=20 --prefix_size=20 --keys_per_prefix=0 --value_size=100 --block_size=4096 --cache_size=17179869184 --cache_numshardbits=6 --compression_type=none --compression_ratio=1 --min_level_to_compress=-1 --disable_seek_compaction=1 --hard_rate_limit=2 --write_buffer_size=134217728 --max_write_buffer_number=2 --level0_file_num_compaction_trigger=8 --target_file_size_base=33554432 --max_bytes_for_level_base=1073741824 --disable_wal=0 --sync=0 --disable_data_sync=1 --verify_checksum=1 --delete_obsolete_files_period_micros=314572800 --max_grandparent_overlap_factor=10 --max_background_compactions=4 --max_background_flushes=0 --level0_slowdown_writes_trigger=16 --level0_stop_writes_trigger=24 --statistics=0 --stats_per_interval=0 --stats_interval=1048576 --histogram=0 --use_plain_table=1 --open_files=-1 --mmap_read=1 --mmap_write=0 --memtablerep=prefix_hash --bloom_bits=10 --bloom_locality=1 --perf_level=0 --benchmarks=readwhilewriting,readwhilewriting,readwhilewriting --use_existing_db=1 --num=52428800 --threads=1 —writes_per_second=81920
Read Random:
From 1.8363 ms/op, improve to 1.7587 ms/op.
Read while writing:
From 2.985 ms/op, improve to 2.924 ms/op.
Test Plan:
make all check
Reviewers: ljin, haobo, yhchiang, sdong
Reviewed By: sdong
Subscribers: dhruba, igor
Differential Revision: https://reviews.facebook.net/D19419
11 years ago
|
|
|
// REQUIRES: If disjoint_sorted_files, file_level.files[]
|
|
|
|
// contains disjoint ranges in sorted order.
|
|
|
|
extern bool SomeFileOverlapsRange(
|
|
|
|
const InternalKeyComparator& icmp,
|
|
|
|
bool disjoint_sorted_files,
|
|
|
|
const LevelFilesBrief& file_level,
|
|
|
|
const Slice* smallest_user_key,
|
|
|
|
const Slice* largest_user_key);
|
|
|
|
|
|
|
|
// Generate LevelFilesBrief from vector<FdWithKeyRange*>
|
|
|
|
// Would copy smallest_key and largest_key data to sequential memory
|
|
|
|
// arena: Arena used to allocate the memory
|
|
|
|
extern void DoGenerateLevelFilesBrief(LevelFilesBrief* file_level,
|
|
|
|
const std::vector<FileMetaData*>& files,
|
|
|
|
Arena* arena);
|
|
|
|
|
|
|
|
class VersionStorageInfo {
|
|
|
|
public:
|
|
|
|
VersionStorageInfo(const InternalKeyComparator* internal_comparator,
|
|
|
|
const Comparator* user_comparator, int num_levels,
|
|
|
|
CompactionStyle compaction_style,
|
|
|
|
VersionStorageInfo* src_vstorage);
|
|
|
|
~VersionStorageInfo();
|
In DB::NewIterator(), try to allocate the whole iterator tree in an arena
Summary:
In this patch, try to allocate the whole iterator tree starting from DBIter from an arena
1. ArenaWrappedDBIter is created when serves as the entry point of an iterator tree, with an arena in it.
2. Add an option to create iterator from arena for following iterators: DBIter, MergingIterator, MemtableIterator, all mem table's iterators, all table reader's iterators and two level iterator.
3. MergeIteratorBuilder is created to incrementally build the tree of internal iterators. It is passed to mem table list and version set and add iterators to it.
Limitations:
(1) Only DB::NewIterator() without tailing uses the arena. Other cases, including readonly DB and compactions are still from malloc
(2) Two level iterator itself is allocated in arena, but not iterators inside it.
Test Plan: make all check
Reviewers: ljin, haobo
Reviewed By: haobo
Subscribers: leveldb, dhruba, yhchiang, igor
Differential Revision: https://reviews.facebook.net/D18513
11 years ago
|
|
|
|
|
|
|
void Reserve(int level, size_t size) { files_[level].reserve(size); }
|
|
|
|
|
|
|
|
void AddFile(int level, FileMetaData* f);
|
|
|
|
|
|
|
|
void SetFinalized() { finalized_ = true; }
|
|
|
|
|
|
|
|
// Update num_non_empty_levels_.
|
|
|
|
void UpdateNumNonEmptyLevels();
|
|
|
|
|
|
|
|
void GenerateFileIndexer() {
|
|
|
|
file_indexer_.UpdateIndex(&arena_, num_non_empty_levels_, files_);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update the accumulated stats from a file-meta.
|
|
|
|
void UpdateAccumulatedStats(FileMetaData* file_meta);
|
|
|
|
|
|
|
|
void ComputeCompensatedSizes();
|
|
|
|
|
|
|
|
// Updates internal structures that keep track of compaction scores
|
|
|
|
// We use compaction scores to figure out which compaction to do next
|
|
|
|
// REQUIRES: db_mutex held!!
|
|
|
|
// TODO find a better way to pass compaction_options_fifo.
|
|
|
|
void ComputeCompactionScore(
|
|
|
|
const MutableCFOptions& mutable_cf_options,
|
|
|
|
const CompactionOptionsFIFO& compaction_options_fifo);
|
|
|
|
|
|
|
|
// Generate level_files_brief_ from files_
|
|
|
|
void GenerateLevelFilesBrief();
|
|
|
|
// Sort all files for this version based on their file size and
|
|
|
|
// record results in files_by_size_. The largest files are listed first.
|
|
|
|
void UpdateFilesBySize();
|
create compressed_levels_ in Version, allocate its space using arena. Make Version::Get, Version::FindFile faster
Summary:
Define CompressedFileMetaData that just contains fd, smallest_slice, largest_slice. Create compressed_levels_ in Version, the space is allocated using arena
Thus increase the file meta data locality, speed up "Get" and "FindFile"
benchmark with in-memory tmpfs, could have 4% improvement under "random read" and 2% improvement under "read while writing"
benchmark command:
./db_bench --db=/mnt/db/rocksdb --num_levels=6 --key_size=20 --prefix_size=20 --keys_per_prefix=0 --value_size=100 --block_size=4096 --cache_size=17179869184 --cache_numshardbits=6 --compression_type=none --compression_ratio=1 --min_level_to_compress=-1 --disable_seek_compaction=1 --hard_rate_limit=2 --write_buffer_size=134217728 --max_write_buffer_number=2 --level0_file_num_compaction_trigger=8 --target_file_size_base=33554432 --max_bytes_for_level_base=1073741824 --disable_wal=0 --sync=0 --disable_data_sync=1 --verify_checksum=1 --delete_obsolete_files_period_micros=314572800 --max_grandparent_overlap_factor=10 --max_background_compactions=4 --max_background_flushes=0 --level0_slowdown_writes_trigger=16 --level0_stop_writes_trigger=24 --statistics=0 --stats_per_interval=0 --stats_interval=1048576 --histogram=0 --use_plain_table=1 --open_files=-1 --mmap_read=1 --mmap_write=0 --memtablerep=prefix_hash --bloom_bits=10 --bloom_locality=1 --perf_level=0 --benchmarks=readwhilewriting,readwhilewriting,readwhilewriting --use_existing_db=1 --num=52428800 --threads=1 —writes_per_second=81920
Read Random:
From 1.8363 ms/op, improve to 1.7587 ms/op.
Read while writing:
From 2.985 ms/op, improve to 2.924 ms/op.
Test Plan:
make all check
Reviewers: ljin, haobo, yhchiang, sdong
Reviewed By: sdong
Subscribers: dhruba, igor
Differential Revision: https://reviews.facebook.net/D19419
11 years ago
|
|
|
|
|
|
|
int MaxInputLevel() const;
|
|
|
|
|
|
|
|
// Returns the maxmimum compaction score for levels 1 to max
|
|
|
|
double max_compaction_score() const { return max_compaction_score_; }
|
|
|
|
|
|
|
|
// See field declaration
|
|
|
|
int max_compaction_score_level() const { return max_compaction_score_level_; }
|
|
|
|
|
|
|
|
// Return level number that has idx'th highest score
|
|
|
|
int CompactionScoreLevel(int idx) const { return compaction_level_[idx]; }
|
|
|
|
|
|
|
|
// Return idx'th highest score
|
|
|
|
double CompactionScore(int idx) const { return compaction_score_[idx]; }
|
|
|
|
|
|
|
|
void GetOverlappingInputs(
|
|
|
|
int level, const InternalKey* begin, // nullptr means before all keys
|
|
|
|
const InternalKey* end, // nullptr means after all keys
|
|
|
|
std::vector<FileMetaData*>* inputs,
|
|
|
|
int hint_index = -1, // index of overlap file
|
|
|
|
int* file_index = nullptr); // return index of overlap file
|
|
|
|
|
|
|
|
void GetOverlappingInputsBinarySearch(
|
|
|
|
int level, const Slice& begin, // nullptr means before all keys
|
|
|
|
const Slice& end, // nullptr means after all keys
|
|
|
|
std::vector<FileMetaData*>* inputs,
|
|
|
|
int hint_index, // index of overlap file
|
|
|
|
int* file_index); // return index of overlap file
|
|
|
|
|
|
|
|
void ExtendOverlappingInputs(
|
|
|
|
int level, const Slice& begin, // nullptr means before all keys
|
|
|
|
const Slice& end, // nullptr means after all keys
|
|
|
|
std::vector<FileMetaData*>* inputs,
|
|
|
|
unsigned int index); // start extending from this index
|
|
|
|
|
|
|
|
// Returns true iff some file in the specified level overlaps
|
|
|
|
// some part of [*smallest_user_key,*largest_user_key].
|
|
|
|
// smallest_user_key==NULL represents a key smaller than all keys in the DB.
|
|
|
|
// largest_user_key==NULL represents a key largest than all keys in the DB.
|
|
|
|
bool OverlapInLevel(int level, const Slice* smallest_user_key,
|
|
|
|
const Slice* largest_user_key);
|
|
|
|
|
[RocksDB] [MergeOperator] The new Merge Interface! Uses merge sequences.
Summary:
Here are the major changes to the Merge Interface. It has been expanded
to handle cases where the MergeOperator is not associative. It does so by stacking
up merge operations while scanning through the key history (i.e.: during Get() or
Compaction), until a valid Put/Delete/end-of-history is encountered; it then
applies all of the merge operations in the correct sequence starting with the
base/sentinel value.
I have also introduced an "AssociativeMerge" function which allows the user to
take advantage of associative merge operations (such as in the case of counters).
The implementation will always attempt to merge the operations/operands themselves
together when they are encountered, and will resort to the "stacking" method if
and only if the "associative-merge" fails.
This implementation is conjectured to allow MergeOperator to handle the general
case, while still providing the user with the ability to take advantage of certain
efficiencies in their own merge-operator / data-structure.
NOTE: This is a preliminary diff. This must still go through a lot of review,
revision, and testing. Feedback welcome!
Test Plan:
-This is a preliminary diff. I have only just begun testing/debugging it.
-I will be testing this with the existing MergeOperator use-cases and unit-tests
(counters, string-append, and redis-lists)
-I will be "desk-checking" and walking through the code with the help gdb.
-I will find a way of stress-testing the new interface / implementation using
db_bench, db_test, merge_test, and/or db_stress.
-I will ensure that my tests cover all cases: Get-Memtable,
Get-Immutable-Memtable, Get-from-Disk, Iterator-Range-Scan, Flush-Memtable-to-L0,
Compaction-L0-L1, Compaction-Ln-L(n+1), Put/Delete found, Put/Delete not-found,
end-of-history, end-of-file, etc.
-A lot of feedback from the reviewers.
Reviewers: haobo, dhruba, zshao, emayanke
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11499
12 years ago
|
|
|
// Returns true iff the first or last file in inputs contains
|
|
|
|
// an overlapping user key to the file "just outside" of it (i.e.
|
|
|
|
// just after the last file, or just before the first file)
|
|
|
|
// REQUIRES: "*inputs" is a sorted list of non-overlapping files
|
|
|
|
bool HasOverlappingUserKey(const std::vector<FileMetaData*>* inputs,
|
|
|
|
int level);
|
|
|
|
|
|
|
|
// Return the level at which we should place a new memtable compaction
|
|
|
|
// result that covers the range [smallest_user_key,largest_user_key].
|
|
|
|
int PickLevelForMemTableOutput(const MutableCFOptions& mutable_cf_options,
|
|
|
|
const Slice& smallest_user_key,
|
|
|
|
const Slice& largest_user_key);
|
|
|
|
|
|
|
|
int num_levels() const { return num_levels_; }
|
|
|
|
|
|
|
|
// REQUIRES: This version has been saved (see VersionSet::SaveTo)
|
|
|
|
int num_non_empty_levels() const {
|
|
|
|
assert(finalized_);
|
|
|
|
return num_non_empty_levels_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// REQUIRES: This version has been saved (see VersionSet::SaveTo)
|
|
|
|
int NumLevelFiles(int level) const {
|
|
|
|
assert(finalized_);
|
|
|
|
return static_cast<int>(files_[level].size());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the combined file size of all files at the specified level.
|
|
|
|
uint64_t NumLevelBytes(int level) const;
|
|
|
|
|
|
|
|
// REQUIRES: This version has been saved (see VersionSet::SaveTo)
|
|
|
|
const std::vector<FileMetaData*>& LevelFiles(int level) const {
|
|
|
|
return files_[level];
|
|
|
|
}
|
|
|
|
|
|
|
|
const rocksdb::LevelFilesBrief& LevelFilesBrief(int level) const {
|
|
|
|
assert(level < static_cast<int>(level_files_brief_.size()));
|
|
|
|
return level_files_brief_[level];
|
|
|
|
}
|
|
|
|
|
|
|
|
// REQUIRES: This version has been saved (see VersionSet::SaveTo)
|
|
|
|
const std::vector<int>& FilesBySize(int level) const {
|
|
|
|
assert(finalized_);
|
|
|
|
return files_by_size_[level];
|
|
|
|
}
|
|
|
|
|
|
|
|
// REQUIRES: lock is held
|
|
|
|
// Set the index that is used to offset into files_by_size_ to find
|
|
|
|
// the next compaction candidate file.
|
|
|
|
void SetNextCompactionIndex(int level, int index) {
|
|
|
|
next_file_to_compact_by_size_[level] = index;
|
|
|
|
}
|
|
|
|
|
|
|
|
// REQUIRES: lock is held
|
|
|
|
int NextCompactionIndex(int level) const {
|
|
|
|
return next_file_to_compact_by_size_[level];
|
|
|
|
}
|
|
|
|
|
|
|
|
// REQUIRES: This version has been saved (see VersionSet::SaveTo)
|
|
|
|
const FileIndexer& file_indexer() const {
|
|
|
|
assert(finalized_);
|
|
|
|
return file_indexer_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Only the first few entries of files_by_size_ are sorted.
|
|
|
|
// There is no need to sort all the files because it is likely
|
|
|
|
// that on a running system, we need to look at only the first
|
|
|
|
// few largest files because a new version is created every few
|
|
|
|
// seconds/minutes (because of concurrent compactions).
|
|
|
|
static const size_t kNumberFilesToSort = 50;
|
|
|
|
|
|
|
|
// Return a human-readable short (single-line) summary of the number
|
|
|
|
// of files per level. Uses *scratch as backing store.
|
|
|
|
struct LevelSummaryStorage {
|
|
|
|
char buffer[1000];
|
|
|
|
};
|
|
|
|
struct FileSummaryStorage {
|
|
|
|
char buffer[3000];
|
|
|
|
};
|
|
|
|
const char* LevelSummary(LevelSummaryStorage* scratch) const;
|
|
|
|
// Return a human-readable short (single-line) summary of files
|
|
|
|
// in a specified level. Uses *scratch as backing store.
|
|
|
|
const char* LevelFileSummary(FileSummaryStorage* scratch, int level) const;
|
|
|
|
|
|
|
|
// Return the maximum overlapping data (in bytes) at next level for any
|
|
|
|
// file at a level >= 1.
|
|
|
|
int64_t MaxNextLevelOverlappingBytes();
|
|
|
|
|
|
|
|
// Return a human readable string that describes this version's contents.
|
|
|
|
std::string DebugString(bool hex = false) const;
|
|
|
|
|
|
|
|
uint64_t GetAverageValueSize() const {
|
|
|
|
if (accumulated_num_non_deletions_ == 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
assert(accumulated_raw_key_size_ + accumulated_raw_value_size_ > 0);
|
|
|
|
assert(accumulated_file_size_ > 0);
|
|
|
|
return accumulated_raw_value_size_ / accumulated_num_non_deletions_ *
|
|
|
|
accumulated_file_size_ /
|
|
|
|
(accumulated_raw_key_size_ + accumulated_raw_value_size_);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t GetEstimatedActiveKeys() const;
|
|
|
|
|
|
|
|
// re-initializes the index that is used to offset into files_by_size_
|
|
|
|
// to find the next compaction candidate file.
|
|
|
|
void ResetNextCompactionIndex(int level) {
|
|
|
|
next_file_to_compact_by_size_[level] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const InternalKeyComparator* InternalComparator() {
|
|
|
|
return internal_comparator_;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
const InternalKeyComparator* internal_comparator_;
|
|
|
|
const Comparator* user_comparator_;
|
|
|
|
int num_levels_; // Number of levels
|
|
|
|
int num_non_empty_levels_; // Number of levels. Any level larger than it
|
|
|
|
// is guaranteed to be empty.
|
|
|
|
// A short brief metadata of files per level
|
|
|
|
autovector<rocksdb::LevelFilesBrief> level_files_brief_;
|
|
|
|
FileIndexer file_indexer_;
|
|
|
|
Arena arena_; // Used to allocate space for file_levels_
|
|
|
|
|
|
|
|
CompactionStyle compaction_style_;
|
|
|
|
|
|
|
|
// List of files per level, files in each level are arranged
|
|
|
|
// in increasing order of keys
|
|
|
|
std::vector<FileMetaData*>* files_;
|
|
|
|
|
|
|
|
// A list for the same set of files that are stored in files_,
|
|
|
|
// but files in each level are now sorted based on file
|
|
|
|
// size. The file with the largest size is at the front.
|
|
|
|
// This vector stores the index of the file from files_.
|
|
|
|
std::vector<std::vector<int>> files_by_size_;
|
|
|
|
|
|
|
|
// An index into files_by_size_ that specifies the first
|
|
|
|
// file that is not yet compacted
|
|
|
|
std::vector<int> next_file_to_compact_by_size_;
|
|
|
|
|
|
|
|
// Only the first few entries of files_by_size_ are sorted.
|
|
|
|
// There is no need to sort all the files because it is likely
|
|
|
|
// that on a running system, we need to look at only the first
|
|
|
|
// few largest files because a new version is created every few
|
|
|
|
// seconds/minutes (because of concurrent compactions).
|
|
|
|
static const size_t number_of_files_to_sort_ = 50;
|
|
|
|
|
|
|
|
// Level that should be compacted next and its compaction score.
|
|
|
|
// Score < 1 means compaction is not strictly needed. These fields
|
|
|
|
// are initialized by Finalize().
|
|
|
|
// The most critical level to be compacted is listed first
|
|
|
|
// These are used to pick the best compaction level
|
|
|
|
std::vector<double> compaction_score_;
|
|
|
|
std::vector<int> compaction_level_;
|
|
|
|
double max_compaction_score_ = 0.0; // max score in l1 to ln-1
|
|
|
|
int max_compaction_score_level_ = 0; // level on which max score occurs
|
|
|
|
|
|
|
|
// the following are the sampled temporary stats.
|
|
|
|
// the current accumulated size of sampled files.
|
|
|
|
uint64_t accumulated_file_size_;
|
|
|
|
// the current accumulated size of all raw keys based on the sampled files.
|
|
|
|
uint64_t accumulated_raw_key_size_;
|
|
|
|
// the current accumulated size of all raw keys based on the sampled files.
|
|
|
|
uint64_t accumulated_raw_value_size_;
|
|
|
|
// total number of non-deletion entries
|
|
|
|
uint64_t accumulated_num_non_deletions_;
|
|
|
|
// total number of deletion entries
|
|
|
|
uint64_t accumulated_num_deletions_;
|
|
|
|
// the number of samples
|
|
|
|
uint64_t num_samples_;
|
|
|
|
|
|
|
|
bool finalized_;
|
|
|
|
|
|
|
|
friend class Version;
|
|
|
|
friend class VersionSet;
|
|
|
|
// No copying allowed
|
|
|
|
VersionStorageInfo(const VersionStorageInfo&) = delete;
|
|
|
|
void operator=(const VersionStorageInfo&) = delete;
|
|
|
|
};
|
|
|
|
|
|
|
|
class Version {
|
|
|
|
public:
|
|
|
|
// Append to *iters a sequence of iterators that will
|
|
|
|
// yield the contents of this Version when merged together.
|
|
|
|
// REQUIRES: This version has been saved (see VersionSet::SaveTo)
|
|
|
|
void AddIterators(const ReadOptions&, const EnvOptions& soptions,
|
|
|
|
MergeIteratorBuilder* merger_iter_builder);
|
|
|
|
|
|
|
|
// Lookup the value for key. If found, store it in *val and
|
|
|
|
// return OK. Else return a non-OK status.
|
|
|
|
// Uses *operands to store merge_operator operations to apply later
|
|
|
|
// REQUIRES: lock is not held
|
|
|
|
void Get(const ReadOptions&, const LookupKey& key, std::string* val,
|
|
|
|
Status* status, MergeContext* merge_context,
|
|
|
|
bool* value_found = nullptr);
|
|
|
|
|
|
|
|
// Loads some stats information from files. Call without mutex held. It needs
|
|
|
|
// to be called before applying the version to the version set.
|
|
|
|
void PrepareApply();
|
|
|
|
|
|
|
|
// Reference count management (so Versions do not disappear out from
|
|
|
|
// under live iterators)
|
|
|
|
void Ref();
|
|
|
|
// Decrease reference count. Delete the object if no reference left
|
|
|
|
// and return true. Otherwise, return false.
|
|
|
|
bool Unref();
|
|
|
|
|
|
|
|
// Add all files listed in the current version to *live.
|
|
|
|
void AddLiveFiles(std::vector<FileDescriptor>* live);
|
|
|
|
|
|
|
|
// Return a human readable string that describes this version's contents.
|
|
|
|
std::string DebugString(bool hex = false) const;
|
|
|
|
|
|
|
|
// Returns the version nuber of this version
|
|
|
|
uint64_t GetVersionNumber() const { return version_number_; }
|
|
|
|
|
|
|
|
// REQUIRES: lock is held
|
|
|
|
// On success, "tp" will contains the table properties of the file
|
|
|
|
// specified in "file_meta". If the file name of "file_meta" is
|
|
|
|
// known ahread, passing it by a non-null "fname" can save a
|
|
|
|
// file-name conversion.
|
|
|
|
Status GetTableProperties(std::shared_ptr<const TableProperties>* tp,
|
|
|
|
const FileMetaData* file_meta,
|
|
|
|
const std::string* fname = nullptr);
|
|
|
|
|
|
|
|
// REQUIRES: lock is held
|
|
|
|
// On success, *props will be populated with all SSTables' table properties.
|
|
|
|
// The keys of `props` are the sst file name, the values of `props` are the
|
|
|
|
// tables' propertis, represented as shared_ptr.
|
|
|
|
Status GetPropertiesOfAllTables(TablePropertiesCollection* props);
|
|
|
|
|
|
|
|
uint64_t GetEstimatedActiveKeys() {
|
|
|
|
return storage_info_.GetEstimatedActiveKeys();
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t GetMemoryUsageByTableReaders();
|
|
|
|
|
|
|
|
ColumnFamilyData* cfd() const { return cfd_; }
|
|
|
|
|
|
|
|
|
|
|
|
// Return the next Version in the linked list. Used for debug only
|
|
|
|
Version* TEST_Next() const {
|
|
|
|
return next_;
|
|
|
|
}
|
|
|
|
|
|
|
|
VersionStorageInfo* storage_info() { return &storage_info_; }
|
|
|
|
|
|
|
|
VersionSet* version_set() { return vset_; }
|
|
|
|
|
CompactFiles, EventListener and GetDatabaseMetaData
Summary:
This diff adds three sets of APIs to RocksDB.
= GetColumnFamilyMetaData =
* This APIs allow users to obtain the current state of a RocksDB instance on one column family.
* See GetColumnFamilyMetaData in include/rocksdb/db.h
= EventListener =
* A virtual class that allows users to implement a set of
call-back functions which will be called when specific
events of a RocksDB instance happens.
* To register EventListener, simply insert an EventListener to ColumnFamilyOptions::listeners
= CompactFiles =
* CompactFiles API inputs a set of file numbers and an output level, and RocksDB
will try to compact those files into the specified level.
= Example =
* Example code can be found in example/compact_files_example.cc, which implements
a simple external compactor using EventListener, GetColumnFamilyMetaData, and
CompactFiles API.
Test Plan:
listener_test
compactor_test
example/compact_files_example
export ROCKSDB_TESTS=CompactFiles
db_test
export ROCKSDB_TESTS=MetaData
db_test
Reviewers: ljin, igor, rven, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D24705
10 years ago
|
|
|
void GetColumnFamilyMetaData(ColumnFamilyMetaData* cf_meta);
|
|
|
|
|
|
|
|
private:
|
|
|
|
friend class VersionSet;
|
|
|
|
|
|
|
|
const InternalKeyComparator* internal_comparator() const {
|
|
|
|
return storage_info_.internal_comparator_;
|
|
|
|
}
|
|
|
|
const Comparator* user_comparator() const {
|
|
|
|
return storage_info_.user_comparator_;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool PrefixMayMatch(const ReadOptions& read_options, Iterator* level_iter,
|
|
|
|
const Slice& internal_prefix) const;
|
|
|
|
|
|
|
|
// The helper function of UpdateAccumulatedStats, which may fill the missing
|
|
|
|
// fields of file_mata from its associated TableProperties.
|
|
|
|
// Returns true if it does initialize FileMetaData.
|
|
|
|
bool MaybeInitializeFileMetaData(FileMetaData* file_meta);
|
|
|
|
|
|
|
|
// Update the accumulated stats associated with the current version.
|
|
|
|
// This accumulated stats will be used in compaction.
|
|
|
|
void UpdateAccumulatedStats();
|
|
|
|
|
|
|
|
// Sort all files for this version based on their file size and
|
|
|
|
// record results in files_by_size_. The largest files are listed first.
|
|
|
|
void UpdateFilesBySize();
|
|
|
|
|
|
|
|
ColumnFamilyData* cfd_; // ColumnFamilyData to which this Version belongs
|
|
|
|
Logger* info_log_;
|
|
|
|
Statistics* db_statistics_;
|
|
|
|
TableCache* table_cache_;
|
|
|
|
const MergeOperator* merge_operator_;
|
create compressed_levels_ in Version, allocate its space using arena. Make Version::Get, Version::FindFile faster
Summary:
Define CompressedFileMetaData that just contains fd, smallest_slice, largest_slice. Create compressed_levels_ in Version, the space is allocated using arena
Thus increase the file meta data locality, speed up "Get" and "FindFile"
benchmark with in-memory tmpfs, could have 4% improvement under "random read" and 2% improvement under "read while writing"
benchmark command:
./db_bench --db=/mnt/db/rocksdb --num_levels=6 --key_size=20 --prefix_size=20 --keys_per_prefix=0 --value_size=100 --block_size=4096 --cache_size=17179869184 --cache_numshardbits=6 --compression_type=none --compression_ratio=1 --min_level_to_compress=-1 --disable_seek_compaction=1 --hard_rate_limit=2 --write_buffer_size=134217728 --max_write_buffer_number=2 --level0_file_num_compaction_trigger=8 --target_file_size_base=33554432 --max_bytes_for_level_base=1073741824 --disable_wal=0 --sync=0 --disable_data_sync=1 --verify_checksum=1 --delete_obsolete_files_period_micros=314572800 --max_grandparent_overlap_factor=10 --max_background_compactions=4 --max_background_flushes=0 --level0_slowdown_writes_trigger=16 --level0_stop_writes_trigger=24 --statistics=0 --stats_per_interval=0 --stats_interval=1048576 --histogram=0 --use_plain_table=1 --open_files=-1 --mmap_read=1 --mmap_write=0 --memtablerep=prefix_hash --bloom_bits=10 --bloom_locality=1 --perf_level=0 --benchmarks=readwhilewriting,readwhilewriting,readwhilewriting --use_existing_db=1 --num=52428800 --threads=1 —writes_per_second=81920
Read Random:
From 1.8363 ms/op, improve to 1.7587 ms/op.
Read while writing:
From 2.985 ms/op, improve to 2.924 ms/op.
Test Plan:
make all check
Reviewers: ljin, haobo, yhchiang, sdong
Reviewed By: sdong
Subscribers: dhruba, igor
Differential Revision: https://reviews.facebook.net/D19419
11 years ago
|
|
|
|
|
|
|
VersionStorageInfo storage_info_;
|
|
|
|
VersionSet* vset_; // VersionSet to which this Version belongs
|
|
|
|
Version* next_; // Next version in linked list
|
|
|
|
Version* prev_; // Previous version in linked list
|
|
|
|
int refs_; // Number of live refs to this version
|
|
|
|
|
|
|
|
// A version number that uniquely represents this version. This is
|
|
|
|
// used for debugging and logging purposes only.
|
|
|
|
uint64_t version_number_;
|
|
|
|
|
|
|
|
Version(ColumnFamilyData* cfd, VersionSet* vset, uint64_t version_number = 0);
|
|
|
|
|
|
|
|
~Version();
|
|
|
|
|
|
|
|
// No copying allowed
|
|
|
|
Version(const Version&);
|
|
|
|
void operator=(const Version&);
|
|
|
|
};
|
|
|
|
|
|
|
|
class VersionSet {
|
|
|
|
public:
|
|
|
|
VersionSet(const std::string& dbname, const DBOptions* db_options,
|
|
|
|
const EnvOptions& env_options, Cache* table_cache,
|
|
|
|
WriteBuffer* write_buffer, WriteController* write_controller);
|
|
|
|
~VersionSet();
|
|
|
|
|
|
|
|
// Apply *edit to the current version to form a new descriptor that
|
|
|
|
// is both saved to persistent state and installed as the new
|
|
|
|
// current version. Will release *mu while actually writing to the file.
|
|
|
|
// column_family_options has to be set if edit is column family add
|
|
|
|
// REQUIRES: *mu is held on entry.
|
|
|
|
// REQUIRES: no other thread concurrently calls LogAndApply()
|
|
|
|
Status LogAndApply(
|
|
|
|
ColumnFamilyData* column_family_data,
|
|
|
|
const MutableCFOptions& mutable_cf_options, VersionEdit* edit,
|
|
|
|
InstrumentedMutex* mu, Directory* db_directory = nullptr,
|
|
|
|
bool new_descriptor_log = false,
|
|
|
|
const ColumnFamilyOptions* column_family_options = nullptr);
|
|
|
|
|
|
|
|
// Recover the last saved descriptor from persistent storage.
|
|
|
|
// If read_only == true, Recover() will not complain if some column families
|
|
|
|
// are not opened
|
|
|
|
Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
|
|
|
|
bool read_only = false);
|
|
|
|
|
|
|
|
// Reads a manifest file and returns a list of column families in
|
|
|
|
// column_families.
|
|
|
|
static Status ListColumnFamilies(std::vector<std::string>* column_families,
|
|
|
|
const std::string& dbname, Env* env);
|
|
|
|
|
|
|
|
#ifndef ROCKSDB_LITE
|
|
|
|
// Try to reduce the number of levels. This call is valid when
|
|
|
|
// only one level from the new max level to the old
|
|
|
|
// max level containing files.
|
Make VersionSet::ReduceNumberOfLevels() static
Summary:
A lot of our code implicitly assumes number_levels to be static. ReduceNumberOfLevels() breaks that assumption. For example, after calling ReduceNumberOfLevels(), DBImpl::NumberLevels() will be different from VersionSet::NumberLevels(). This is dangerous. Thankfully, it's not in public headers and is only used from LDB cmd tool. LDB tool is only using it statically, i.e. it never calls it with running DB instance. With this diff, we make it explicitly static. This way, we can assume number_levels to be immutable and not break assumption that lot of our code is relying upon. LDB tool can still use the method.
Also, I removed the method from a separate file since it breaks filename completition. version_se<TAB> now completes to "version_set." instead of "version_set" (without the dot). I don't see a big reason that the function should be in a different file.
Test Plan: reduce_levels_test
Reviewers: dhruba, haobo, kailiu, sdong
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15303
11 years ago
|
|
|
// The call is static, since number of levels is immutable during
|
|
|
|
// the lifetime of a RocksDB instance. It reduces number of levels
|
|
|
|
// in a DB by applying changes to manifest.
|
|
|
|
// For example, a db currently has 7 levels [0-6], and a call to
|
|
|
|
// to reduce to 5 [0-4] can only be executed when only one level
|
|
|
|
// among [4-6] contains files.
|
Make VersionSet::ReduceNumberOfLevels() static
Summary:
A lot of our code implicitly assumes number_levels to be static. ReduceNumberOfLevels() breaks that assumption. For example, after calling ReduceNumberOfLevels(), DBImpl::NumberLevels() will be different from VersionSet::NumberLevels(). This is dangerous. Thankfully, it's not in public headers and is only used from LDB cmd tool. LDB tool is only using it statically, i.e. it never calls it with running DB instance. With this diff, we make it explicitly static. This way, we can assume number_levels to be immutable and not break assumption that lot of our code is relying upon. LDB tool can still use the method.
Also, I removed the method from a separate file since it breaks filename completition. version_se<TAB> now completes to "version_set." instead of "version_set" (without the dot). I don't see a big reason that the function should be in a different file.
Test Plan: reduce_levels_test
Reviewers: dhruba, haobo, kailiu, sdong
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15303
11 years ago
|
|
|
static Status ReduceNumberOfLevels(const std::string& dbname,
|
|
|
|
const Options* options,
|
|
|
|
const EnvOptions& env_options,
|
Make VersionSet::ReduceNumberOfLevels() static
Summary:
A lot of our code implicitly assumes number_levels to be static. ReduceNumberOfLevels() breaks that assumption. For example, after calling ReduceNumberOfLevels(), DBImpl::NumberLevels() will be different from VersionSet::NumberLevels(). This is dangerous. Thankfully, it's not in public headers and is only used from LDB cmd tool. LDB tool is only using it statically, i.e. it never calls it with running DB instance. With this diff, we make it explicitly static. This way, we can assume number_levels to be immutable and not break assumption that lot of our code is relying upon. LDB tool can still use the method.
Also, I removed the method from a separate file since it breaks filename completition. version_se<TAB> now completes to "version_set." instead of "version_set" (without the dot). I don't see a big reason that the function should be in a different file.
Test Plan: reduce_levels_test
Reviewers: dhruba, haobo, kailiu, sdong
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15303
11 years ago
|
|
|
int new_levels);
|
|
|
|
|
|
|
|
// printf contents (for debugging)
|
|
|
|
Status DumpManifest(Options& options, std::string& manifestFileName,
|
|
|
|
bool verbose, bool hex = false);
|
|
|
|
|
|
|
|
#endif // ROCKSDB_LITE
|
|
|
|
|
|
|
|
// Return the current manifest file number
|
|
|
|
uint64_t manifest_file_number() const { return manifest_file_number_; }
|
|
|
|
|
|
|
|
uint64_t pending_manifest_file_number() const {
|
|
|
|
return pending_manifest_file_number_;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t current_next_file_number() const { return next_file_number_.load(); }
|
|
|
|
|
|
|
|
// Allocate and return a new file number
|
|
|
|
uint64_t NewFileNumber() { return next_file_number_.fetch_add(1); }
|
|
|
|
|
|
|
|
// Return the last sequence number.
|
|
|
|
uint64_t LastSequence() const {
|
|
|
|
return last_sequence_.load(std::memory_order_acquire);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the last sequence number to s.
|
|
|
|
void SetLastSequence(uint64_t s) {
|
|
|
|
assert(s >= last_sequence_);
|
|
|
|
last_sequence_.store(s, std::memory_order_release);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Mark the specified file number as used.
|
|
|
|
// REQUIRED: this is only called during single-threaded recovery
|
|
|
|
void MarkFileNumberUsedDuringRecovery(uint64_t number);
|
|
|
|
|
|
|
|
// Return the log file number for the log file that is currently
|
|
|
|
// being compacted, or zero if there is no such log file.
|
|
|
|
uint64_t prev_log_number() const { return prev_log_number_; }
|
|
|
|
|
|
|
|
// Returns the minimum log number such that all
|
|
|
|
// log numbers less than or equal to it can be deleted
|
|
|
|
uint64_t MinLogNumber() const {
|
|
|
|
uint64_t min_log_num = std::numeric_limits<uint64_t>::max();
|
|
|
|
for (auto cfd : *column_family_set_) {
|
|
|
|
if (min_log_num > cfd->GetLogNumber()) {
|
|
|
|
min_log_num = cfd->GetLogNumber();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return min_log_num;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create an iterator that reads over the compaction inputs for "*c".
|
|
|
|
// The caller should delete the iterator when no longer needed.
|
|
|
|
Iterator* MakeInputIterator(Compaction* c);
|
|
|
|
|
|
|
|
// Add all files listed in any live version to *live.
|
|
|
|
void AddLiveFiles(std::vector<FileDescriptor>* live_list);
|
|
|
|
|
|
|
|
// Return the approximate offset in the database of the data for
|
|
|
|
// "key" as of version "v".
|
|
|
|
uint64_t ApproximateOffsetOf(Version* v, const InternalKey& key);
|
|
|
|
|
|
|
|
// Return the size of the current manifest file
|
|
|
|
uint64_t manifest_file_size() const { return manifest_file_size_; }
|
|
|
|
|
|
|
|
// verify that the files that we started with for a compaction
|
|
|
|
// still exist in the current version and in the same original level.
|
|
|
|
// This ensures that a concurrent compaction did not erroneously
|
|
|
|
// pick the same files to compact.
|
|
|
|
bool VerifyCompactionFileConsistency(Compaction* c);
|
|
|
|
|
|
|
|
Status GetMetadataForFile(uint64_t number, int* filelevel,
|
|
|
|
FileMetaData** metadata, ColumnFamilyData** cfd);
|
|
|
|
|
CompactFiles, EventListener and GetDatabaseMetaData
Summary:
This diff adds three sets of APIs to RocksDB.
= GetColumnFamilyMetaData =
* This APIs allow users to obtain the current state of a RocksDB instance on one column family.
* See GetColumnFamilyMetaData in include/rocksdb/db.h
= EventListener =
* A virtual class that allows users to implement a set of
call-back functions which will be called when specific
events of a RocksDB instance happens.
* To register EventListener, simply insert an EventListener to ColumnFamilyOptions::listeners
= CompactFiles =
* CompactFiles API inputs a set of file numbers and an output level, and RocksDB
will try to compact those files into the specified level.
= Example =
* Example code can be found in example/compact_files_example.cc, which implements
a simple external compactor using EventListener, GetColumnFamilyMetaData, and
CompactFiles API.
Test Plan:
listener_test
compactor_test
example/compact_files_example
export ROCKSDB_TESTS=CompactFiles
db_test
export ROCKSDB_TESTS=MetaData
db_test
Reviewers: ljin, igor, rven, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D24705
10 years ago
|
|
|
void GetLiveFilesMetaData(std::vector<LiveFileMetaData> *metadata);
|
|
|
|
|
|
|
|
void GetObsoleteFiles(std::vector<FileMetaData*>* files,
|
|
|
|
uint64_t min_pending_output);
|
|
|
|
|
|
|
|
ColumnFamilySet* GetColumnFamilySet() { return column_family_set_.get(); }
|
|
|
|
const EnvOptions& env_options() { return env_options_; }
|
|
|
|
|
|
|
|
static uint64_t GetNumLiveVersions(Version* dummy_versions);
|
|
|
|
|
|
|
|
private:
|
|
|
|
struct ManifestWriter;
|
|
|
|
|
|
|
|
friend class Version;
|
CompactFiles, EventListener and GetDatabaseMetaData
Summary:
This diff adds three sets of APIs to RocksDB.
= GetColumnFamilyMetaData =
* This APIs allow users to obtain the current state of a RocksDB instance on one column family.
* See GetColumnFamilyMetaData in include/rocksdb/db.h
= EventListener =
* A virtual class that allows users to implement a set of
call-back functions which will be called when specific
events of a RocksDB instance happens.
* To register EventListener, simply insert an EventListener to ColumnFamilyOptions::listeners
= CompactFiles =
* CompactFiles API inputs a set of file numbers and an output level, and RocksDB
will try to compact those files into the specified level.
= Example =
* Example code can be found in example/compact_files_example.cc, which implements
a simple external compactor using EventListener, GetColumnFamilyMetaData, and
CompactFiles API.
Test Plan:
listener_test
compactor_test
example/compact_files_example
export ROCKSDB_TESTS=CompactFiles
db_test
export ROCKSDB_TESTS=MetaData
db_test
Reviewers: ljin, igor, rven, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D24705
10 years ago
|
|
|
friend class DBImpl;
|
|
|
|
|
|
|
|
struct LogReporter : public log::Reader::Reporter {
|
|
|
|
Status* status;
|
|
|
|
virtual void Corruption(size_t bytes, const Status& s) {
|
|
|
|
if (this->status->ok()) *this->status = s;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Save current contents to *log
|
|
|
|
Status WriteSnapshot(log::Writer* log);
|
|
|
|
|
|
|
|
void AppendVersion(ColumnFamilyData* column_family_data, Version* v);
|
|
|
|
|
|
|
|
bool ManifestContains(uint64_t manifest_file_number,
|
|
|
|
const std::string& record) const;
|
|
|
|
|
|
|
|
ColumnFamilyData* CreateColumnFamily(const ColumnFamilyOptions& cf_options,
|
|
|
|
VersionEdit* edit);
|
|
|
|
|
|
|
|
std::unique_ptr<ColumnFamilySet> column_family_set_;
|
|
|
|
|
|
|
|
Env* const env_;
|
|
|
|
const std::string dbname_;
|
|
|
|
const DBOptions* const db_options_;
|
|
|
|
std::atomic<uint64_t> next_file_number_;
|
|
|
|
uint64_t manifest_file_number_;
|
|
|
|
uint64_t pending_manifest_file_number_;
|
|
|
|
std::atomic<uint64_t> last_sequence_;
|
|
|
|
uint64_t prev_log_number_; // 0 or backing store for memtable being compacted
|
|
|
|
|
|
|
|
// Opened lazily
|
|
|
|
unique_ptr<log::Writer> descriptor_log_;
|
|
|
|
|
|
|
|
// generates a increasing version number for every new version
|
|
|
|
uint64_t current_version_number_;
|
|
|
|
|
|
|
|
// Queue of writers to the manifest file
|
|
|
|
std::deque<ManifestWriter*> manifest_writers_;
|
|
|
|
|
|
|
|
// Current size of manifest file
|
|
|
|
uint64_t manifest_file_size_;
|
|
|
|
|
|
|
|
std::vector<FileMetaData*> obsolete_files_;
|
|
|
|
|
|
|
|
// env options for all reads and writes except compactions
|
|
|
|
const EnvOptions& env_options_;
|
|
|
|
|
|
|
|
// env options used for compactions. This is a copy of
|
|
|
|
// env_options_ but with readaheads set to readahead_compactions_.
|
|
|
|
const EnvOptions env_options_compactions_;
|
|
|
|
|
|
|
|
// No copying allowed
|
|
|
|
VersionSet(const VersionSet&);
|
|
|
|
void operator=(const VersionSet&);
|
|
|
|
|
|
|
|
void LogAndApplyCFHelper(VersionEdit* edit);
|
|
|
|
void LogAndApplyHelper(ColumnFamilyData* cfd, VersionBuilder* b, Version* v,
|
|
|
|
VersionEdit* edit, InstrumentedMutex* mu);
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace rocksdb
|