2014-01-22 20:44:53 +01:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
2014-01-25 03:40:05 +01:00
|
|
|
#include <unordered_map>
|
2014-01-22 20:44:53 +01:00
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
2014-02-06 20:44:50 +01:00
|
|
|
#include <atomic>
|
2014-01-22 20:44:53 +01:00
|
|
|
|
2014-01-24 23:30:28 +01:00
|
|
|
#include "rocksdb/options.h"
|
2014-03-11 22:52:17 +01:00
|
|
|
#include "rocksdb/db.h"
|
2014-02-05 01:31:18 +01:00
|
|
|
#include "rocksdb/env.h"
|
2014-02-07 00:42:16 +01:00
|
|
|
#include "db/memtable_list.h"
|
2014-01-28 20:05:04 +01:00
|
|
|
#include "db/write_batch_internal.h"
|
[CF] Rethink table cache
Summary:
Adapting table cache to column families is interesting. We want table cache to be global LRU, so if some column families are use not as often as others, we want them to be evicted from cache. However, current TableCache object also constructs tables on its own. If table is not found in the cache, TableCache automatically creates new table. We want each column family to be able to specify different table factory.
To solve the problem, we still have a single LRU, but we provide the LRUCache object to TableCache on construction. We have one TableCache per column family, but the underyling cache is shared by all TableCache objects.
This allows us to have a global LRU, but still be able to support different table factories for different column families. Also, in the future it will also be able to support different directories for different column families.
Test Plan: make check
Reviewers: dhruba, haobo, kailiu, sdong
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15915
2014-02-05 18:07:55 +01:00
|
|
|
#include "db/table_cache.h"
|
2014-03-04 02:54:04 +01:00
|
|
|
#include "util/thread_local.h"
|
2014-01-24 23:30:28 +01:00
|
|
|
|
2014-01-22 20:44:53 +01:00
|
|
|
namespace rocksdb {
|
|
|
|
|
|
|
|
class Version;
|
|
|
|
class VersionSet;
|
2014-01-24 23:30:28 +01:00
|
|
|
class MemTable;
|
|
|
|
class MemTableListVersion;
|
2014-02-01 00:30:27 +01:00
|
|
|
class CompactionPicker;
|
|
|
|
class Compaction;
|
|
|
|
class InternalKey;
|
2014-02-05 02:45:19 +01:00
|
|
|
class InternalStats;
|
2014-02-11 02:04:44 +01:00
|
|
|
class ColumnFamilyData;
|
|
|
|
class DBImpl;
|
2014-03-11 01:25:10 +01:00
|
|
|
class LogBuffer;
|
2014-02-11 02:04:44 +01:00
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
// ColumnFamilyHandleImpl is the class that clients use to access different
|
|
|
|
// column families. It has non-trivial destructor, which gets called when client
|
|
|
|
// is done using the column family
|
2014-02-11 02:04:44 +01:00
|
|
|
class ColumnFamilyHandleImpl : public ColumnFamilyHandle {
|
|
|
|
public:
|
|
|
|
// create while holding the mutex
|
|
|
|
ColumnFamilyHandleImpl(ColumnFamilyData* cfd, DBImpl* db, port::Mutex* mutex);
|
|
|
|
// destroy without mutex
|
|
|
|
virtual ~ColumnFamilyHandleImpl();
|
|
|
|
virtual ColumnFamilyData* cfd() const { return cfd_; }
|
|
|
|
|
2014-03-14 19:26:13 +01:00
|
|
|
virtual uint32_t GetID() const;
|
2014-02-26 02:30:54 +01:00
|
|
|
|
2014-02-11 02:04:44 +01:00
|
|
|
private:
|
|
|
|
ColumnFamilyData* cfd_;
|
|
|
|
DBImpl* db_;
|
|
|
|
port::Mutex* mutex_;
|
|
|
|
};
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
// Does not ref-count ColumnFamilyData
|
|
|
|
// We use this dummy ColumnFamilyHandleImpl because sometimes MemTableInserter
|
|
|
|
// calls DBImpl methods. When this happens, MemTableInserter need access to
|
|
|
|
// ColumnFamilyHandle (same as the client would need). In that case, we feed
|
|
|
|
// MemTableInserter dummy ColumnFamilyHandle and enable it to call DBImpl
|
|
|
|
// methods
|
2014-02-11 02:04:44 +01:00
|
|
|
class ColumnFamilyHandleInternal : public ColumnFamilyHandleImpl {
|
|
|
|
public:
|
|
|
|
ColumnFamilyHandleInternal()
|
|
|
|
: ColumnFamilyHandleImpl(nullptr, nullptr, nullptr) {}
|
|
|
|
|
|
|
|
void SetCFD(ColumnFamilyData* cfd) { internal_cfd_ = cfd; }
|
|
|
|
virtual ColumnFamilyData* cfd() const override { return internal_cfd_; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
ColumnFamilyData* internal_cfd_;
|
|
|
|
};
|
2014-01-24 23:30:28 +01:00
|
|
|
|
|
|
|
// holds references to memtable, all immutable memtables and version
|
|
|
|
struct SuperVersion {
|
|
|
|
MemTable* mem;
|
|
|
|
MemTableListVersion* imm;
|
|
|
|
Version* current;
|
|
|
|
std::atomic<uint32_t> refs;
|
|
|
|
// We need to_delete because during Cleanup(), imm->Unref() returns
|
|
|
|
// all memtables that we need to free through this vector. We then
|
|
|
|
// delete all those memtables outside of mutex, during destruction
|
2014-02-07 00:42:16 +01:00
|
|
|
autovector<MemTable*> to_delete;
|
2014-03-04 02:54:04 +01:00
|
|
|
// Version number of the current SuperVersion
|
|
|
|
uint64_t version_number;
|
|
|
|
port::Mutex* db_mutex;
|
2014-01-24 23:30:28 +01:00
|
|
|
|
|
|
|
// should be called outside the mutex
|
2014-02-12 23:01:30 +01:00
|
|
|
SuperVersion() = default;
|
2014-01-24 23:30:28 +01:00
|
|
|
~SuperVersion();
|
|
|
|
SuperVersion* Ref();
|
2014-04-07 23:21:25 +02:00
|
|
|
|
2014-01-24 23:30:28 +01:00
|
|
|
bool Unref();
|
|
|
|
|
|
|
|
// call these two methods with db mutex held
|
|
|
|
// Cleanup unrefs mem, imm and current. Also, it stores all memtables
|
|
|
|
// that needs to be deleted in to_delete vector. Unrefing those
|
|
|
|
// objects needs to be done in the mutex
|
|
|
|
void Cleanup();
|
|
|
|
void Init(MemTable* new_mem, MemTableListVersion* new_imm,
|
|
|
|
Version* new_current);
|
2014-03-08 01:59:47 +01:00
|
|
|
|
|
|
|
// The value of dummy is not actually used. kSVInUse takes its address as a
|
|
|
|
// mark in the thread local storage to indicate the SuperVersion is in use
|
|
|
|
// by thread. This way, the value of kSVInUse is guaranteed to have no
|
|
|
|
// conflict with SuperVersion object address and portable on different
|
|
|
|
// platform.
|
|
|
|
static int dummy;
|
|
|
|
static void* const kSVInUse;
|
|
|
|
static void* const kSVObsolete;
|
2014-01-24 23:30:28 +01:00
|
|
|
};
|
2014-01-22 20:44:53 +01:00
|
|
|
|
2014-02-05 01:31:18 +01:00
|
|
|
extern ColumnFamilyOptions SanitizeOptions(const InternalKeyComparator* icmp,
|
|
|
|
const InternalFilterPolicy* ipolicy,
|
|
|
|
const ColumnFamilyOptions& src);
|
|
|
|
|
2014-02-11 02:04:44 +01:00
|
|
|
class ColumnFamilySet;
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
// This class keeps all the data that a column family needs. It's mosly dumb and
|
|
|
|
// used just to provide access to metadata.
|
|
|
|
// Most methods require DB mutex held, unless otherwise noted
|
2014-01-29 22:28:50 +01:00
|
|
|
class ColumnFamilyData {
|
|
|
|
public:
|
2014-02-11 02:04:44 +01:00
|
|
|
~ColumnFamilyData();
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
// thread-safe
|
2014-01-29 22:28:50 +01:00
|
|
|
uint32_t GetID() const { return id_; }
|
2014-03-11 22:52:17 +01:00
|
|
|
// thread-safe
|
|
|
|
const std::string& GetName() const { return name_; }
|
2014-01-29 22:28:50 +01:00
|
|
|
|
2014-02-11 02:04:44 +01:00
|
|
|
void Ref() { ++refs_; }
|
|
|
|
// will just decrease reference count to 0, but will not delete it. returns
|
2014-04-07 23:21:25 +02:00
|
|
|
// true if the ref count was decreased to zero. in that case, it can be
|
|
|
|
// deleted by the caller immediatelly, or later, by calling
|
|
|
|
// FreeDeadColumnFamilies()
|
2014-02-11 02:04:44 +01:00
|
|
|
bool Unref() {
|
|
|
|
assert(refs_ > 0);
|
|
|
|
return --refs_ == 0;
|
|
|
|
}
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
// This can only be called from single-threaded VersionSet::LogAndApply()
|
|
|
|
// After dropping column family no other operation on that column family
|
|
|
|
// will be executed. All the files and memory will be, however, kept around
|
|
|
|
// until client drops the column family handle. That way, client can still
|
|
|
|
// access data from dropped column family.
|
|
|
|
// Column family can be dropped and still alive. In that state:
|
|
|
|
// *) Column family is not included in the iteration.
|
|
|
|
// *) Compaction and flush is not executed on the dropped column family.
|
|
|
|
// *) Client can continue writing and reading from column family. However, all
|
|
|
|
// writes stay in the current memtable.
|
|
|
|
// When the dropped column family is unreferenced, then we:
|
|
|
|
// *) delete all memory associated with that column family
|
|
|
|
// *) delete all the files associated with that column family
|
2014-02-11 02:04:44 +01:00
|
|
|
void SetDropped() {
|
|
|
|
// can't drop default CF
|
|
|
|
assert(id_ != 0);
|
2014-03-11 22:52:17 +01:00
|
|
|
dropped_ = true;
|
2014-02-11 02:04:44 +01:00
|
|
|
}
|
2014-03-11 22:52:17 +01:00
|
|
|
bool IsDropped() const { return dropped_; }
|
2014-02-11 02:04:44 +01:00
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
// thread-safe
|
2014-02-01 00:30:27 +01:00
|
|
|
int NumberLevels() const { return options_.num_levels; }
|
|
|
|
|
2014-01-29 22:28:50 +01:00
|
|
|
void SetLogNumber(uint64_t log_number) { log_number_ = log_number; }
|
|
|
|
uint64_t GetLogNumber() const { return log_number_; }
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
// thread-safe
|
|
|
|
const Options* options() const { return &options_; }
|
|
|
|
|
|
|
|
InternalStats* internal_stats() { return internal_stats_.get(); }
|
2014-01-29 22:28:50 +01:00
|
|
|
|
|
|
|
MemTableList* imm() { return &imm_; }
|
|
|
|
MemTable* mem() { return mem_; }
|
|
|
|
Version* current() { return current_; }
|
|
|
|
Version* dummy_versions() { return dummy_versions_; }
|
|
|
|
void SetMemtable(MemTable* new_mem) { mem_ = new_mem; }
|
2014-01-31 00:23:13 +01:00
|
|
|
void SetCurrent(Version* current);
|
2014-01-24 23:30:28 +01:00
|
|
|
void CreateNewMemtable();
|
2014-01-29 22:28:50 +01:00
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
TableCache* table_cache() { return table_cache_.get(); }
|
[CF] Rethink table cache
Summary:
Adapting table cache to column families is interesting. We want table cache to be global LRU, so if some column families are use not as often as others, we want them to be evicted from cache. However, current TableCache object also constructs tables on its own. If table is not found in the cache, TableCache automatically creates new table. We want each column family to be able to specify different table factory.
To solve the problem, we still have a single LRU, but we provide the LRUCache object to TableCache on construction. We have one TableCache per column family, but the underyling cache is shared by all TableCache objects.
This allows us to have a global LRU, but still be able to support different table factories for different column families. Also, in the future it will also be able to support different directories for different column families.
Test Plan: make check
Reviewers: dhruba, haobo, kailiu, sdong
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15915
2014-02-05 18:07:55 +01:00
|
|
|
|
2014-02-01 00:30:27 +01:00
|
|
|
// See documentation in compaction_picker.h
|
2014-03-06 01:55:51 +01:00
|
|
|
Compaction* PickCompaction(LogBuffer* log_buffer);
|
2014-02-01 00:30:27 +01:00
|
|
|
Compaction* CompactRange(int input_level, int output_level,
|
|
|
|
const InternalKey* begin, const InternalKey* end,
|
|
|
|
InternalKey** compaction_end);
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
CompactionPicker* compaction_picker() { return compaction_picker_.get(); }
|
|
|
|
// thread-safe
|
2014-02-05 01:31:18 +01:00
|
|
|
const Comparator* user_comparator() const {
|
|
|
|
return internal_comparator_.user_comparator();
|
|
|
|
}
|
2014-03-11 22:52:17 +01:00
|
|
|
// thread-safe
|
2014-02-05 01:31:18 +01:00
|
|
|
const InternalKeyComparator& internal_comparator() const {
|
|
|
|
return internal_comparator_;
|
|
|
|
}
|
2014-02-01 00:30:27 +01:00
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
SuperVersion* GetSuperVersion() { return super_version_; }
|
|
|
|
// thread-safe
|
2014-03-08 01:59:47 +01:00
|
|
|
ThreadLocalPtr* GetThreadLocalSuperVersion() const { return local_sv_.get(); }
|
2014-03-11 22:52:17 +01:00
|
|
|
// thread-safe
|
2014-01-29 22:28:50 +01:00
|
|
|
uint64_t GetSuperVersionNumber() const {
|
|
|
|
return super_version_number_.load();
|
|
|
|
}
|
|
|
|
// will return a pointer to SuperVersion* if previous SuperVersion
|
|
|
|
// if its reference count is zero and needs deletion or nullptr if not
|
|
|
|
// As argument takes a pointer to allocated SuperVersion to enable
|
|
|
|
// the clients to allocate SuperVersion outside of mutex.
|
2014-03-04 02:54:04 +01:00
|
|
|
SuperVersion* InstallSuperVersion(SuperVersion* new_superversion,
|
|
|
|
port::Mutex* db_mutex);
|
|
|
|
|
|
|
|
void ResetThreadLocalSuperVersions();
|
2014-01-29 22:28:50 +01:00
|
|
|
|
2014-01-31 00:23:13 +01:00
|
|
|
// A Flag indicating whether write needs to slowdown because of there are
|
|
|
|
// too many number of level0 files.
|
|
|
|
bool NeedSlowdownForNumLevel0Files() const {
|
|
|
|
return need_slowdown_for_num_level0_files_;
|
|
|
|
}
|
|
|
|
|
2014-01-29 22:28:50 +01:00
|
|
|
private:
|
2014-01-31 01:49:46 +01:00
|
|
|
friend class ColumnFamilySet;
|
[CF] Rethink table cache
Summary:
Adapting table cache to column families is interesting. We want table cache to be global LRU, so if some column families are use not as often as others, we want them to be evicted from cache. However, current TableCache object also constructs tables on its own. If table is not found in the cache, TableCache automatically creates new table. We want each column family to be able to specify different table factory.
To solve the problem, we still have a single LRU, but we provide the LRUCache object to TableCache on construction. We have one TableCache per column family, but the underyling cache is shared by all TableCache objects.
This allows us to have a global LRU, but still be able to support different table factories for different column families. Also, in the future it will also be able to support different directories for different column families.
Test Plan: make check
Reviewers: dhruba, haobo, kailiu, sdong
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15915
2014-02-05 18:07:55 +01:00
|
|
|
ColumnFamilyData(const std::string& dbname, uint32_t id,
|
|
|
|
const std::string& name, Version* dummy_versions,
|
|
|
|
Cache* table_cache, const ColumnFamilyOptions& options,
|
2014-02-05 22:12:23 +01:00
|
|
|
const DBOptions* db_options,
|
2014-02-11 02:04:44 +01:00
|
|
|
const EnvOptions& storage_options,
|
|
|
|
ColumnFamilySet* column_family_set);
|
2014-01-31 01:49:46 +01:00
|
|
|
|
2014-01-29 22:28:50 +01:00
|
|
|
uint32_t id_;
|
|
|
|
const std::string name_;
|
|
|
|
Version* dummy_versions_; // Head of circular doubly-linked list of versions.
|
|
|
|
Version* current_; // == dummy_versions->prev_
|
|
|
|
|
2014-02-11 02:04:44 +01:00
|
|
|
int refs_; // outstanding references to ColumnFamilyData
|
2014-03-11 22:52:17 +01:00
|
|
|
bool dropped_; // true if client dropped it
|
2014-02-11 02:04:44 +01:00
|
|
|
|
2014-02-05 01:31:18 +01:00
|
|
|
const InternalKeyComparator internal_comparator_;
|
|
|
|
const InternalFilterPolicy internal_filter_policy_;
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
Options const options_;
|
2014-02-01 00:30:27 +01:00
|
|
|
|
[CF] Rethink table cache
Summary:
Adapting table cache to column families is interesting. We want table cache to be global LRU, so if some column families are use not as often as others, we want them to be evicted from cache. However, current TableCache object also constructs tables on its own. If table is not found in the cache, TableCache automatically creates new table. We want each column family to be able to specify different table factory.
To solve the problem, we still have a single LRU, but we provide the LRUCache object to TableCache on construction. We have one TableCache per column family, but the underyling cache is shared by all TableCache objects.
This allows us to have a global LRU, but still be able to support different table factories for different column families. Also, in the future it will also be able to support different directories for different column families.
Test Plan: make check
Reviewers: dhruba, haobo, kailiu, sdong
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15915
2014-02-05 18:07:55 +01:00
|
|
|
std::unique_ptr<TableCache> table_cache_;
|
|
|
|
|
2014-02-05 02:45:19 +01:00
|
|
|
std::unique_ptr<InternalStats> internal_stats_;
|
|
|
|
|
2014-01-29 22:28:50 +01:00
|
|
|
MemTable* mem_;
|
|
|
|
MemTableList imm_;
|
|
|
|
SuperVersion* super_version_;
|
|
|
|
|
|
|
|
// An ordinal representing the current SuperVersion. Updated by
|
|
|
|
// InstallSuperVersion(), i.e. incremented every time super_version_
|
|
|
|
// changes.
|
|
|
|
std::atomic<uint64_t> super_version_number_;
|
|
|
|
|
2014-03-04 02:54:04 +01:00
|
|
|
// Thread's local copy of SuperVersion pointer
|
|
|
|
// This needs to be destructed before mutex_
|
2014-03-04 18:03:56 +01:00
|
|
|
std::unique_ptr<ThreadLocalPtr> local_sv_;
|
2014-03-04 02:54:04 +01:00
|
|
|
|
2014-01-31 01:49:46 +01:00
|
|
|
// pointers for a circular linked list. we use it to support iterations
|
|
|
|
// that can be concurrent with writes
|
2014-02-11 02:04:44 +01:00
|
|
|
ColumnFamilyData* next_;
|
|
|
|
ColumnFamilyData* prev_;
|
2014-01-31 01:49:46 +01:00
|
|
|
|
2014-01-29 22:28:50 +01:00
|
|
|
// This is the earliest log file number that contains data from this
|
|
|
|
// Column Family. All earlier log files must be ignored and not
|
|
|
|
// recovered from
|
|
|
|
uint64_t log_number_;
|
2014-01-31 00:23:13 +01:00
|
|
|
|
|
|
|
// A flag indicating whether we should delay writes because
|
|
|
|
// we have too many level 0 files
|
|
|
|
bool need_slowdown_for_num_level0_files_;
|
2014-02-01 00:30:27 +01:00
|
|
|
|
|
|
|
// An object that keeps all the compaction stats
|
|
|
|
// and picks the next compaction
|
|
|
|
std::unique_ptr<CompactionPicker> compaction_picker_;
|
2014-02-11 02:04:44 +01:00
|
|
|
|
|
|
|
ColumnFamilySet* column_family_set_;
|
2014-01-22 20:44:53 +01:00
|
|
|
};
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
// ColumnFamilySet has interesting thread-safety requirements
|
|
|
|
// * CreateColumnFamily() or RemoveColumnFamily() -- need to protect by DB
|
|
|
|
// mutex. Inside, column_family_data_ and column_families_ will be protected
|
|
|
|
// by Lock() and Unlock(). CreateColumnFamily() should ONLY be called from
|
|
|
|
// VersionSet::LogAndApply() in the normal runtime. It is also called
|
|
|
|
// during Recovery and in DumpManifest(). RemoveColumnFamily() is called
|
|
|
|
// from ColumnFamilyData destructor
|
|
|
|
// * Iteration -- hold DB mutex, but you can release it in the body of
|
|
|
|
// iteration. If you release DB mutex in body, reference the column
|
|
|
|
// family before the mutex and unreference after you unlock, since the column
|
|
|
|
// family might get dropped when the DB mutex is released
|
|
|
|
// * GetDefault() -- thread safe
|
|
|
|
// * GetColumnFamily() -- either inside of DB mutex or call Lock() <-> Unlock()
|
|
|
|
// * GetNextColumnFamilyID(), GetMaxColumnFamily(), UpdateMaxColumnFamily() --
|
|
|
|
// inside of DB mutex
|
2014-01-22 20:44:53 +01:00
|
|
|
class ColumnFamilySet {
|
|
|
|
public:
|
2014-03-11 22:52:17 +01:00
|
|
|
// ColumnFamilySet supports iteration
|
2014-01-24 23:30:28 +01:00
|
|
|
class iterator {
|
|
|
|
public:
|
2014-01-31 01:49:46 +01:00
|
|
|
explicit iterator(ColumnFamilyData* cfd)
|
|
|
|
: current_(cfd) {}
|
2014-01-24 23:30:28 +01:00
|
|
|
iterator& operator++() {
|
2014-03-11 22:52:17 +01:00
|
|
|
// dummy is never dead or dropped, so this will never be infinite
|
2014-02-11 02:04:44 +01:00
|
|
|
do {
|
2014-03-11 22:52:17 +01:00
|
|
|
current_ = current_->next_;
|
|
|
|
} while (current_->refs_ == 0 || current_->IsDropped());
|
2014-01-24 23:30:28 +01:00
|
|
|
return *this;
|
|
|
|
}
|
2014-01-31 01:49:46 +01:00
|
|
|
bool operator!=(const iterator& other) {
|
|
|
|
return this->current_ != other.current_;
|
|
|
|
}
|
|
|
|
ColumnFamilyData* operator*() { return current_; }
|
2014-01-24 23:30:28 +01:00
|
|
|
|
|
|
|
private:
|
2014-01-31 01:49:46 +01:00
|
|
|
ColumnFamilyData* current_;
|
2014-01-24 23:30:28 +01:00
|
|
|
};
|
2014-01-22 20:44:53 +01:00
|
|
|
|
2014-02-05 22:12:23 +01:00
|
|
|
ColumnFamilySet(const std::string& dbname, const DBOptions* db_options,
|
[CF] Rethink table cache
Summary:
Adapting table cache to column families is interesting. We want table cache to be global LRU, so if some column families are use not as often as others, we want them to be evicted from cache. However, current TableCache object also constructs tables on its own. If table is not found in the cache, TableCache automatically creates new table. We want each column family to be able to specify different table factory.
To solve the problem, we still have a single LRU, but we provide the LRUCache object to TableCache on construction. We have one TableCache per column family, but the underyling cache is shared by all TableCache objects.
This allows us to have a global LRU, but still be able to support different table factories for different column families. Also, in the future it will also be able to support different directories for different column families.
Test Plan: make check
Reviewers: dhruba, haobo, kailiu, sdong
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15915
2014-02-05 18:07:55 +01:00
|
|
|
const EnvOptions& storage_options, Cache* table_cache);
|
2014-01-22 20:44:53 +01:00
|
|
|
~ColumnFamilySet();
|
|
|
|
|
|
|
|
ColumnFamilyData* GetDefault() const;
|
|
|
|
// GetColumnFamily() calls return nullptr if column family is not found
|
|
|
|
ColumnFamilyData* GetColumnFamily(uint32_t id) const;
|
2014-02-28 23:05:11 +01:00
|
|
|
ColumnFamilyData* GetColumnFamily(const std::string& name) const;
|
2014-01-22 20:44:53 +01:00
|
|
|
// this call will return the next available column family ID. it guarantees
|
|
|
|
// that there is no column family with id greater than or equal to the
|
2014-03-05 21:13:44 +01:00
|
|
|
// returned value in the current running instance or anytime in RocksDB
|
|
|
|
// instance history.
|
2014-01-22 20:44:53 +01:00
|
|
|
uint32_t GetNextColumnFamilyID();
|
2014-03-05 21:13:44 +01:00
|
|
|
uint32_t GetMaxColumnFamily();
|
|
|
|
void UpdateMaxColumnFamily(uint32_t new_max_column_family);
|
2014-01-22 20:44:53 +01:00
|
|
|
|
|
|
|
ColumnFamilyData* CreateColumnFamily(const std::string& name, uint32_t id,
|
|
|
|
Version* dummy_version,
|
|
|
|
const ColumnFamilyOptions& options);
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
iterator begin() { return iterator(dummy_cfd_->next_); }
|
2014-01-31 01:49:46 +01:00
|
|
|
iterator end() { return iterator(dummy_cfd_); }
|
2014-01-22 20:44:53 +01:00
|
|
|
|
2014-02-06 20:44:50 +01:00
|
|
|
void Lock();
|
|
|
|
void Unlock();
|
|
|
|
|
2014-04-07 23:21:25 +02:00
|
|
|
// REQUIRES: DB mutex held
|
|
|
|
// Don't call while iterating over ColumnFamilySet
|
|
|
|
void FreeDeadColumnFamilies();
|
|
|
|
|
2014-01-22 20:44:53 +01:00
|
|
|
private:
|
2014-03-11 22:52:17 +01:00
|
|
|
friend class ColumnFamilyData;
|
|
|
|
// helper function that gets called from cfd destructor
|
|
|
|
// REQUIRES: DB mutex held
|
|
|
|
void RemoveColumnFamily(ColumnFamilyData* cfd);
|
|
|
|
|
|
|
|
// column_families_ and column_family_data_ need to be protected:
|
|
|
|
// * when mutating: 1. DB mutex locked first, 2. spinlock locked second
|
|
|
|
// * when reading, either: 1. lock DB mutex, or 2. lock spinlock
|
2014-02-11 02:04:44 +01:00
|
|
|
// (if both, respect the ordering to avoid deadlock!)
|
2014-01-22 20:44:53 +01:00
|
|
|
std::unordered_map<std::string, uint32_t> column_families_;
|
|
|
|
std::unordered_map<uint32_t, ColumnFamilyData*> column_family_data_;
|
2014-03-11 22:52:17 +01:00
|
|
|
|
2014-01-22 20:44:53 +01:00
|
|
|
uint32_t max_column_family_;
|
2014-01-31 01:49:46 +01:00
|
|
|
ColumnFamilyData* dummy_cfd_;
|
2014-03-11 22:52:17 +01:00
|
|
|
// We don't hold the refcount here, since default column family always exists
|
|
|
|
// We are also not responsible for cleaning up default_cfd_cache_. This is
|
|
|
|
// just a cache that makes common case (accessing default column family)
|
|
|
|
// faster
|
|
|
|
ColumnFamilyData* default_cfd_cache_;
|
[CF] Rethink table cache
Summary:
Adapting table cache to column families is interesting. We want table cache to be global LRU, so if some column families are use not as often as others, we want them to be evicted from cache. However, current TableCache object also constructs tables on its own. If table is not found in the cache, TableCache automatically creates new table. We want each column family to be able to specify different table factory.
To solve the problem, we still have a single LRU, but we provide the LRUCache object to TableCache on construction. We have one TableCache per column family, but the underyling cache is shared by all TableCache objects.
This allows us to have a global LRU, but still be able to support different table factories for different column families. Also, in the future it will also be able to support different directories for different column families.
Test Plan: make check
Reviewers: dhruba, haobo, kailiu, sdong
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15915
2014-02-05 18:07:55 +01:00
|
|
|
|
|
|
|
const std::string db_name_;
|
2014-02-05 22:12:23 +01:00
|
|
|
const DBOptions* const db_options_;
|
[CF] Rethink table cache
Summary:
Adapting table cache to column families is interesting. We want table cache to be global LRU, so if some column families are use not as often as others, we want them to be evicted from cache. However, current TableCache object also constructs tables on its own. If table is not found in the cache, TableCache automatically creates new table. We want each column family to be able to specify different table factory.
To solve the problem, we still have a single LRU, but we provide the LRUCache object to TableCache on construction. We have one TableCache per column family, but the underyling cache is shared by all TableCache objects.
This allows us to have a global LRU, but still be able to support different table factories for different column families. Also, in the future it will also be able to support different directories for different column families.
Test Plan: make check
Reviewers: dhruba, haobo, kailiu, sdong
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15915
2014-02-05 18:07:55 +01:00
|
|
|
const EnvOptions storage_options_;
|
|
|
|
Cache* table_cache_;
|
2014-02-06 20:44:50 +01:00
|
|
|
std::atomic_flag spin_lock_;
|
2014-01-22 20:44:53 +01:00
|
|
|
};
|
|
|
|
|
2014-03-11 22:52:17 +01:00
|
|
|
// We use ColumnFamilyMemTablesImpl to provide WriteBatch a way to access
|
|
|
|
// memtables of different column families (specified by ID in the write batch)
|
2014-01-28 20:05:04 +01:00
|
|
|
class ColumnFamilyMemTablesImpl : public ColumnFamilyMemTables {
|
|
|
|
public:
|
|
|
|
explicit ColumnFamilyMemTablesImpl(ColumnFamilySet* column_family_set)
|
2014-02-06 01:02:48 +01:00
|
|
|
: column_family_set_(column_family_set), current_(nullptr) {}
|
2014-01-28 20:05:04 +01:00
|
|
|
|
2014-02-06 01:02:48 +01:00
|
|
|
// sets current_ to ColumnFamilyData with column_family_id
|
|
|
|
// returns false if column family doesn't exist
|
|
|
|
bool Seek(uint32_t column_family_id) override;
|
|
|
|
|
|
|
|
// Returns log number of the selected column family
|
|
|
|
uint64_t GetLogNumber() const override;
|
|
|
|
|
|
|
|
// REQUIRES: Seek() called first
|
|
|
|
virtual MemTable* GetMemTable() const override;
|
2014-01-28 20:05:04 +01:00
|
|
|
|
2014-02-06 01:02:48 +01:00
|
|
|
// Returns options for selected column family
|
|
|
|
// REQUIRES: Seek() called first
|
2014-03-11 22:52:17 +01:00
|
|
|
virtual const Options* GetOptions() const override;
|
2014-02-06 01:02:48 +01:00
|
|
|
|
|
|
|
// Returns column family handle for the selected column family
|
2014-02-11 02:04:44 +01:00
|
|
|
virtual ColumnFamilyHandle* GetColumnFamilyHandle() override;
|
2014-01-28 20:05:04 +01:00
|
|
|
|
|
|
|
private:
|
|
|
|
ColumnFamilySet* column_family_set_;
|
2014-02-06 01:02:48 +01:00
|
|
|
ColumnFamilyData* current_;
|
2014-02-11 02:04:44 +01:00
|
|
|
ColumnFamilyHandleInternal handle_;
|
2014-01-28 20:05:04 +01:00
|
|
|
};
|
|
|
|
|
2014-01-22 20:44:53 +01:00
|
|
|
} // namespace rocksdb
|