10225501435
/
LSM_tree_KV_Separation
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

modify report.md

master
王雪飞 8 months ago
parent
c653bd53f9
commit
40dd4ce387
1 changed files with 309 additions and 95 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +309
    -95
      report.md

+ 309
- 95
report.md View File

@ -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 | 王雪飞， 马也驰 |

Write Preview
Loading…
Cancel
Save