码迷，mamicode.com
首页 > 数据库 > 详细

levelDB Log

时间：2014-08-11 20:51:12      阅读：501      评论：0      收藏：0      [点我收藏+]

标签：des   style   blog   http   使用   io   strong   文件   

分析完KV在内存中的存储，接下来就是操作日志。所有的写操作都必须先成功的append到操作日志中，然后再更新内存memtable。这样做有两个有点：1可以将随机的写IO变成append，极大的提高写磁盘速度；2防止在节点down机导致内存数据丢失，造成数据丢失，这对系统来说是个灾难。

在各种高效的存储系统中，这已经是口水技术了。

5.1 格式

在源码下的文档doc/log_format.txt中，作者详细描述了log格式：
The log file contents are a sequence of 32KB blocks.  The only exception is that the tail of thefile may contain a partial block.
Each block consists of a sequence of records:
    block:= record* trailer?
    record :=
    checksum: uint32    // crc32c of type and data[] ; little-endian
    length: uint16       // little-endian
    type: uint8          // One of FULL,FIRST, MIDDLE, LAST
    data: uint8[length]
A record never starts within the last six bytes of a block (since it won‘tfit).  Any leftover bytes here form thetrailer, which must consist entirely of zero bytes and must be skipped byreaders.
翻译过来就是：
Leveldb把日志文件切分成了大小为32KB的连续block块，block由连续的log record组成，log record的格式为：

bubuko.com,布布扣

，注意：CRC32, Length都是little-endian的。
Log Type有4种：FULL = 1、FIRST = 2、MIDDLE = 3、LAST = 4。FULL类型表明该log record包含了完整的user record；而user record可能内容很多，超过了block的可用大小，就需要分成几条log record，第一条类型为FIRST，中间的为MIDDLE，最后一条为LAST。也就是：
> FULL，说明该log record包含一个完整的user record；
> FIRST，说明是user record的第一条log record
> MIDDLE，说明是user record中间的log record
> LAST，说明是user record最后的一条log record
翻一下文档上的例子，考虑到如下序列的user records：
   A: length 1000
   B: length 97270
   C: length 8000
A作为FULL类型的record存储在第一个block中；B将被拆分成3条log record，分别存储在第1、2、3个block中，这时block3还剩6byte，将被填充为0；C将作为FULL类型的record存储在block 4中。如图5.1-1所示。

bubuko.com,布布扣

图5.1-1
由于一条logrecord长度最短为7，如果一个block的剩余空间<=6byte，那么将被填充为空字符串，另外长度为7的log record是不包括任何用户数据的。

写日志

写比读简单，而且写入决定了读，所以从写开始分析。

有意思的是在写文件时，Leveldb使用了内存映射文件，内存映射文件的读写效率比普通文件要高，关于内存映射文件为何更高效，这篇文章写的不错：

http://blog.csdn.net/mg0832058/article/details/5890688

bubuko.com,布布扣

图5.2-1

注意Write类的成员type_crc_数组，这里存放的为Record Type预先计算的CRC32值，因为Record Type是固定的几种，为了效率。

Writer类只有一个接口，就是AddRecord()，传入Slice参数，下面来看函数实现。

首先取出slice的字符串指针和长度，初始化begin=true，表明是第一条log record。

const char* ptr = slice.data();

size_t left = slice.size();

bool begin = true;

然后进入一个do{}while循环，直到写入出错，或者成功写入全部数据，如下：

S1 首先查看当前block是否<7，如果<7则补位，并重置block偏移。

dest_->Append(Slice("\x00\x00\x00\x00\x00\x00",leftover));

block_offset_ = 0;

S2 计算block剩余大小，以及本次log record可写入数据长度

    const size_t avail =kBlockSize - block_offset_ - kHeaderSize;

    const size_t fragment_length = (left <avail) ? left : avail;

S3 根据两个值，判断log type

    RecordType type;

    const bool end = (left ==fragment_length); // 两者相等，表明写完

    if (begin && end)  type = kFullType;

    else if (begin)     type = kFirstType;

    else if (end)       type = kLastType;

    else             type = kMiddleType;

 S4 调用EmitPhysicalRecord函数，append日志；并更新指针、剩余长度和begin标记。

    s = EmitPhysicalRecord(type, ptr,fragment_length);

    ptr += fragment_length;

    left -= fragment_length;

begin = false;

接下来看看EmitPhysicalRecord函数，这是实际写入的地方，涉及到log的存储格式。函数声明为：StatusWriter::EmitPhysicalRecord(RecordType t, const char* ptr, size_t n)

参数ptr为用户record数据，参数n为record长度，不包含log header。

S1 计算header，并Append到log文件，共7byte格式为：

| CRC32 (4 byte) | payload length lower + high (2 byte) | type (1byte)|

char buf[kHeaderSize];

  buf[4] = static_cast<char>(n& 0xff);

  buf[5] =static_cast<char>(n >> 8);

  buf[6] =static_cast<char>(t);

  // 计算record type和payload的CRC校验值

  uint32_t crc = crc32c::Extend(type_crc_[t], ptr, n);

  crc = crc32c::Mask(crc);        // 空间调整

  EncodeFixed32(buf, crc);

  dest_->Append(Slice(buf,kHeaderSize));

S2 写入payload，并Flush，更新block的当前偏移

    s =dest_->Append(Slice(ptr, n));

    s = dest_->Flush();

    block_offset_ += kHeaderSize +n;

以上就是写日志的逻辑，很直观。

 

 

[cpp] view plaincopy
 
  1. <span style="font-size:18px;">// 记录类型  
  2. enum RecordType {  
  3.             // Zero is reserved for preallocated files  
  4.             kZeroType = 0,  
  5.   
  6.             kFullType = 1,  
  7.   
  8.             // For fragments  
  9.             kFirstType = 2,  
  10.             kMiddleType = 3,  
  11.             kLastType = 4  
  12. };  
  13.   
  14. static const int kBlockSize = 32768;        // 32k Block  
  15.   
  16. // recored header is checksum (4 bytes), length (2 bytes), type (1 byte).  
  17. static const int kHeaderSize = 4 + 2 + 1;</span>  

 

写日志类Writer：

[cpp] view plaincopy
 
    1. <span style="font-size:18px;">  namespace log {  
    2.         class Writer {  
    3.             public:  
    4.             // Create a writer that will append data to "*dest".  
    5.             // "*dest" must be initially empty.  
    6.             // "*dest" must remain live while this Writer is in use.  
    7.             explicit Writer(WritableFile* dest);  
    8.             ~Writer(){}  
    9.   
    10.             Status AddRecord(const Slice& slice);                       // 添加一个记录  
    11.   
    12.             private:  
    13.             WritableFile* dest_;                                        // class WritableFile;为写文件类  
    14.             int block_offset_;       // Current offset in block  
    15.   
    16.             // crc32c values for all supported record types.  These are  
    17.             // pre-computed to reduce the overhead of computing the crc of the  
    18.             // record type stored in the header.  
    19.             uint32_t type_crc_[kMaxRecordType + 1];                     // 每种type都预先计算出CRC，kMaxRecordType = kLastType;  
    20.   
    21.             Status EmitPhysicalRecord(RecordType type, const char* ptr, size_t length);// 写入一个Record  
    22.   
    23.             // No copying allowed  
    24.             Writer(const Writer&);                                  // 禁止拷贝构造函数及赋值运算符重载  
    25.             void operator=(const Writer&);  
    26.             };  
    27.     }  
    28.   
    29.         Writer::Writer(WritableFile* dest)                              // 构造函数，参数：写文件句柄  
    30.          : dest_(dest),  
    31.          block_offset_(0) {  
    32.             for (int i = 0; i <= kMaxRecordType; i++) {  
    33.                 char t = static_cast<char>(i);  
    34.                 type_crc_[i] = crc32c::Value(&t, 1);                        // 首先计算每个Type对应的CRC  
    35.             }  
    36.         }  
    37.           
    38.         Status Writer::AddRecord(const Slice& slice) {                  // 添加一个记录  
    39.             const char* ptr = slice.data();  
    40.             size_t left = slice.size();  
    41.   
    42.             // Fragment the record if necessary and emit it.  Note that if slice  
    43.             // is empty, we still want to iterate once to emit a single     // 如果Slice为空，则增加一个zero-length的记录  
    44.             // zero-length record  
    45.             Status s;  
    46.             bool begin = true;  
    47.             do {  
    48.                 const int leftover = kBlockSize - block_offset_;            // 当前Block剩余容量  
    49.                 assert(leftover >= 0);  
    50.                 if (leftover < kHeaderSize) {                            // 剩余容量比kHeaderSize还小，则填充trailer  
    51.                     // Switch to a new block  
    52.                     if (leftover > 0) {  
    53.                         // Fill the trailer (literal below relies on kHeaderSize being 7)  
    54.                         assert(kHeaderSize == 7);  
    55.                         dest_->Append(Slice("\x00\x00\x00\x00\x00\x00", leftover));  // leftover<7, dest_追加leftover个0  
    56.                     }  
    57.                     block_offset_ = 0;  
    58.                 }  
    59.   
    60.                 // Invariant: we never leave < kHeaderSize bytes in a block.  
    61.                 assert(kBlockSize - block_offset_ - kHeaderSize >= 0);  
    62.   
    63.                 const size_t avail = kBlockSize - block_offset_ - kHeaderSize; // 当前block剩余可用大小(除去kHeaderSize)  
    64.                 const size_t fragment_length = (left < avail) ? left : avail;  // 分片  
    65.   
    66.                 RecordType type;  
    67.                 const bool end = (left == fragment_length);                    // 是否为最后一个  
    68.                 if (begin && end) {                                   // 开始 && 结束，则type为FullType  
    69.                     type = kFullType;  
    70.                 } else if (begin) {                                   // 开始 && 非结束，则type为kFirstType  
    71.                     type = kFirstType;  
    72.                 } else if (end) {                                         // 非开始 && 结束，则type为kLastType  
    73.                     type = kLastType;  
    74.                 } else {                                              // 其它为kMiddleType  
    75.                     type = kMiddleType;  
    76.                 }  
    77.   
    78.                 s = EmitPhysicalRecord(type, ptr, fragment_length);           // 保存一条fragment_length字节长度的数据到log文件，类型为type，开始地址为ptr  
    79.                 if(!s.ok()){                                          // 写入失败，则跳出循环  
    80.                     break ;  
    81.                 }  
    82.                 ptr += fragment_length;  
    83.                 left -= fragment_length;  
    84.                 begin = false;  
    85.             } while (/*s.ok() &&*/ left > 0);  
    86.             return s;  
    87.         }  
    88.           
    89.         // 保存一条n字节长度的记录，记录类型为t，记录数据开始地址为ptr  
    90.         Status Writer::EmitPhysicalRecord(RecordType t, const char* ptr, size_t n)   
    91.         {  
    92.             assert(n <= 0xffff);  // Must fit in two bytes  
    93.             assert(block_offset_ + kHeaderSize + n <= kBlockSize);  
    94.   
    95.             // Format the header  
    96.             char buf[kHeaderSize];                              // 7bytes: CheckSum(4) + 记录长度(2) + Type(1)  
    97.             buf[4] = static_cast<char>(n & 0xff);  
    98.             buf[5] = static_cast<char>(n >> 8 & 0xff);              // 长度高位在后  
    99.             buf[6] = static_cast<char>(t);  
    100.   
    101.             // Compute the crc of the record type and the payload.  
    102.             uint32_t crc = crc32c::Extend(type_crc_[t], ptr, n);    // 计算CRC  
    103.             crc = crc32c::Mask(crc);                            // Adjust for storage  
    104.             EncodeFixed32(buf, crc);                                // 将CRC放入header前4字节  
    105.   
    106.             // Write the header and the payload  
    107.             Status s = dest_->Append(Slice(buf, kHeaderSize));       // header写入文件  
    108.             if (s.ok()) {                                           // header写入成功  
    109.                 s = dest_->Append(Slice(ptr, n));                    // 将记录数据写入文件  
    110.                 if (s.ok()) {  
    111.                     s = dest_->Flush();                              // flush到文件  
    112.                 }  
    113.             }  
    114.             block_offset_ += kHeaderSize + n;                       // Block offset移动  
    115.             return s;  
    116.         }  
    117.         </span>  

levelDB Log,布布扣,bubuko.com

levelDB Log

标签：des   style   blog   http   使用   io   strong   文件   

原文地址：http://www.cnblogs.com/shenzhaohai1989/p/3905354.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！