Go 存储系列:Hash存储引擎 Bitcask

Hash 存储引擎

在现代软件系统中,存储和检索数据是一个非常重要的任务。随着数据量的不断增长,如何高效地存储和检索数据变得越来越重要。Hash 存储引擎是一种常见的存储引擎,它可以快速地存储和检索数据。

在本文中,我们将介绍 Hash 存储引擎的工作原理,并分析一个 Go 语言实现一个简单的 Hash 存储引擎:tiny-bitcask。tiny-bitcask 是参考论文:https://riak.com/assets/bitcask-intro.pdf 开发出的一个 简单版本的demo。

通过分析 tiny-bitcask,有助于我们理解一个存储一系统是如何构造的,包括内存结构,磁盘文件结构,如何从内存结构找到对应的磁盘文件内容。

Bitcask 介绍

Bitcask 是一种底层格式为日志模样的 kv 存储,就是只追加,保证文件是一直顺序写入的,写入性能非常好

Bitcask模型的整体结构

Go 存储系列:Hash存储引擎 Bitcask_第1张图片

  • Bitcask 只有一个可写的文件。 可写的文件叫做 active data file,只读的叫做 older data file。
  • 写数据只写 active data file,而且是顺序写入,读数据从 active data file 和 older data
    file 中读 hint file:
  • 在合并 data file 产生的文件,用于快速重新建立内存索引,可以理解成是在磁盘中的索引文件

Bitcask 它的文件格式

Go 存储系列:Hash存储引擎 Bitcask_第2张图片
crc:校验码,tstamp:时间戳,ksz:key 大小,value_sz 值大小

Bitcask 它内存的索引结构

Go 存储系列:Hash存储引擎 Bitcask_第3张图片
file_id: 所在的物理文件,value_sz: 值大小,value_pos: value 在文件中的位置,tstamp:时间戳

数据操作

  • 写入数据:Bitcask 先写文件,持久化落盘之后更新内存 hash 表。
  • 读取数据:从内存索引查询key,从这里知道了value所在的file_id,位置,大小,然后只要调用系统的读取接口就行了

Go 存储系列:Hash存储引擎 Bitcask_第4张图片

  • 删除数据 :不直接删除记录,而是新增一条相同key的记录,把value设置一个删除的标记 原有记录依然存在于数据文件中,只是更新索引哈希表
  • 修改数据 :Bitcask不支持随机写入,修改数据时不会找到目标记录进行修改 还是新增一条相同key的记录,把value设置为新值
  • 旧数据处理:Bitcask会定期进行Marge操作,扫描所有旧数据文件中的数据,生成新的数据文件 扫描时,把已经被置为删除状态的记录直接过滤掉,修改过的数据,只保留时间最近的一条
  • Marge 操作:会遍历所有不可变的旧数据文件,将所有有效的数据重新写到新的数据文件中,并且将旧的数据文件删除掉。
    Go 存储系列:Hash存储引擎 Bitcask_第5张图片

tiny-bitcask 实现

在上面介绍了 bitcask 的基本概念后,我们知道了 bitcask 大概有哪些部分

  • Entry:代表DB中一条数据的信息。
  • DataFiles:磁盘中的文件
  • Storage:与文件系统打交道的对象,包括了写入,读取数据。将数据写入到 DataFiles 中
  • Index,索引,记录一条数据的具体信息,主要是数据在磁盘中的位置。
  • DB,DB的实体。包含了DB的各种操作,包括读取,写入数据。

数据结构

DB 结构

type DB struct {
    rw      sync.RWMutex // 读写锁
    kd      *index.KeyDir // 内存index
    storage *storage.DataFiles // 文件
    opt     *Options // 参数
}

Entry 结构

Entry 的结构 就是对应着 Bitcask 的文件格式,其中 Flag 是用来标识是否是删除的记录

type Entry struct {
    Key   []byte
    Value []byte
    Meta  *Meta
}
 
type Meta struct {
    Crc       uint32
    position  uint64
    TimeStamp uint64
    KeySize   uint32
    ValueSize uint32
    Flag      uint8
}

一条数据是以怎么样的形式存进磁盘的。磁盘是不知道你存进来的数据是什么的,他只知道是一些二进制,至于那些二进制是什么,由放进来的应用程序来定义。所以,我们要对数据写入到磁盘的时候继续编码,也就是编码成二进制,其中我们的 Meta 这个结构体就是记录了我们的数据的一些圆信息,我们要利用这些信息进行编码。

func (e *Entry) Encode() []byte {
    size := e.Size() // int64(MetaSize + e.Meta.KeySize + e.Meta.ValueSize)
    buf := make([]byte, size)
    binary.LittleEndian.PutUint64(buf[4:12], e.Meta.position) // 这里并没有实际作用
    binary.LittleEndian.PutUint64(buf[12:20], e.Meta.TimeStamp) // 时间戳
    binary.LittleEndian.PutUint32(buf[20:24], e.Meta.KeySize) // key 大小
    binary.LittleEndian.PutUint32(buf[24:28], e.Meta.ValueSize) // value 大小
    buf[28] = e.Meta.Flag
    if e.Meta.Flag != DeleteFlag {
        copy(buf[MetaSize:MetaSize+len(e.Key)], e.Key)
        copy(buf[MetaSize+len(e.Key):MetaSize+len(e.Key)+len(e.Value)], e.Value)
    }
    c32 := crc32.ChecksumIEEE(buf[4:])
    binary.LittleEndian.PutUint32(buf[0:4], c32) // 写入CRC
    return buf
}

DataFiles 磁盘文件

type DataFiles struct {
    dir         string // 数据目录
    oIds        []int // old data files 的文件列表
    segmentSize int64
    active      *ActiveFile // active data file 文件
    olds        map[int]*OldFile //  old data files 的文件列表 
}

写入过程

Set: db 暴露出来的接口,写入一个key value 值

func (db *DB) Set(key []byte, value []byte) error {
    db.rw.Lock()
    defer db.rw.Unlock()
    entry := entity.NewEntryWithData(key, value) // Entry
    h, err := db.storage.WriterEntity(entry) // 写入到文件
    if err != nil {
        return err
    }
    db.kd.AddIndexByData(h, entry) // 更新内存 index
    return nil
}

WriterEntity: 写入 Entity 到文件

func (af *ActiveFile) WriterEntity(e entity.Entity) (h *entity.Hint, err error) {
    buf := e.Encode() // 编码
    n, err := af.fd.WriteAt(buf, af.off) // 写入到 文件 offset
    if n < len(buf) {
        return nil, WriteMissDataErr
    }
    if err != nil {
        return nil, err
    }
    h = &entity.Hint{Fid: af.fid, Off: af.off} 
    af.off += e.Size() // 更新文件下一个offset
    return h, nil
}

AddIndexByData: 更新内存 index

// DataPosition means a certain position of an entity.Entry which stores in disk.
type DataPosition struct {
    Fid       int // 文件 fd
    Off       int64 // 所在文件的偏移量
    Timestamp uint64
    KeySize   int
    ValueSize int
}
 
 
func (kd *KeyDir) AddIndexByRawInfo(fid int, off int64, key, value []byte) {
    index := newDataPosition(fid, off, key, value)
    kd.Add(string(key), index) // 记录到内存
}
 
 
func newDataPosition(fid int, off int64, key, value []byte) *DataPosition {
    dp := &DataPosition{}
    dp.Fid = fid
    dp.Off = off 
    dp.KeySize = len(key)
    dp.ValueSize = len(value)
    return dp
}

读取流程

Get:db 暴露出来的接口,读取一个key的值

// Get gets value by using key
func (db *DB) Get(key []byte) (value []byte, err error) {
    db.rw.RLock()
    defer db.rw.RUnlock()
    i := db.kd.Find(string(key))
    if i == nil {
        return nil, KeyNotFoundErr
    }
    entry, err := db.storage.ReadEntry(i)
    if err != nil {
        return nil, err
    }
    return entry.Value, nil
}

ReadEntry:从文件中读取一个 Entry

func (dfs *DataFiles) ReadEntry(index *index.DataPosition) (e *entity.Entry, err error) {
    dataSize := entity.MetaSize + index.KeySize + index.ValueSize
    if index.Fid == dfs.active.fid {
        return dfs.active.ReadEntity(index.Off, dataSize) // 从acive 文件中读取
    }
    of, exist := dfs.olds[index.Fid]// 从 old data file 中读取
    if !exist {
        return nil, MissOldFileErr
    }
    return of.ReadEntity(index.Off, dataSize)
}
func readEntry(fd *os.File, off int64, length int) (e *entity.Entry, err error) {
    buf := make([]byte, length)
    n, err := fd.ReadAt(buf, off) // 根据 key 在内存中读取问津啊对应的 offset 记录
    if n < length {
        return nil, ReadMissDataErr
    }
    if err != nil {
        return nil, err
    }
    e = entity.NewEntry()
    e.DecodeMeta(buf[:entity.MetaSize])
    e.DecodePayload(buf[entity.MetaSize:]) // 解码,从磁盘数据还原成写入时的数据
    return e, nil
}

Marge 操作

Marge 操作的流程就是

  • 获取到old data file
  • 看下当前内存 index中有没有数据,这条数据可能被删除了,如果在内存index 没有找到,就是被删除了,不需要处理
  • 比较一些当前读到的这个数据是不是最新的数据,如果是,则需要写入到 active data file 中
  • 遍历完成一个之后,就删除老的文件,继续遍历下一个
// Merge clean the useless data
func (db *DB) Merge() error {
    db.rw.Lock()
    defer db.rw.Unlock()
    fids := db.storage.GetOldFiles()
    if len(fids) < 2 {
        return NoNeedToMergeErr
    }
    sort.Ints(fids)
    for _, fid := range fids[:len(fids)-1] {
        var off int64 = 0
        reader := db.storage.GetOldFile(fid) // 获取到old data file
        for {
            entry, err := reader.ReadEntityWithOutLength(off) // 读取一条数据
            if err == nil {
                key := string(entry.Key)
                off += entry.Size()
                oldIndex := db.kd.Find(key) // 看下当前内存 index中有没有数据,这条数据可能被删除了
                if oldIndex == nil {
                    continue
                }
                // oldIndex 是这个 key 最新的文件
                if oldIndex.IsEqualPos(fid, off) { // 比较一些当前读到的这个数据是不是最新的数据,如果是,则需要写入到 active data file 中
                    h, err := db.storage.WriterEntity(entry)
                    if err != nil {
                        return err
                    }
                    db.kd.AddIndexByData(h, entry) // 更新内存index
                }
            } else {
                if err == io.EOF {
                    break
                }
                return err
            }
        }
        err := db.storage.RemoveFile(fid) // 删除老的文件
        if err != nil {
            return err
        }
    }
    return nil
}
 

总结

  • 大部分接触的KV存储引擎是可能都是Redis。Redis的所有数据都是装在内存的,也可以根据配置持久化在磁盘里面,但是读都是从内存里面读的,这意味着redis的读写速度都非常快。
  • 但是这有一个限制,那就是单机Redis存储的数据不能大于内存本身。而Bitcask的最大限制是内存必须装得下所有的key,因为Bitcask的value是存在磁盘上的。所以相比Redis,Bitcask的存在意义不是和redis比速度,而是当你的数据用Redis存不下的时候,可以考虑稍微损失读取效率,试试Bitcask。

参考

  • Go存储引擎资料汇总
  • https://riak.com/assets/bitcask-intro.pdf

你可能感兴趣的:(Golang,数据库,哈希算法,golang,算法)