From 40dd4ce38702ce164fcca3b93790425df044ede0 Mon Sep 17 00:00:00 2001
From: wangxuefei <10225501435@stu.ecnu.edu.cn>
Date: Sun, 5 Jan 2025 17:42:24 +0800
Subject: [PATCH] modify report.md

---
 report.md | 404 +++++++++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 309 insertions(+), 95 deletions(-)

diff --git a/report.md b/report.md
index 6faf540..fa48e46 100644
--- a/report.md
+++ b/report.md
@@ -45,6 +45,8 @@ using FieldArray = std::vector<std::pair<std::string, std::string>>;
 
 **功能：** 将传入的字段数组和 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<std::pair<std::string, std::string>>;
 **具体实现如下：**
 ````
 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<std::string> 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<std::string> 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 管理
-+ 性能测试
-+ 功能测试
\ No newline at end of file
+| 功能测试                 | 1.5   | 王雪飞， 马也驰 |
\ No newline at end of file