|
|
|
@ -45,6 +45,8 @@ using FieldArray = std::vector>; |
|
|
|
|
|
|
|
**功能：** 将传入的字段数组和 slot_num 序列化为字符串，并存到 value |
|
|
|
|
|
|
|
注：slot_num 字段用于实现KV分离 |
|
|
|
|
|
|
|
**字符串形式：** |
|
|
|
|
|
|
|
`single value: || value_size(uint16_t) | slot_num(size_t) || {field_nums(uint16_t), attr1, attr2, ... } |` |
|
|
|
@ -56,15 +58,21 @@ using FieldArray = std::vector>; |
|
|
|
**具体实现如下：** |
|
|
|
```` |
|
|
|
void DBImpl::SerializeValue(const FieldArray& fields, std::string &value, size_t slot_num) { |
|
|
|
// 先构建 slot_num 之后的字符串，存到 tmp_value 中 |
|
|
|
std::string tmp_value; |
|
|
|
// slot_num 之后的总长度 |
|
|
|
uint16_t value_size = sizeof(uint16_t); |
|
|
|
// 字段数目 |
|
|
|
uint16_t field_nums = 0; |
|
|
|
// 遍历所有字段 |
|
|
|
for (const auto& field : fields) { |
|
|
|
// 字段名的长度 |
|
|
|
const uint8_t attr_name_len = field.name.size(); |
|
|
|
// 字段属性的长度 |
|
|
|
const uint16_t attr_value_len = field.value.size(); |
|
|
|
const size_t attr_size = attr_name_len + attr_value_len + sizeof(uint8_t) + sizeof(uint16_t); |
|
|
|
// 用 attr_data 存放：字段名长度 + 字段名 + 字段属性长度 + 字段属性 |
|
|
|
char attr_data[attr_size]; |
|
|
|
|
|
|
|
size_t off = 0; |
|
|
|
memcpy(attr_data+off, &attr_name_len, sizeof(uint8_t)); |
|
|
|
off += sizeof(uint8_t); |
|
|
|
@ -76,13 +84,17 @@ void DBImpl::SerializeValue(const FieldArray& fields, std::string &value, size_t |
|
|
|
off += attr_value_len; |
|
|
|
|
|
|
|
assert(off == attr_size); |
|
|
|
// 将 attr_data 添加到 tmp_value 中 |
|
|
|
tmp_value += std::string(attr_data, attr_size); |
|
|
|
// 更新总长度和字段数目 |
|
|
|
value_size += attr_size; |
|
|
|
field_nums ++; |
|
|
|
} |
|
|
|
|
|
|
|
// value_data 存放完整的字符串 |
|
|
|
char value_data[value_size]; |
|
|
|
// 将 value_size 添加到 value_data 中 |
|
|
|
memcpy(value_data, &value_size, sizeof(uint16_t)); |
|
|
|
// 将 tmp_value 添加到 value_data 中 |
|
|
|
memcpy(value_data+sizeof(uint16_t), tmp_value.c_str(), tmp_value.size()); |
|
|
|
|
|
|
|
assert(sizeof(uint16_t) + tmp_value.size() == value_size); |
|
|
|
@ -106,20 +118,26 @@ void DBImpl::SerializeValue(const FieldArray& fields, std::string &value, size_t |
|
|
|
```` |
|
|
|
void DBImpl::DeserializeValue(FieldArray& fields, const std::string& value_str) { |
|
|
|
const char *value_data = value_str.c_str(); |
|
|
|
// value_len 为 value 的长度 |
|
|
|
const size_t value_len = value_str.size(); |
|
|
|
// 最前面为 value_size，大小为 uint16_t |
|
|
|
size_t attr_off = sizeof(uint16_t); |
|
|
|
|
|
|
|
// 当偏移小于 value 的长度时，继续解码 |
|
|
|
while (attr_off < value_len) { |
|
|
|
// 下面的步骤为：读取属性后加偏移 |
|
|
|
// 读属性名长度，加偏移 |
|
|
|
uint8_t attr_name_len = *(uint8_t *)(value_data+attr_off); |
|
|
|
attr_off += sizeof(uint8_t); |
|
|
|
// 读属性名，加偏移 |
|
|
|
auto attr_name = std::string(value_data+attr_off, attr_name_len); |
|
|
|
attr_off += attr_name_len; |
|
|
|
|
|
|
|
// 读属性长度，加偏移 |
|
|
|
uint16_t attr_len = *(uint16_t *)(value_data+attr_off); |
|
|
|
attr_off += sizeof(uint16_t); |
|
|
|
// 读属性值，加偏移 |
|
|
|
auto attr_value = std::string(value_data+attr_off, attr_len); |
|
|
|
attr_off += attr_len; |
|
|
|
|
|
|
|
// 将 属性名 和 属性 添加到 fields 中 |
|
|
|
fields.push_back({attr_name, attr_value}); |
|
|
|
} |
|
|
|
|
|
|
|
@ -136,8 +154,8 @@ void DBImpl::DeserializeValue(FieldArray& fields, const std::string& value_str) |
|
|
|
```` |
|
|
|
std::vector<std::string> FindKeysByField(leveldb::DB* db, const Field& field) { |
|
|
|
std::vector<std::string> keys; |
|
|
|
// 遍历数据库中所有的 KV 对 |
|
|
|
leveldb::Iterator* it = db->NewIterator(leveldb::ReadOptions()); |
|
|
|
// 遍历数据库中所有的键值对 |
|
|
|
for (it->SeekToFirst(); it->Valid() ; it->Next()) { |
|
|
|
std::string key = it->key().ToString(); |
|
|
|
FieldArray fields; |
|
|
|
@ -163,20 +181,134 @@ std::vector FindKeysByField(leveldb::DB* db, const Field& field) { |
|
|
|
1. KV 分离设计 |
|
|
|
+ a. 将LevelDB的key-value存储结构进行扩展，分离存储key和value |
|
|
|
+ b. Key存储在一个LevelDB实例中，LSM-tree中的value为一个指向Value log文件和偏移地址的指针，用户Value存储在Value log中。 |
|
|
|
2. 读取操作 |
|
|
|
+ a. KV分离后依然支持点查询与范围查询操作。 |
|
|
|
3. value_log 的管理 |
|
|
|
+ a. 当Value log超过一定大小后通过后台GC操作释放Value log中的无效数据。 |
|
|
|
+ b. GC能把旧Value log中没有失效的数据写入新的Value log，并更新LSM-tree里的键值对。 |
|
|
|
+ c. 新旧Value log的管理功能。 |
|
|
|
4. 确保操作的原子性 |
|
|
|
|
|
|
|
#### 2.2.2 实验内容 |
|
|
|
+ 1) 不改变LevelDB原有的接口，实现KV分离。 |
|
|
|
+ 2) 编写测试点验证KV分离是否正确实现。 |
|
|
|
|
|
|
|
##### 设计思路： |
|
|
|
1. value的分离式存储 |
|
|
|
我们使用若干个vlog文件，为每一个vlog文件设置容量上限（比如16MiB），并在内存中为每一个vlog维护一个discard计数器，表示这个vlog中当前有多少value已经在lsm tree中被标记为删除。 |
|
|
|
2. 存储value所在vlog和偏移量的元数据 |
|
|
|
我们在 memtable 和vlog中添加一个slot_page的中间层，这一层存储每一个key对应的value所在的vlog文件和文件内偏移，而lsm tree中的key包含的实际上是这个中间层的slot下标，而每一个slot中存储的是key所对应的vlog文件号以及value在vlog中的偏移。这样，我们就可以在不修改lsm tree的基础上，完成对vlog的compaction，并将vlog的gc结果只反映在这个中间层slot_page中。这个slot_page实际上也是一个线性增长的log文件，作用类似于os中的页表，负责维护lsm tree中存储的slot下标到vlog和vlog内偏移量的一个映射。这样，通过slot_page我们就可以找到具体的vlog文件和其文件内偏移量。对于vlog的GC过程，我们不需要修改lsm tree中的内容，我们只需要修改slot_page中的映射即可。 |
|
|
|
3. slot_page文件和vlog文件的GC |
|
|
|
对于vlog文件，我们在内存中维护一个bitmap，用来表示每一个slot的使用情况，并在插入和GC删除kv时进行动态的分配和释放。对于vlog文件的GC，我们用一个后台线程来扫描所有vlog的discard计数器。当某些vlog的discard计数器超过某个阈值（比如1024），我们就对这些vlog文件进行GC过程，当GC完成之后将slot_page中的slot元数据进行更新，再将原来的vlog文件进行删除，GC过程就完成了。 |
|
|
|
|
|
|
|
##### 相关代码文件 |
|
|
|
- [`/db/db_impl.cc`](./db/db_impl.cc): 修改函数 DBImpl::Get, DBImpl::Put 和 DBImpl::Delete,添加函数 Put_fields, Get_fields, get_slot_num,SerializeValue, DeserializeValue |
|
|
|
- [`/db/db_impl.h`](./db/db_impl.h): 添加两个结构体 SlotPage *slot_page_; VlogSet *vlog_set_ ，添加增加的相关函数的声明 |
|
|
|
- [`/db/shared_lock.h`](./db/shared_lock.h): 定义了一个 SharedLock 类，用于实现读写锁机制。该类支持两种锁模式：软锁（soft_lock/soft_unlock）和硬锁（hard_lock/hard_unlock）; |
|
|
|
- [`/db/slotpage.h`](./db/slotpage.h): |
|
|
|
1. 定义了 slot_content 结构体： |
|
|
|
```` |
|
|
|
struct slot_content { |
|
|
|
uint32_t vlog_num; |
|
|
|
uint32_t value_offset; |
|
|
|
slot_content() {} |
|
|
|
slot_content(uint32_t vn, uint32_t vo) { |
|
|
|
vlog_num = vn; |
|
|
|
value_offset = vo; |
|
|
|
} |
|
|
|
}; |
|
|
|
```` |
|
|
|
2. 定义了 SlotCache 类，类中函数：get_slot, set_slot, read_slot, set_slot; |
|
|
|
3. 定义了 BitMap 类，类中函数： dealloc_slot, alloc_slot, alloc_new_bitmap; |
|
|
|
4. 定义了 Slot_page 类，类中函数： get_slot, set_slot, alloc_slot, dealloc_slot |
|
|
|
- [`/db/vlog.h`](./db/vlog.h) |
|
|
|
1. 定义了 vlog_info 结构体: |
|
|
|
```` |
|
|
|
struct vlog_info { |
|
|
|
std::mutex vlog_info_latch_; // 保护对vlog_info本身的并发修改 |
|
|
|
size_t vlog_num; |
|
|
|
size_t vlog_num_for_gc; // set when start gc |
|
|
|
bool processing_gc;; // init to be false, set as true when processing gc |
|
|
|
bool vlog_valid_; // init to be true, set as false after deleted |
|
|
|
size_t discard; |
|
|
|
size_t value_nums; |
|
|
|
size_t curr_size; |
|
|
|
vlog_info(size_t vlog_num) : processing_gc(false), discard(0), value_nums(0), |
|
|
|
vlog_num(vlog_num), curr_size(2*sizeof(size_t)), vlog_valid_(true) {} |
|
|
|
vlog_info(size_t vlog_num, size_t value_nums, size_t curr_size) : processing_gc(false), |
|
|
|
discard(0), value_nums(value_nums), |
|
|
|
vlog_num(vlog_num), curr_size(curr_size), |
|
|
|
vlog_valid_(true) {} |
|
|
|
}; |
|
|
|
```` |
|
|
|
2. 定义了 vlog_handler 结构体： |
|
|
|
```` |
|
|
|
struct vlog_handler { |
|
|
|
std::mutex vlog_handler_latch_; |
|
|
|
size_t curr_access_thread_nums; |
|
|
|
SharedLock vlog_latch_; // 表明当前vlog上的并发情况，读上soft_lock，写上hard_lock |
|
|
|
vlog_handler() : curr_access_thread_nums(0) {} |
|
|
|
inline void incre_access_thread_nums() { |
|
|
|
vlog_handler_latch_.lock(); |
|
|
|
curr_access_thread_nums ++; |
|
|
|
vlog_handler_latch_.unlock(); |
|
|
|
} |
|
|
|
inline void decre_access_thread_nums() { |
|
|
|
vlog_handler_latch_.lock(); |
|
|
|
curr_access_thread_nums --; |
|
|
|
vlog_handler_latch_.unlock(); |
|
|
|
} |
|
|
|
inline bool non_access_thread() { |
|
|
|
bool flag = false; |
|
|
|
vlog_handler_latch_.lock(); |
|
|
|
if (!curr_access_thread_nums) { |
|
|
|
flag = true; |
|
|
|
} |
|
|
|
vlog_handler_latch_.unlock(); |
|
|
|
return flag; |
|
|
|
} |
|
|
|
}; |
|
|
|
```` |
|
|
|
- [`/db/vlog_gc.h`](./db/vlog_gc.h)： |
|
|
|
|
|
|
|
定义 VlogGC 类，声明类中函数：do_gc, exec_gc, gc_counter_increment, gc_counter_decrement, get_gc_num, vlog_in_gc, add_vlog_in_gc, del_vlog_in_gc |
|
|
|
- [`/db/vlog_gc.cpp`](./db/vlog_gc.cpp)： |
|
|
|
1. 定义了 executor_param 结构体: |
|
|
|
```` |
|
|
|
struct executor_param { |
|
|
|
VlogGC *vg; |
|
|
|
size_t old_vlog_num; |
|
|
|
size_t new_vlog_num; |
|
|
|
}; |
|
|
|
```` |
|
|
|
2. 定义函数：add_executor_params, get_executor_params, del_executor_params, add_vlog_gc, get_vlog_gc, del_vlog_gc, gc_counter_increment, gc_counter_decrement, do_gc, exec_gc |
|
|
|
- [`/db/vlog_set.h`](./db/vlog_set.h)： |
|
|
|
定义 VlogSet 结构体 |
|
|
|
- [`/db/vlog_cache.h`](./db/vlog_cache.h)： |
|
|
|
1. 定义结构体：frame_info, block_frame |
|
|
|
2. 定义类 VlogCache |
|
|
|
- [`/db/vlog_cache.cpp`](./db/vlog_cache.cpp)：实现 VlogCache 类中的函数 |
|
|
|
- [`/db/vlog_set.cpp`](./db/vlog_set.cpp)： |
|
|
|
定义函数: get_value, get_writable_vlog_info, put_value, del_value, register_new_vlog, remove_old_vlog, vlog_need_gc, register_inconfig_file, remove_from_config_file, create_vlog, restore_vlog_inmaps, register_vlog_inmaps, remove_vlog_from_maps, read_vlog_value, write_vlog_value, mark_del_value |
|
|
|
- [`/test/db_test3.cc`](./test/db_test3.cc)：测试 value 的字段功能 |
|
|
|
- [`/test/db_test4.cc`](./test/db_test4.cc) |
|
|
|
- [`/test/db_test5.cc`](./test/db_test5.cc) |
|
|
|
- |
|
|
|
- [`CMakeLists.txt`](CMakeLists.txt)：添加可执行文件 |
|
|
|
|
|
|
|
|
|
|
|
实现方法 |
|
|
|
对于每一次读取，用户线程先读取lsm tree中key的slot_num下标，然后到slot_page中读取对应的slot内容(**每一个slot都是定长的**)，之后再在这个slot中读取value所在的vlog文件号和偏移量offset，之后到对应的vlog文件中读取value。 |
|
|
|
|
|
|
|
但是这又带来了一个问题，我们该如何管理slot_page这个文件？当插入新的kv时，我们需要在这个slot_page中分配新的slot，在GC删除某个kv时，我们需要将对应的slot进行释放。这里我们选择在内存中维护一个可线性扩展的bitmap。这个bitmap中每一个bit标识了当前slot_page文件中对应slot是否被使用，是为1，不是为0。这样一来，在插入新kv时，我们可以用bitmap来分配一个新的slot（将bitmap中第一个为0的bit设置为1），将内容进行写入；在GC删除某个kv时，我们将这个slot对应的bitmap中的bit重置为0即可。 |
|
|
|
|
|
|
|
**数据结构设计：** |
|
|
|
|
|
|
|
`memtable中：| key | slot_num | ` |
|
|
|
`sstable 中：| key | slot_num | ` |
|
|
|
|
|
|
|
`slot_page中: | slot0:{vlog_no(定长), offset(定长)}, slot1:{vlog_no, offset}, ... | ` |
|
|
|
`slot_page 中: | slot0:{vlog_no(定长), offset(定长)}, slot1:{vlog_no, offset}, ... | ` |
|
|
|
|
|
|
|
`value_log 中：|value 长度 | slot_num | attr个数(定长) | attr1_name的长度(定长) | attr1_name(变长) | attr1_value的长度(定长) | attr1_value(变长) | ... |` |
|
|
|
2. 读取操作 |
|
|
|
+ a. KV分离后依然支持点查询与范围查询操作。 |
|
|
|
|
|
|
|
实现方法 |
|
|
|
|
|
|
|
**读操作：** |
|
|
|
|
|
|
|
@ -194,6 +326,9 @@ std::vector FindKeysByField(leveldb::DB* db, const Field& field) { |
|
|
|
6. 调用 set_slot 函数，将 slot_content 中的内容赋值给 slot_num; |
|
|
|
7. 将 slot_num 作为 value 写入数据库中; |
|
|
|
|
|
|
|
相关函数调用链: |
|
|
|
`DBImpl::Put_Fields` |
|
|
|
|
|
|
|
**代码实现：** |
|
|
|
```` |
|
|
|
Status DBImpl::Put_Fields(const WriteOptions& opt, const Slice& key, |
|
|
|
@ -201,7 +336,7 @@ const FieldArray& fields) { |
|
|
|
std::string serialized_value; |
|
|
|
// alloc_slot 函数作用：分配一个 slot_num |
|
|
|
size_t slot_num = slot_page_->alloc_slot(); |
|
|
|
// 调用 SerializeValue 函数将字段数组和 slot_num_str 序列化为字符串 serialized_value |
|
|
|
// SerializeValue 函数作用：将字段数组和 slot_num_str 序列化为字符串 serialized_value |
|
|
|
SerializeValue(fields, serialized_value, slot_num); |
|
|
|
// 实例化 slot_content 结构体 sc |
|
|
|
struct slot_content sc; |
|
|
|
@ -301,7 +436,15 @@ void set_slot(size_t slot_num, struct slot_content *sc) { |
|
|
|
|
|
|
|
**输入：** 待插入的字符串 value，slot_num，slot_content |
|
|
|
|
|
|
|
**具体实现如下：** |
|
|
|
**实现步骤：** |
|
|
|
1. 获取互斥锁； |
|
|
|
2. 根据值的大小获取可写入的vlog信息； |
|
|
|
3. 锁定 vlog 信息，更新 slot_content 内容； |
|
|
|
4. 更新 vlog 内容，包括当前大小 curr_size 和存储的 value 个数； |
|
|
|
5. 根据 vlog 编号获取 vlog 处理器； |
|
|
|
6. 如果 vlog 无效或者正在进行GC，则使用 vlog_num_for_gc； |
|
|
|
7. 调用 write_vlog_value 函数，将字符串 serialized_value 写入 vlog 中 |
|
|
|
**具体实现如下：** |
|
|
|
```` |
|
|
|
void VlogSet::put_value(struct slot_content &sc, size_t slot_num, const leveldb::Slice &value) { |
|
|
|
mtx.lock(); |
|
|
|
@ -332,7 +475,7 @@ void VlogSet::put_value(struct slot_content &sc, size_t slot_num, const leveldb: |
|
|
|
mtx.unlock(); // for better performance |
|
|
|
// vlog 信息写入完毕，解锁 |
|
|
|
vinfo->vlog_info_latch_.unlock(); |
|
|
|
// 调用 write_vlog_value 函数，将字符串 serialized_value 写入 vlog 中 |
|
|
|
// write_vlog_value 函数功能：将字符串 serialized_value 写入 vlog 中 |
|
|
|
write_vlog_value(sc, slot_num, value); |
|
|
|
// 写入完毕，减少访问线程数 |
|
|
|
vhandler->decre_access_thread_nums(); // FIXME: decrease thread nums |
|
|
|
@ -347,6 +490,11 @@ void VlogSet::put_value(struct slot_content &sc, size_t slot_num, const leveldb: |
|
|
|
**输入：** slot_content，slot_num，字符串 value |
|
|
|
|
|
|
|
**实现步骤：** |
|
|
|
1. 获取 vlog 名称； |
|
|
|
2. 打开 vlog 文件； |
|
|
|
3. 定位写入位置； |
|
|
|
4. 构造要写入的数据； |
|
|
|
5. 写入数据。 |
|
|
|
|
|
|
|
**具体实现如下：** |
|
|
|
```` |
|
|
|
@ -377,17 +525,12 @@ void VlogSet::write_vlog_value(const struct slot_content &sc, size_t slot_num, c |
|
|
|
|
|
|
|
`Status DBImpl::Get_Fields(const ReadOptions& options, const Slice& key,FieldArray& fields)` |
|
|
|
|
|
|
|
**功能：** |
|
|
|
|
|
|
|
从数据库中读取 key 对应的字段数组 |
|
|
|
**功能：** 从数据库中读取 key 对应的字段数组并存放到 fields 中 |
|
|
|
|
|
|
|
**步骤：** |
|
|
|
|
|
|
|
读取流程 |
|
|
|
**实现步骤：** |
|
|
|
1. 读取 key 对应的 slot_num |
|
|
|
2. 实例化 slot_content 结构体 sc |
|
|
|
3. 调用 get_slot 函数，根据 slot_num 从缓存中获取 slot_content |
|
|
|
4. 调用 get_value 函数，根据 sc 中的 vlog_num(vlog编号) 和 value_offset(在vlog中的偏移量) 从 vlog 中读取字符串 |
|
|
|
2. 调用 get_slot 函数，根据 slot_num 从 slot_page 中获取 slot_content |
|
|
|
4. 调用 get_value 函数，根据 slot_content 中的 vlog_num(vlog编号) 和 value_offset(在vlog中的偏移量) 从 vlog 中读取字符串 |
|
|
|
5. 将字符串解码得到 value |
|
|
|
|
|
|
|
**代码实现：** |
|
|
|
@ -417,7 +560,7 @@ return Status::OK(); |
|
|
|
```` |
|
|
|
`void get_slot(size_t slot_num, struct slot_content *sc)` |
|
|
|
|
|
|
|
**功能：** 获取 slot_num 对应的 slot_content |
|
|
|
**功能：** 获取 slot_num 对应的 slot_content 并存放到 sc 中 |
|
|
|
|
|
|
|
**实现步骤：** |
|
|
|
1. 计算块编号：根据槽位号计算出对应的块编号。 |
|
|
|
@ -427,7 +570,8 @@ return Status::OK(); |
|
|
|
5. 读取新块：从磁盘读取新的块到缓存，并更新访问时间和块信息。 |
|
|
|
6. 读取槽位内容：从缓存块中读取指定槽位的内容。 |
|
|
|
7. 解锁缓存块：操作完成后解锁。 |
|
|
|
**具体实现如下：** |
|
|
|
|
|
|
|
**具体实现如下：** |
|
|
|
```` |
|
|
|
void get_slot(size_t slot_num, struct slot_content *sc) { |
|
|
|
auto block_num = slotnum_hash2_blocknum(slot_num); |
|
|
|
@ -449,12 +593,14 @@ void get_slot(size_t slot_num, struct slot_content *sc) { |
|
|
|
|
|
|
|
`void VlogSet::get_value(const struct slot_content &sc, std::string *value)` |
|
|
|
|
|
|
|
**功能：** 从 vlog 中读取字符串 |
|
|
|
**功能：** 根据 slot_content 从 vlog 中读取字符串并存放到 value 中 |
|
|
|
|
|
|
|
**实现步骤：** |
|
|
|
1. 获取 vlog_num 和 vlog_handler |
|
|
|
|
|
|
|
**具体实现如下：** |
|
|
|
1. 根据 sc.vlog_num 获取 vinfo 和 vlog_handler； |
|
|
|
2. 加 vlog 信息锁； |
|
|
|
3. 根据 vinfo 中的信息检查 vlog 是否有效； |
|
|
|
4. 调用 read_vlog_value 函数，根据 sc 中的 vlog_num 和 value_offset 从 vlog 中读取字符串 |
|
|
|
**具体实现如下：** |
|
|
|
```` |
|
|
|
void VlogSet::get_value(const struct slot_content &sc, std::string *value) { |
|
|
|
// 获取互斥锁 |
|
|
|
@ -490,8 +636,14 @@ void VlogSet::get_value(const struct slot_content &sc, std::string *value) { |
|
|
|
**功能：** 根据 sc 中的 vlog_num 和 value_offset 从 vlog 中读取字符串并存放到 value |
|
|
|
|
|
|
|
**实现步骤：** |
|
|
|
1. 根据 sc 中的 vlog_num 获取 vlog 文件名 |
|
|
|
**具体实现如下：** |
|
|
|
1. 获取 vlog 文件名； |
|
|
|
2. 打开 vlog 文件； |
|
|
|
3. 定位文件指针到 value_offset 指定的位置； |
|
|
|
4. 读取固定大小的数据到缓冲区 value_buff； |
|
|
|
5. 从缓冲区中提取 value 的大小，value_size 字段设置了标志位，用于检查是否被标记为删除, 如果被标记为删除，则将结果字符串设置为空并返回; |
|
|
|
6. 计算实际值的大小并从缓冲区中提取值，存储到结果字符串中 |
|
|
|
|
|
|
|
**具体实现如下：** |
|
|
|
```` |
|
|
|
void VlogSet::read_vlog_value(const struct slot_content &sc, std::string *value) { |
|
|
|
// 根据 sc 中的 vlog_num 获取 vlog 文件名 |
|
|
|
@ -503,7 +655,7 @@ void VlogSet::read_vlog_value(const struct slot_content &sc, std::string *value) |
|
|
|
// 从文件中读取固定大小的数据到缓冲区 value_buff |
|
|
|
char value_buff[VALUE_BUFF_SIZE]; |
|
|
|
handler.read(value_buff, VALUE_BUFF_SIZE); |
|
|
|
// 从缓冲区中提取值的大小，并检查是否被删除标记 |
|
|
|
// 从缓冲区中提取值的大小，并检查是否被标记为删除 |
|
|
|
uint16_t value_size; |
|
|
|
memcpy(&value_size, value_buff, sizeof(uint16_t)); |
|
|
|
// 如果值带有删除标记，则将结果字符串设置为空并返回 |
|
|
|
@ -515,6 +667,7 @@ void VlogSet::read_vlog_value(const struct slot_content &sc, std::string *value) |
|
|
|
value_size &= VALUE_SIZE_MASK; |
|
|
|
assert(value_size <= VALUE_BUFF_SIZE); |
|
|
|
const size_t off = sizeof(uint16_t)+sizeof(size_t); |
|
|
|
// 减去 off 的长度，只读取出 value 中实际存放属性的部分 |
|
|
|
*value = std::string(&value_buff[off], value_size-off); |
|
|
|
// 关闭文件 |
|
|
|
handler.close(); |
|
|
|
@ -525,11 +678,14 @@ void VlogSet::read_vlog_value(const struct slot_content &sc, std::string *value) |
|
|
|
**功能：** 删除 key 对应的条目 |
|
|
|
|
|
|
|
**步骤：** |
|
|
|
1. 获取 key 对应的 slot_num |
|
|
|
1. 从 sstable 中获取 key 对应的 slot_num； |
|
|
|
2. 获取 slot_num 对应的 slot_content； |
|
|
|
3. 删除 vlog 中 slot_content 对应的条目； |
|
|
|
4. 释放 slot_num 中对应的 slot_content；? |
|
|
|
5. 删除 sstable 中 key 对应的条目。 |
|
|
|
|
|
|
|
**代码实现：** |
|
|
|
```` |
|
|
|
// 删除操作，删除 key 对应的条目 |
|
|
|
Status DBImpl::Delete(const WriteOptions& options, const Slice& key) { |
|
|
|
size_t slot_num; |
|
|
|
// get_slot_num 函数的作用: 获取 key 对应的 slot_num |
|
|
|
@ -539,63 +695,126 @@ return s; |
|
|
|
} |
|
|
|
|
|
|
|
struct slot_content sc; |
|
|
|
// get_slot 函数作用: |
|
|
|
// get_slot 函数作用: 获取 slot_num 对应的 slot_content |
|
|
|
slot_page_->get_slot(slot_num, &sc); |
|
|
|
// del_value 函数作用: |
|
|
|
// del_value 函数作用:删除 vlog 中 slot_content 对应的条目 |
|
|
|
vlog_set_->del_value(sc); |
|
|
|
// dealloc_slot 函数作用: 释放 slot_num 对应的 slot |
|
|
|
slot_page_->dealloc_slot(slot_num); |
|
|
|
|
|
|
|
return DB::Delete(options, key); |
|
|
|
} |
|
|
|
```` |
|
|
|
3. value_log 的管理 |
|
|
|
+ a. 当Value log超过一定大小后通过后台GC操作释放Value log中的无效数据。 |
|
|
|
+ b. GC能把旧Value log中没有失效的数据写入新的Value log，并更新LSM-tree里的键值对。 |
|
|
|
+ c. 新旧Value log的管理功能。 |
|
|
|
`void VlogSet::del_value(const struct slot_content &sc)` |
|
|
|
|
|
|
|
**GC 和 slot_page 管理, vlog管理：** |
|
|
|
4. 确保操作的原子性 |
|
|
|
**功能：** 删除 vlog 中 slot_content 对应的条目 |
|
|
|
|
|
|
|
**锁机制：** |
|
|
|
[`/db/shared_lock.h`](./db/shared_lock.h) 定义了一个 SharedLock 类，用于实现读写锁机制，包含四种操作：soft_lock():获取共享读锁，确保在没有写操作时允许多个读操作并发进行；soft_unlock():释放共享读锁；hard_lock():获取独占写锁，确保只有当没有其他读写操作时，允许写入操作进行；hard_unlock():释放独占写锁。 |
|
|
|
#### 2.2.1 实验内容 |
|
|
|
+ 1) 不改变LevelDB原有的接口，实现KV分离。 |
|
|
|
+ 2) 编写测试点验证KV分离是否正确实现。 |
|
|
|
**实现步骤：** |
|
|
|
1. 加锁：使用互斥锁 mtx 确保线程安全。 |
|
|
|
2. 获取信息：通过 sc.vlog_num 获取对应的 vlog 信息和处理器。 |
|
|
|
3. 检查状态：如果 vlog 无效或正在处理垃圾回收，则更新处理器为垃圾回收的 vlog。 |
|
|
|
4. 加锁并增加访问计数：对 vlog 处理器加锁，并增加访问线程数。 |
|
|
|
5. 解锁：释放互斥锁和 vlog 信息锁。 |
|
|
|
6. 标记删除：调用 mark_del_value 标记删除操作。 |
|
|
|
7. 减少访问计数并解锁：减少访问线程数并解锁 vlog |
|
|
|
|
|
|
|
**设计思路：** |
|
|
|
1. value的分离式存储 |
|
|
|
我们使用若干个vlog文件，为每一个vlog文件设置容量上限（比如16MiB），并在内存中为每一个vlog维护一个discard计数器，表示这个vlog中当前有多少value已经在lsm tree中被标记为删除。 |
|
|
|
2. 存储value所在vlog和偏移量的元数据 |
|
|
|
我们在 memtable 和vlog中添加一个slot_page的中间层，这一层存储每一个key对应的value所在的vlog文件和文件内偏移，而lsm tree中的key包含的实际上是这个中间层的slot下标，而每一个slot中存储的是key所对应的vlog文件号以及value在vlog中的偏移。这样，我们就可以在不修改lsm tree的基础上，完成对vlog的compaction，并将vlog的gc结果只反映在这个中间层slot_page中。这个slot_page实际上也是一个线性增长的log文件，作用类似于os中的页表，负责维护lsm tree中存储的slot下标到vlog和vlog内偏移量的一个映射。这样，通过slot_page我们就可以找到具体的vlog文件和其文件内偏移量。对于vlog的GC过程，我们不需要修改lsm tree中的内容，我们只需要修改slot_page中的映射即可。 |
|
|
|
3. slot_page文件和vlog文件的GC |
|
|
|
对于vlog文件，我们在内存中维护一个bitmap，用来表示每一个slot的使用情况，并在插入和GC删除kv时进行动态的分配和释放。对于vlog文件的GC，我们用一个后台线程来扫描所有vlog的discard计数器。当某些vlog的discard计数器超过某个阈值（比如1024），我们就对这些vlog文件进行GC过程，当GC完成之后将slot_page中的slot元数据进行更新，再将原来的vlog文件进行删除，GC过程就完成了。 |
|
|
|
**具体实现如下：** |
|
|
|
```` |
|
|
|
void VlogSet::del_value(const struct slot_content &sc) { |
|
|
|
mtx.lock(); |
|
|
|
auto vinfo = get_vlog_info(sc.vlog_num); |
|
|
|
auto vhandler = get_vlog_handler(sc.vlog_num); |
|
|
|
|
|
|
|
##### 2.2.1 相关代码文件 |
|
|
|
- [`/db/db_impl.cc`](./db/db_impl.cc): 修改函数 DBImpl::Get, DBImpl::Put 和 DBImpl::Delete,添加函数 Put_fields, Get_fields, get_slot_num,SerializeValue, DeserializeValue |
|
|
|
- [`/db/db_impl.h`](./db/db_impl.h): 添加两个结构体 SlotPage *slot_page_; VlogSet *vlog_set_ ，添加增加的相关函数的声明 |
|
|
|
- |
|
|
|
- [`/db/shared_lock.h`](./db/shared_lock.h) 定义了一个 SharedLock 类，用于实现读写锁机制，包含四种操作：soft_lock():获取共享读锁，确保在没有写操作时允许多个读操作并发进行；soft_unlock():释放共享读锁；hard_lock():获取独占写锁，确保只有当没有其他读写操作时，允许写入操作进行；hard_unlock():释放独占写锁。 |
|
|
|
- [`/db/slotpage.h`](./db/slotpage.h) |
|
|
|
- [`/db/threadpool.h`](./db/threadpool.h) |
|
|
|
- [`/db/vlog.h`](./db/vlog.h) |
|
|
|
- [`/db/vlog_gc.cpp`](./db/vlog_gc.cpp) |
|
|
|
- [`/db/vlog_gc.h`](./db/vlog_gc.h) |
|
|
|
- [`/db/vlog_set.cpp`](./db/vlog_set.cpp) |
|
|
|
- [`/db/vlog_set.h`](./db/vlog_set.h) |
|
|
|
- |
|
|
|
- [`/test/db_test3.cc`](./test/db_test3.cc)：测试 value 的字段功能 |
|
|
|
- [`/test/db_test4.cc`](./test/db_test4.cc) |
|
|
|
- [`/test/db_test5.cc`](./test/db_test5.cc) |
|
|
|
- |
|
|
|
- [`CMakeLists.txt`](CMakeLists.txt)：添加可执行文件 |
|
|
|
vinfo->vlog_info_latch_.lock(); |
|
|
|
if (!vinfo->vlog_valid_ || vinfo->processing_gc) { |
|
|
|
vhandler = get_vlog_handler(vinfo->vlog_num_for_gc); |
|
|
|
} |
|
|
|
|
|
|
|
vhandler->vlog_latch_.hard_lock(); |
|
|
|
vhandler->incre_access_thread_nums(); // FIXME: increase thread nums |
|
|
|
mtx.unlock(); // for better performance |
|
|
|
vinfo->vlog_info_latch_.unlock(); |
|
|
|
mark_del_value(sc); |
|
|
|
vhandler->decre_access_thread_nums(); // FIXME: decrease thread nums |
|
|
|
vhandler->vlog_latch_.hard_unlock(); |
|
|
|
} |
|
|
|
```` |
|
|
|
`void VlogSet::mark_del_value(const struct slot_content &sc)` |
|
|
|
|
|
|
|
对于每一次读取，用户线程先读取lsm tree中key的slot_num下标，然后到slot_page中读取对应的slot内容(**每一个slot都是定长的**)，之后再在这个slot中读取value所在的vlog文件号和偏移量offset，之后到对应的vlog文件中读取value。 |
|
|
|
**功能：** 标记 slot_content 对应的条目为删除并判断是否需要调用 GC |
|
|
|
|
|
|
|
但是这又带来了一个问题，我们该如何管理slot_page这个文件？当插入新的kv时，我们需要在这个slot_page中分配新的slot，在GC删除某个kv时，我们需要将对应的slot进行释放。这里我们选择在内存中维护一个可线性扩展的bitmap。这个bitmap中每一个bit标识了当前slot_page文件中对应slot是否被使用，是为1，不是为0。这样一来，在插入新kv时，我们可以用bitmap来分配一个新的slot（将bitmap中第一个为0的bit设置为1），将内容进行写入；在GC删除某个kv时，我们将这个slot对应的bitmap中的bit重置为0即可。 |
|
|
|
**实现步骤：** |
|
|
|
1. 获取日志信息：根据传入的槽内容（slot_content），获取对应的日志文件信息和名称 |
|
|
|
2. 读取并检查日志项：打开日志文件，读取指定偏移量的日志项数据，检查是否已被删除。如果已被删除，则直接返回 |
|
|
|
3. 标记删除：如果没有被删除，则设置删除标志位，并更新日志文件中的数据 |
|
|
|
4. 更新统计信息：增加丢弃计数，减少值的数量和当前大小 |
|
|
|
5. 触发垃圾回收：如果需要进行垃圾回收且未在处理中，则创建新的日志文件并启动垃圾回收过程 |
|
|
|
**具体实现如下：** |
|
|
|
```` |
|
|
|
void VlogSet::mark_del_value(const struct slot_content &sc) { |
|
|
|
// 根据 sc.vlog_num 获取 vlog 文件信息和名称 |
|
|
|
auto vinfo = get_vlog_info(sc.vlog_num); |
|
|
|
auto vlog_name = get_vlog_name(sc.vlog_num); |
|
|
|
// 打开日志文件并读取头部信息 |
|
|
|
auto handler = std::fstream(vlog_name, std::ios::in | std::ios::out); |
|
|
|
handler.seekp(sc.value_offset); |
|
|
|
char value_buff[VALUE_BUFF_SIZE]; |
|
|
|
handler.read(value_buff, VALUE_BUFF_SIZE); |
|
|
|
// 判断标志位是否为删除 |
|
|
|
uint16_t value_size; |
|
|
|
memcpy(&value_size, value_buff, sizeof(uint16_t)); |
|
|
|
if (value_size & VALUE_DELE_MASK) { |
|
|
|
// case when value has been deleted |
|
|
|
handler.close(); |
|
|
|
return ; |
|
|
|
} |
|
|
|
// 如果未被设置为删除，则设置删除标志位 |
|
|
|
assert(!(value_size & VALUE_DELE_MASK)); |
|
|
|
uint16_t masked_value_size = value_size | (uint16_t)VALUE_DELE_MASK; |
|
|
|
// 写回更新后的 value_size |
|
|
|
memcpy(value_buff, &masked_value_size, sizeof(uint16_t)); |
|
|
|
handler.seekp(sc.value_offset); |
|
|
|
handler.write(value_buff, sizeof(uint16_t)); |
|
|
|
handler.flush(); |
|
|
|
handler.close(); |
|
|
|
|
|
|
|
### 3. 功能测试 |
|
|
|
#### 3.1 在 LevelDB 的 value 中实现字段功能 |
|
|
|
// handle gc, mtx is locked outside, vlog_info_latch and vlog hard lock is locked outside too |
|
|
|
// 更新统计信息，包括 增加丢弃计数 discard， 减少值的数量 value_nums， 减少当前大小 curr_size，减去被删除的日志项的大小 value_size |
|
|
|
vinfo->discard ++; |
|
|
|
vinfo->value_nums --; |
|
|
|
vinfo->curr_size -= value_size; |
|
|
|
// FIXME: gc process, avoid repeated gc |
|
|
|
// 判断是否需要触发垃圾回收 |
|
|
|
if (vlog_need_gc(sc.vlog_num) && !vinfo->processing_gc) { |
|
|
|
// create new vlog |
|
|
|
vinfo->processing_gc = true; |
|
|
|
vinfo->vlog_num_for_gc = register_new_vlog(); |
|
|
|
// 启动垃圾回收过程 |
|
|
|
vlog_gc->do_gc(sc.vlog_num, vinfo->vlog_num_for_gc); |
|
|
|
} |
|
|
|
} |
|
|
|
```` |
|
|
|
`void SlotPage::dealloc_slot(size_t slot_num)` |
|
|
|
**功能：** 释放 slot_num 中对应的 slot |
|
|
|
|
|
|
|
**实现步骤：** |
|
|
|
|
|
|
|
**具体实现如下：** |
|
|
|
```` |
|
|
|
void dealloc_slot(size_t slot_num) { |
|
|
|
mtx.lock(); |
|
|
|
const size_t byte = slot2byte(slot_num); |
|
|
|
const size_t off = slot2offset(slot_num); |
|
|
|
char *target_byte = get_bitmap_byte(byte); |
|
|
|
assert(*target_byte & POSMASK(off)); |
|
|
|
RESETBIT(target_byte, off); |
|
|
|
// set_bitmap_byte(byte, target_byte); |
|
|
|
first_empty_slot = first_empty_slot < slot_num ? first_empty_slot:slot_num; |
|
|
|
mtx.unlock(); |
|
|
|
} |
|
|
|
```` |
|
|
|
## 3. 功能测试 |
|
|
|
### 3.1 在 LevelDB 的 value 中实现字段功能 |
|
|
|
1. 以字段形式插入,读取数据 |
|
|
|
2. 根据 key 删除数据 |
|
|
|
3. 通过字段值查询对应的 key |
|
|
|
@ -680,26 +899,28 @@ int main(int argc, char** argv) { |
|
|
|
```` |
|
|
|
**测试结果：** |
|
|
|
|
|
|
|
|
|
|
|
#### 3.2 测试并发插入和读取数据 |
|
|
|
#### 3.3 测试 GC |
|
|
|
#### 3.4 测试 |
|
|
|
### 3.2 |
|
|
|
### 3.3 测试并发插入和读取数据 |
|
|
|
### 3.4 测试 GC |
|
|
|
### 3.5 测试 |
|
|
|
单元测试: |
|
|
|
1. 测试插入超过初始slot_page等slot数量之后，是否还能正常插入，检查slot_page文件等线性可扩展性 |
|
|
|
2. 测试插入后，进行删除，等待GC完成后再读取value和vlog的大小，看看GC过程是否正常进行。 |
|
|
|
|
|
|
|
### 4. 性能测试: |
|
|
|
#### 4.1 测试吞吐量 |
|
|
|
#### 4.2 测试延迟 |
|
|
|
#### 4.3 测试写放大 |
|
|
|
## 4. 性能测试: |
|
|
|
### 4.1 测试吞吐量 |
|
|
|
### 4.2 测试延迟 |
|
|
|
### 4.3 测试写放大 |
|
|
|
|
|
|
|
吞吐率下降很多 |
|
|
|
写放大下降很多 |
|
|
|
#### 6. 可能遇到的挑战与解决方案 |
|
|
|
### 5. 实验中遇到的问题和解决方案 |
|
|
|
### 6. 现有优化手段的分析与可能的优化 |
|
|
|
### 7. 可能遇到的挑战与解决方案 |
|
|
|
列出实现过程中可能遇到的技术难题及其解决思路，如如何处理GC开销、数据同步、索引原子更新等问题。 |
|
|
|
各种参数的设置，比如vlog的容量上限，以及slot_page的bitmap管理方式是否足够高效？以及在GC过程中如果对被GC中的vlog进行写入该让用户线程和后台线程以什么样的方式进行同步？slot_page的读写放大也是一个重要的问题。 |
|
|
|
|
|
|
|
#### 7. 分工和进度安排 |
|
|
|
### 8. 分工和进度安排 |
|
|
|
|
|
|
|
| 功能 | 完成日期 | 分工 | |
|
|
|
|----------------------|-------|----------| |
|
|
|
@ -710,11 +931,4 @@ int main(int argc, char** argv) { |
|
|
|
| 修改leveldb的接口实现字段功能 | 12.17 | 王雪飞 | |
|
|
|
| vlog的GC实现 | 12.29 | 马也驰 | |
|
|
|
| 性能测试 | 1.5 | 王雪飞, 马也驰 | |
|
|
|
| 功能测试 | 1.5 | 王雪飞， 马也驰 | |
|
|
|
|
|
|
|
报告待完成部分： |
|
|
|
+ alloc_slot() set_slot() get_slot() |
|
|
|
+ gc过程 |
|
|
|
+ slot_page 管理,value_log 管理 |
|
|
|
+ 性能测试 |
|
|
|
+ 功能测试 |
|
|
|
| 功能测试 | 1.5 | 王雪飞， 马也驰 | |
