LevelDB源码分析-sstable的Block

sstable中的Block（table/block.h table/block.cc table/block_builder.h table/block_builder.cc）

sstable中的block由Block类封装并由BlockBuilder类构建。

block的结构为：

entry1 | entry2 | ... | restarts(uint32 * num_of_restarts) | num_of_restarts(uint32) | trailer

其中entry格式为：

shared_bytes(varint32) | unshared_bytes(varint32) | value_bytes(varint32) | unshared_key_data(unshared_bytes) | value_data(value_bytes)

shared_bytes为这个entry中的key与前一个entry的key共享的字节数，entry的key在存储时只存储不共享的部分，即采用前缀压缩的形式，并且前缀压缩是分组进行的，以避免所有查找都需要从头开始的情况。而每个组的起始entry的位置（offset）存储在restarts中，每个为uint32，数量为num_of_restarts。

trailer的格式为：

type(char) | crc(uint32)

type为block的压缩方式，crc为循环冗余校验码。

Block类

Block类对sstable的block中的数据进行封装，并提供了一个迭代器作为接口。Block类的声明为：

class Block { public: // ... private: // ... const char *data_; size_t size_; uint32_t restart_offset_; // Offset in data_ of restart array bool owned_; // Block owns data_[] // ... class Iter; }; 

其中成员变量data_为指向block中数据的指针，size_为block中数据的大小，restart_offset_为block中restarts部分数据的起始位置的offset，owned标记block是否包含data_。

而LevelDB实际上为Block类封装了一个Iter类，对Block的遍历操作需要通过Iter类提供的接口函数进行。

class Block::Iter : public Iterator { private: const Comparator *const comparator_; const char *const data_; // underlying block contents uint32_t const restarts_; // Offset of restart array (list of fixed32) uint32_t const num_restarts_; // Number of uint32_t entries in restart array // current_ is offset in data_ of current entry. >= restarts_ if !Valid uint32_t current_; uint32_t restart_index_; // Index of restart block in which current_ falls std::string key_; Slice value_; Status status_; // ... public: // ... virtual bool Valid() const { return current_ < restarts_; } virtual Status status() const { return status_; } virtual Slice key() const { // ... } virtual Slice value() const { // ... } virtual void Next() { // ... } virtual void Prev() { // ... } virtual void Seek(const Slice &target) { // 见下文分析 } virtual void SeekToFirst() { // ... } virtual void SeekToLast() { // ... } private: // ... }; 

其中，前几个成员变量的含义与Block类中的成员变量的含义类似，这里不再赘述。key_、value_这两个成员变量为迭代器当前指向的entry的KV值。

在这里主要分析Seek(const Slice &target)函数，其余函数的实现比较简单，在这里就不做分析了。Seek函数首先通过二分查找算法找到target所在的前缀编码分组的位置：

 // Binary search in restart array to find the last restart point // with a key < target uint32_t left = 0; uint32_t right = num_restarts_ - 1; while (left < right) { uint32_t mid = (left + right + 1) / 2; uint32_t region_offset = GetRestartPoint(mid); uint32_t shared, non_shared, value_length; const char *key_ptr = DecodeEntry(data_ + region_offset, data_ + restarts_, &shared, &non_shared, &value_length); if (key_ptr == nullptr || (shared != 0)) { CorruptionError(); return; } Slice mid_key(key_ptr, non_shared); if (Compare(mid_key, target) < 0) { // Key at "mid" is smaller than "target". Therefore all // blocks before "mid" are uninteresting. left = mid; } else { // Key at "mid" is >= "target". Therefore all blocks at or // after "mid" are uninteresting. right = mid - 1; } } 

然后在该分组中遍历：

 // Linear search (within restart block) for first key >= target SeekToRestartPoint(left); while (true) { if (!ParseNextKey()) { return; } if (Compare(key_, target) >= 0) { return; } } 

其中调用了DecodeEntry函数：

static inline const char *DecodeEntry(const char *p, const char *limit, uint32_t *shared, uint32_t *non_shared, uint32_t *value_length) { // ... } 

这个函数将以p为起始位置的entry解码，并且解码不会超过limit指向的位置，将key共享字节长度、key非共享字节长度、value长度存入shared，non_shared，value_length，返回指向entry中unshared_key_data起始位置的指针。

还调用了ParseNextKey函数：

 bool ParseNextKey() { // ... } 

这个函数获取下一个entry的key和value值并存入迭代器的成员变量中。

BlockBuilder类

BlockBuilder类用于构建sstable中的block。BlockBuilder类声明为：

class BlockBuilder { public: // ... // REQUIRES: Finish() has not been called since the last call to Reset(). // REQUIRES: key is larger than any previously added key void Add(const Slice &key, const Slice &value); // Finish building the block and return a slice that refers to the // block contents. The returned slice will remain valid for the // lifetime of this builder or until Reset() is called. Slice Finish(); // ... private: const Options *options_; std::string buffer_; // Destination buffer std::vector<uint32_t> restarts_; // Restart points int counter_; // Number of entries emitted since restart bool finished_; // Has Finish() been called? std::string last_key_; // ... }; 

其中options_为构建选项，buffer_为实际block中的数据，restarts_存储前缀编码各个分组的起始位置，counter_记录当前前缀编码分组中已经压缩了几个entry，finished_标记Finish是否被调用，last_key_为block中上一次添加的key值。

下面我们首先看Add函数：

void BlockBuilder::Add(const Slice &key, const Slice &value) 

Add函数首先检查当前前缀编码分组中压缩的entry个数是否已经达到上限，如果没有达到上限则计算共享的key的字节个数：

 Slice last_key_piece(last_key_); assert(!finished_); assert(counter_ <= options_->block_restart_interval); assert(buffer_.empty() // No values yet? || options_->comparator->Compare(key, last_key_piece) > 0); size_t shared = 0; if (counter_ < options_->block_restart_interval) { // See how much sharing to do with previous string const size_t min_length = std::min(last_key_piece.size(), key.size()); while ((shared < min_length) && (last_key_piece[shared] == key[shared])) { shared++; } } 

如果达到上限则重新开始一个restart：

 else { // Restart compression restarts_.push_back(buffer_.size()); counter_ = 0; } const size_t non_shared = key.size() - shared; 

然后依次将相应的数据编码后组成一个新的entry：

 // Add "<shared><non_shared><value_size>" to buffer_ PutVarint32(&buffer_, shared); PutVarint32(&buffer_, non_shared); PutVarint32(&buffer_, value.size()); // Add string delta to buffer_ followed by value buffer_.append(key.data() + shared, non_shared); buffer_.append(value.data(), value.size()); 

最后将数据加在buffer_的后面并更新last_key_和counter_的值：

 // Update state last_key_.resize(shared); last_key_.append(key.data() + shared, non_shared); assert(Slice(last_key_) == key); counter_++; 

然后是Finish函数：

Slice BlockBuilder::Finish() { // Append restart array for (size_t i = 0; i < restarts_.size(); i++) { PutFixed32(&buffer_, restarts_[i]); } PutFixed32(&buffer_, restarts_.size()); finished_ = true; return Slice(buffer_); } 

Finish函数首先将restarts_的偏移量存入buffer_，然后存入num_of_restarts，然后将buffer_封装为一个Slice返回。

228 Love u