diff --git a/report.md b/report.md
index e92043d..85c25df 100644
--- a/report.md
+++ b/report.md
@@ -39,11 +39,23 @@
 ````
 using Field = std::pair<std::string, std::string>;	  // field_name:field_value
 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 序列化为字符串，并存到 value
+
+**字符串形式：**
+
+`single value: || value_size(uint16_t) | slot_num(size_t) || {field_nums(uint16_t), attr1, attr2, ... } |`
+
+`single attr: | attr1_name_len(uint8_t) | attr1_name | attr1_len(uint16_t) | attr1 |`
 
-// 编码函数,将传入的字段数组和 slot_num 序列化为字符串，并存到 value 
+**输入：** 字段数组, slot_num, &value
+
+**具体实现如下：**
+````
 void DBImpl::SerializeValue(const FieldArray& fields, std::string &value, size_t slot_num) {
-  // single value: || value_size(uint16_t) | slot_num(size_t) || {field_nums(uint16_t), attr1, attr2, ... } |
-  // single attr: | attr1_name_len(uint8_t) | attr1_name | attr1_len(uint16_t) | attr1 |
   std::string tmp_value;
   uint16_t value_size = sizeof(uint16_t);
   uint16_t field_nums = 0;
@@ -76,11 +88,23 @@ void DBImpl::SerializeValue(const FieldArray& fields, std::string &value, size_t
   assert(sizeof(uint16_t) + tmp_value.size() == value_size);
   value = std::string(value_data, value_size);
 }
+````
+##### 解码函数：
+`void DBImpl::DeserializeValue(FieldArray& fields, const std::string& value_str)`
+
+**功能：** 将传入的待解码字符串反序列化为字段数组并存到 fields
 
-// 解码函数 将传入的 value_str 字符串反序列化为字段数组并存到 fields
+**字符串形式：**
+
+`single value: || value_size(uint16_t) | slot_num(size_t) || {field_nums(uint16_t), attr1, attr2, ... } |`
+
+`single attr: | attr1_name_len(uint8_t) | attr1_name | attr1_len(uint16_t) | attr1 |`
+
+**输入：** 存放解码结果的字段数组，待解码的字符串
+
+**具体实现如下：**
+````
 void DBImpl::DeserializeValue(FieldArray& fields, const std::string& value_str) {
-  // single value: || value_size(uint16_t) | slot_num(size_t) || {field_nums(uint16_t), attr1, attr2, ... } |
-  // single attr: | attr1_name_len(uint8_t) | attr1_name | attr1_len(uint16_t) | attr1 |
   const char *value_data = value_str.c_str();
   const size_t value_len = value_str.size();
   size_t attr_off = sizeof(uint16_t);
@@ -103,9 +127,13 @@ void DBImpl::DeserializeValue(FieldArray& fields, const std::string& value_str)
 }
 ````
 2. 通过字段查询 Key: 实现函数 FindKeysByField，传入字段名和字段的值就可以找到对应的key
+
+`std::vector<std::string> FindKeysByField(leveldb::DB* db, const Field& field)`
+
+**功能：** 根据传入的字段值 field 查找所有包含该字段的 key，由于一个字段值可能对应多个key，所以返回`std::vector<std::string>`
+
+**具体实现如下：**
 ````
-// 根据字段值查找所有包含该字段的 key
-// 一个字段值可能对应多个key，所以返回std::vector<std::string>
 std::vector<std::string> FindKeysByField(leveldb::DB* db, const Field& field) {
   std::vector<std::string> keys;
   leveldb::Iterator* it = db->NewIterator(leveldb::ReadOptions());
@@ -115,7 +143,7 @@ std::vector<std::string> FindKeysByField(leveldb::DB* db, const Field& field) {
     FieldArray fields;
     // 调用 Get_Fields 函数，获取 key 对应的字段数组
     db->Get_Fields(leveldb::ReadOptions(), key, fields);
-    // 便利字段数组，如果字段数组中包含该字段，则将该 key 添加到 keys 中
+    // 遍历字段数组，如果字段数组中包含该字段，则将该 key 添加到 keys 中
     for (const auto& f : fields) {
       if (f.name == field.name && f.value == field.value) {
         keys.push_back(key);
@@ -129,36 +157,42 @@ std::vector<std::string> FindKeysByField(leveldb::DB* db, const Field& field) {
 }
 ````
 
-#### 2.1.3 实验结果
-
-
 ### 2.2 KV分离
-**设计目标：**
 在LevelDB中实现KV分离，即将键值对中的键和值存储在不同的存储区域，以优化写性能和点查询性能。
 #### 2.2.1 实验要求
 1. KV 分离设计
 + a. 将LevelDB的key-value存储结构进行扩展，分离存储key和value
 + b. Key存储在一个LevelDB实例中，LSM-tree中的value为一个指向Value log文件和偏移地址的指针，用户Value存储在Value log中。
+
+**数据结构设计：**
+
+`memtable中：| key | slot_num | `
+
+`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分离后依然支持点查询与范围查询操作。
-3. value_log 的管理
-+ a. 当Value log超过一定大小后通过后台GC操作释放Value log中的无效数据。
-+ b. GC能把旧Value log中没有失效的数据写入新的Value log，并更新LSM-tree里的键值对。
-+ c. 新旧Value log的管理功能。
-4. 确保操作的原子性
-#### 2.2.1 实验内容
-+ 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过程就完成了。
+**读写操作：**
+
+`Status DBImpl::Put_Fields(const WriteOptions& opt, const Slice& key, const FieldArray& fields)`
+
+**功能：**
+
+将传入的字段数组插入数据库中
+
+**步骤：**
+1. 为当前 KV 对分配一个 size_t 类型的 slot_num；
+2. 将 slot_num 转化为字符串形式 slot_num_str；
+3. 调用 SerializeValue 函数将字段数组和 slot_num_str 序列化为字符串 serialized_value；
+4. 实例化 slot_content 结构体 sc;
+5. 调用 put_value 函数，以 sc 中的 vlog_num(vlog编号) 和 value_offset(在vlog中的偏移量) 为参数，将字符串 serialized_value 写入 vlog 中;
+6. 调用 set_slot 函数，将 slot_content 中的内容赋值给 slot_num;
+7. 将 slot_num 作为 value 写入数据库中;
+
+**代码实现：**
 ````
-// 将传入的字段数组插入数据库中
 Status DBImpl::Put_Fields(const WriteOptions& opt, const Slice& key,
 const FieldArray& fields) {
 std::string serialized_value;
@@ -177,8 +211,25 @@ Slice slot_val(data, sizeof(data));
 // 将 slot_num 作为 value 插入 memtable 中
 return DB::Put(opt, key, slot_val);
 }
+````
 
-// 从数据库中读取 key 对应的字段数组
+`Status DBImpl::Get_Fields(const ReadOptions& options, const Slice& key,FieldArray& fields)`
+
+**功能：**
+
+从数据库中读取 key 对应的字段数组
+
+**步骤：**
+
+读取流程
+1. 读取 key 对应的 slot_num
+2. 实例化 slot_content 结构体 sc
+3. 根据 slot_num 从 slot_page_ 中读取 slot_content
+4. 利用 sc 中的 vlog_num(vlog编号) 和 value_offset(在vlog中的偏移量) 从 vlog 中读取字符串
+5. 将字符串进行解码得到 value
+
+**代码实现：**
+````
 Status DBImpl::Get_Fields(const ReadOptions& options, const Slice& key,
 FieldArray& fields) {
 size_t slot_num;
@@ -197,12 +248,61 @@ vlog_set_->get_value(sc, &vlog_value);
 if (vlog_value.empty()) {
 return Status::NotFound("value has been deleted");
 }
-
 // 调用 DeserializeValue 函数，将 vlog_value 解码为字段数组 fields
 DeserializeValue(fields, vlog_value);
 return Status::OK();
 }
 ````
+`Status DBImpl::Delete(const WriteOptions& options, const Slice& key)`
+
+**功能：** 删除 key 对应的条目
+
+**步骤：**
+1. 获取 key 对应的 slot_num
+
+**代码实现：**
+````
+// 删除操作，删除 key 对应的条目
+Status DBImpl::Delete(const WriteOptions& options, const Slice& key) {
+size_t slot_num;
+// get_slot_num 函数的作用: 获取 key 对应的 slot_num
+auto s = get_slot_num(ReadOptions(), key, &slot_num);
+if (!s.ok()) {
+return s;
+}
+
+struct slot_content sc;
+// get_slot 函数作用:
+slot_page_->get_slot(slot_num, &sc);
+// del_value 函数作用:
+vlog_set_->del_value(sc);
+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的管理功能。
+
+**GC 和 slot_page 管理, vlog管理：**
+4. 确保操作的原子性
+
+**锁机制：**
+
+#### 2.2.1 实验内容
++ 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过程就完成了。
+
 ##### 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_ ，添加增加的相关函数的声明
@@ -221,98 +321,12 @@ return Status::OK();
 - [`/test/db_test5.cc`](./test/db_test5.cc)
 -
 - [`CMakeLists.txt`](CMakeLists.txt)：添加可执行文件
-##### 2.2.1 具体流程
-
-1. 为当前 KV 对分配一个 size_t 类型的 slot_num；
-2. 将 slot_num 转化为字符串形式 slot_num_str；
-3. 调用 SerializeValue 函数将字段数组和 slot_num_str 序列化为字符串 serialized_value；
-4. 实例化 slot_content 结构体 sc;
-5. 调用 put_value 函数，以 sc 中的 vlog_num(vlog编号) 和 value_offset(在vlog中的偏移量) 为参数，将字符串 serialized_value 写入 vlog 中;
-6. 调用 set_slot 函数，将 slot_content 中的内容赋值给 slot_num;
-7. 将 slot_num 作为 value 写入数据库中;
 
-读取流程
-1. 读取 key 对应的 value， 也就是 slot_num
-2. 实例化 slot_content 结构体 sc
-3. 根据 slot_num 从 slot_page_ 中读取 slot_content
-4. 利用 sc 中的 vlog_num(vlog编号) 和 value_offset(在vlog中的偏移量) 从 vlog 中读取字符串
-5. 将字符串进行解码得到 value
-
-删除流程
-````
-// TODO(begin)
-  ReadOptions ro;
-  ro.verify_checksums = true;
-  ro.fill_cache = false;
-  ro.snapshot = nullptr;
-  std::string value;
-  Get(ro, key, &value);
-  size_t slot_num = *(size_t *)value.c_str();
-  struct slot_content sc;
-  std::string vlog_value;
-  slot_page_->get_slot(slot_num, &sc);
-  vlog_set_->del_value(sc.vlog_num, sc.value_offset);
-  // TODO(end)
-````
-1. 读取 key 对应
-### 锁机制
-
-### 3. 数据结构设计
-`key的格式：| key | slot_num | `
-
-`slot_page: | slot0:{vlog_no(定长), offset(定长)}, slot1:{vlog_no, offset}, ... | `
-
-`value 的格式：|value 长度 | slot_num | attr个数(定长) | attr1_name的长度(定长) | attr1_name(变长) | attr1_value的长度(定长) | attr1_value(变长) | ... |`
 
 对于每一次读取，用户线程先读取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即可。
 
-
-### 4. 接口设计
-#### 4.1 在 LevelDB 的 value 中实现字段功能
-1. std::string SerializeValue(const FieldArray& fields, std::string slot_num_str)
-
-**功能：** 将字段数组和 slot_num_str 序列化为字符串
-
-**输入：** 字段名和字段的值组成的字段数组 和 slot_num_str,即为该 KV 对分配的 slot_num 的字符串形式
-
-**输出：** 序列化后的字符串
-
-2. FieldArray DeserializeValue(const std::string& value_str)
-
-**功能：** 将字符串反序列化为字段数组
-
-**输入：** 字符串
-
-**输出：** 反序列化的字段数组
-
-3. std::vector< std::string >FindKeysByField(leveldb::DB* db, Field &field)
-
-**功能：** 根据字段名和字段的值找到对应的key
-
-**输入：** 数据库名，字段名和字段的值
-
-**输出：** 包含该字段和字段数组的 key,由于可能不只有一个，所以返回值为 vector
-
-4. Put_Fields(const WriteOptions& opt, const Slice& key,
-   const FieldArray& fields)
-
-**功能：** 仿照Status DB::Put(const WriteOptions& opt, const Slice& key, const Slice& value)，调用序列化函数，实现以字段形式插入 value
-
-5. Get_Fields(const ReadOptions& options, const Slice& key,
-   FieldArray* fields)
-
-**功能：** 仿照Status DB::Get(const WriteOptions& opt, const Slice& key, const Slice& value)，读取key对应的 value 之后，通过调用反序列化函数，将 value 反序列化为字段数组，并存到 fields 中
-
-#### 4.2 实现KV分离
-1. 搜索slot_page文件: Status find_slot(const Slice& key, Slot *slot);
-2. 搜索vlog文件: Status find_value(Slot *slot);
-3. 分配新的slot: Status allocate_slot(Bitmap *map, uint64_t *s);
-4. 释放slot: void deallocate_slot(Bitmap *map, uint64_t *s);
-5.
-6. VlogSet::get_value(const struct slot_content &sc, std::string *value)
-7.
 ### 5. 功能测试
 ### 5.1 在 LevelDB 的 value 中实现字段功能
 #### 5.1.1 功能测试