BlogJava-小明思考-随笔分类-分布式计算

leveldb性能分析 - 随机写

小明 — Thu, 22 Mar 2012 09:32:00 GMT

摘要: 准备工作：1. 下载Snappy库Download source code from: http://code.google.com/p/snappy编译并安装./configure & make & sudo make install2. 编译leveldb自带的db_benchmake db_bench注意:在ubuntu 11.04上编译会出错，修改makefile:$(CX... 阅读全文

小明 2012-03-22 17:32 发表评论

leveldb研究11- 流程分析：读数据

小明 — Wed, 21 Mar 2012 09:30:00 GMT

leveldb读数据

先看看ReadOptions有哪些参数可以指定：

// Options that control read operations
struct ReadOptions {
  // 是否检查checksum
  // Default: false
  bool verify_checksums;

  // 是否将此次结果放入cache
  // Default: true
  bool fill_cache;

  //是否指定snapshot,否则读取当前版本
  // Default: NULL
  const Snapshot* snapshot;

  ReadOptions()
      : verify_checksums(false),
        fill_cache(true),
        snapshot(NULL) {
  }
};

下面看看读取的详细过程：
查询memtable=>查询previous memtable(imm_)=>查询文件(缓冲）

Status DBImpl::Get(const ReadOptions& options,
                   const Slice& key,
                   std::string* value) {
  Status s;
  MutexLock l(&mutex_);
  SequenceNumber snapshot;
  //设置snapshot
  if (options.snapshot != NULL) {
    snapshot = reinterpret_cast<const SnapshotImpl*>(options.snapshot)->number_;
  } else {
    snapshot = versions_->LastSequence();
  }

  MemTable* mem = mem_;
  MemTable* imm = imm_;
  Version* current = versions_->current();
  mem->Ref();
  if (imm != NULL) imm->Ref();
  current->Ref();

  bool have_stat_update = false;
  Version::GetStats stats;

  // Unlock while reading from files and memtables
  {
    mutex_.Unlock();
    LookupKey lkey(key, snapshot);
    //先查询memtable
    if (mem->Get(lkey, value, &s)) {
      // Done
    } else if (imm != NULL && imm->Get(lkey, value, &s)) { //然后查询previous memtable:imm_
      // Done
    } else {
      //从文件中读取
      s = current->Get(options, lkey, value, &stats);
      have_stat_update = true;
    }
    mutex_.Lock();
  }

  //是否有文件需要被compaction,参见allowed_seek
  if (have_stat_update && current->UpdateStats(stats)) {
    MaybeScheduleCompaction();
  }
  mem->Unref();
  if (imm != NULL) imm->Unref();
  current->Unref();
  return s;
}

重点来看看从version中读取：

Status Version::Get(const ReadOptions& options,
                    const LookupKey& k,
                    std::string* value,
                    GetStats* stats) {
  Slice ikey = k.internal_key();
  Slice user_key = k.user_key();
  const Comparator* ucmp = vset_->icmp_.user_comparator();
  Status s;

  stats->seek_file = NULL;
  stats->seek_file_level = -1;
  FileMetaData* last_file_read = NULL;
  int last_file_read_level = -1;

  //从level0向高层查找，如果再低级level中查到，则不再查询
  std::vector<FileMetaData*> tmp;
  FileMetaData* tmp2;
  for (int level = 0; level < config::kNumLevels; level++) {
    size_t num_files = files_[level].size();
    //本层文件数为空，则返回
    if (num_files == 0) continue;

    // Get the list of files to search in this level
    FileMetaData* const* files = &files_[level][0];
    if (level == 0) {
      //level0特殊处理，因为key是重叠，所有符合条件的文件必须被查找
      tmp.reserve(num_files);
      for (uint32_t i = 0; i < num_files; i++) {
        FileMetaData* f = files[i];
        if (ucmp->Compare(user_key, f->smallest.user_key()) >= 0 &&
            ucmp->Compare(user_key, f->largest.user_key()) <= 0) {
          tmp.push_back(f);
        }
      }
      if (tmp.empty()) continue;

      std::sort(tmp.begin(), tmp.end(), NewestFirst);
      files = &tmp[0];
      num_files = tmp.size();
    } else {
      // 二分法查找，某个key只可能属于一个文件
      uint32_t index = FindFile(vset_->icmp_, files_[level], ikey);
      //没有查到
      if (index >= num_files) {
        files = NULL;
        num_files = 0;
      } else {
        tmp2 = files[index];
        if (ucmp->Compare(user_key, tmp2->smallest.user_key()) < 0) {
          // All of "tmp2" is past any data for user_key
          files = NULL;
          num_files = 0;
        } else {
          files = &tmp2;
          num_files = 1;
        }
      }
    }

    for (uint32_t i = 0; i < num_files; ++i) { //遍历本层符合条件的文件
      if (last_file_read != NULL && stats->seek_file == NULL) {
        //seek_file只记录第一个
        stats->seek_file = last_file_read;
        stats->seek_file_level = last_file_read_level;
      }

      FileMetaData* f = files[i];
      last_file_read = f;
      last_file_read_level = level;

      //从table cache中读取
      Iterator* iter = vset_->table_cache_->NewIterator(
          options,
          f->number,
          f->file_size);
      iter->Seek(ikey);
      const bool done = GetValue(ucmp, iter, user_key, value, &s);
      if (!iter->status().ok()) { //查找到
        s = iter->status();
        delete iter;
        return s;
      } else {
        delete iter;
        if (done) {
          return s;
        }
      }
    }
  }

  return Status::NotFound(Slice());  // Use an empty error message for speed
}

继续跟踪：TableCache

Iterator* TableCache::NewIterator(const ReadOptions& options,
                                  uint64_t file_number,
                                  uint64_t file_size,
                                  Table** tableptr) {
  if (tableptr != NULL) {
    *tableptr = NULL;
  }

  char buf[sizeof(file_number)];
  EncodeFixed64(buf, file_number);
  Slice key(buf, sizeof(buf));

  //从LRU cache中查找
  Cache::Handle* handle = cache_->Lookup(key);
  if (handle == NULL) {
    /加载文件
    std::string fname = TableFileName(dbname_, file_number);
    RandomAccessFile* file = NULL;
    Table* table = NULL;
    Status s = env_->NewRandomAccessFile(fname, &file);
    if (s.ok()) {
      s = Table::Open(*options_, file, file_size, &table);
    }

    if (!s.ok()) {
      assert(table == NULL);
      delete file;
      // We do not cache error results so that if the error is transient,
      // or somebody repairs the file, we recover automatically.
      return NewErrorIterator(s);
    }

    //插入Cache
    TableAndFile* tf = new TableAndFile;
    tf->file = file;
    tf->table = table;
    handle = cache_->Insert(key, tf, 1, &DeleteEntry);
  }

  Table* table = reinterpret_cast<TableAndFile*>(cache_->Value(handle))->table;
  //从Table对象中生成iterator
  Iterator* result = table->NewIterator(options);
  result->RegisterCleanup(&UnrefEntry, cache_, handle);
  if (tableptr != NULL) {
    *tableptr = table;
  }
  return result;
}

小明 2012-03-21 17:30 发表评论

leveldb研究10- 流程分析：写数据

小明 — Wed, 21 Mar 2012 06:41:00 GMT

总体来说,leveldb的写操作有两个步骤，首先是针对log的append操作，然后是对memtable的插入操作。

影响写性能的因素有：
1. write_buffer_size
2. kL0_SlowdownWritesTrigger and kL0_StopWritesTrigger.提高这两个值，能够增加写的性能，但是降低读的性能

看看WriteOptions有哪些参数可以指定

struct WriteOptions {
  //设置sync=true,leveldb会调用fsync()，这会降低插入性能
  //同时会增加数据的安全性
  //Default: false
  bool sync;

  WriteOptions()
      : sync(false) {
  }
};

首先把Key,value转成WriteBatch

Status DB::Put(const WriteOptions& opt, const Slice& key, const Slice& value) {
  WriteBatch batch;
  batch.Put(key, value);
  return Write(opt, &batch);
}

接下来就是真正的插入了
这里使用了两把锁，主要是想提高并发能力，减少上锁的时间。
首先是检查是否可写，然后append log，最后是插入memtable

Status DBImpl::Write(const WriteOptions& options, WriteBatch* updates) {
  Status status;
  //加锁
  MutexLock l(&mutex_);
  LoggerId self;
  //拿到写log的权利
  AcquireLoggingResponsibility(&self);
  //检查是否可写
  status = MakeRoomForWrite(false);  // May temporarily release lock and wait
  uint64_t last_sequence = versions_->LastSequence();
  if (status.ok()) {
    WriteBatchInternal::SetSequence(updates, last_sequence + 1);
    last_sequence += WriteBatchInternal::Count(updates);

    // Add to log and apply to memtable.  We can release the lock during
    // this phase since the "logger_" flag protects against concurrent
    // loggers and concurrent writes into mem_.
    {
      assert(logger_ == &self);
      mutex_.Unlock();
      //IO操作：写入LOG
      status = log_->AddRecord(WriteBatchInternal::Contents(updates));
      if (status.ok() && options.sync) {
        status = logfile_->Sync();
      }
      //插入memtable
      if (status.ok()) {
        status = WriteBatchInternal::InsertInto(updates, mem_);
      }
      mutex_.Lock();
      assert(logger_ == &self);
    }
    //设置新的seqence number
    versions_->SetLastSequence(last_sequence);
  }
  //释放写LOG锁
  ReleaseLoggingResponsibility(&self);
  return status;
}

写流量控制：

Status DBImpl::MakeRoomForWrite(bool force) {
  mutex_.AssertHeld();
  assert(logger_ != NULL);
  bool allow_delay = !force;
  Status s;
  while (true) {
    if (!bg_error_.ok()) {
      // Yield previous error
      s = bg_error_;
      break;
    } else if (
        allow_delay &&
        versions_->NumLevelFiles(0) >= config::kL0_SlowdownWritesTrigger) {
      mutex_.Unlock();
      //如果level0的文件大于kL0_SlowdownWritesTrigger阈值，则sleep 1s，这样给compaction更多的CPU
      env_->SleepForMicroseconds(1000);
      allow_delay = false;  // Do not delay a single write more than once
      mutex_.Lock();
    } else if (!force &&
               (mem_->ApproximateMemoryUsage() <= options_.write_buffer_size)) {
      //可写
      break;
    } else if (imm_ != NULL) {
      // imm_:之前的memtable 没有被compaction，需要等待
      bg_cv_.Wait();
    } else if (versions_->NumLevelFiles(0) >= config::kL0_StopWritesTrigger) {
      // level0文件个数大于kL0_StopWritesTrigger,需要等待
      Log(options_.info_log, "waiting\n");
      bg_cv_.Wait();
    } else {
      //生成新的额memtable和logfile，把当前memtable传给imm_
      assert(versions_->PrevLogNumber() == 0);
      uint64_t new_log_number = versions_->NewFileNumber();
      WritableFile* lfile = NULL;
      s = env_->NewWritableFile(LogFileName(dbname_, new_log_number), &lfile);
      if (!s.ok()) {
        break;
      }
      delete log_;
      delete logfile_;
      logfile_ = lfile;
      logfile_number_ = new_log_number;
      log_ = new log::Writer(lfile);
      imm_ = mem_;
      has_imm_.Release_Store(imm_);
      mem_ = new MemTable(internal_comparator_);
      mem_->Ref();
      force = false;   // Do not force another compaction if have room

// 发起compaction,dump imm_

      MaybeScheduleCompaction();
    }
  }
  return s;
}

小明 2012-03-21 14:41 发表评论

leveldb研究9- 流程分析：打开数据库

小明 — Tue, 20 Mar 2012 08:02:00 GMT

摘要: leveldb 是通过Open函数来打开/新建数据库。Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->static Status Open(const Options& options, &nb... 阅读全文

小明 2012-03-20 16:02 发表评论

leveldb研究8- 内存中的数据结构Memtable/SkipList

小明 — Mon, 19 Mar 2012 08:31:00 GMT

我们知道,leveldb在写数据的时候，除了log文件，都要在内存中写一份。

先看看SkipList【跳表】这个数据结构：

SkipList有如下特点：
1. 本质上一个排序好的链表
2. 分层，上层节点比下层的少，更具有跳跃性
3. 查询的复杂度是O(logn)

SkipList跟红黑树等还是比较容易实现和理解的，主要长处是比较容易实现Lock free和遍历。
我们来看看leveldb的实现
插入：

//插入一个新的key
template<typename Key, class Comparator>
void SkipList<Key,Comparator>::Insert(const Key& key) {
  //查找插入节点,prev为各层的前置节点
  Node* prev[kMaxHeight];
  Node* x = FindGreaterOrEqual(key, prev);

  // Our data structure does not allow duplicate insertion
  assert(x == NULL || !Equal(key, x->key));

  //生成随机高度
  int height = RandomHeight();
  if (height > GetMaxHeight()) {
    for (int i = GetMaxHeight(); i < height; i++) {
      prev[i] = head_;
    }
    //设置当前最大高度
    max_height_.NoBarrier_Store(reinterpret_cast<void*>(height));
  }

  //生成新节点
  x = NewNode(key, height);
  for (int i = 0; i < height; i++) {
    //设置新节点的各层的下一跳
    x->NoBarrier_SetNext(i, prev[i]->NoBarrier_Next(i));
    //设置前节点的next为当前节点，完成插入
    prev[i]->SetNext(i, x);
  }
}

查询：

template<typename Key, class Comparator>
typename SkipList<Key,Comparator>::Node* SkipList<Key,Comparator>::FindGreaterOrEqual(const Key& key, Node** prev)
    const {
  Node* x = head_;
  int level = GetMaxHeight() - 1; //从高层开始查找，依次到0 level
  while (true) {
    Node* next = x->Next(level);
    if (KeyIsAfterNode(key, next)) { //比next key 要大
      // Keep searching in this list
      x = next;
    } else { //比next key小，查找下一层
      //标记当前level的前置节点
      if (prev != NULL) prev[level] = x;
      if (level == 0) {
        return next;
      } else {
        level--;
      }
    }
  }
}

template<typename Key, class Comparator>
bool SkipList<Key,Comparator>::Contains(const Key& key) const {
  Node* x = FindGreaterOrEqual(key, NULL);
  if (x != NULL && Equal(key, x->key)) {
    return true;
  } else {
    return false;
  }
}

接着我们看看leveldb MemTable的实现，很简单了，基本是对SkipList访问一个封装

class MemTable {
public:
  explicit MemTable(const InternalKeyComparator& comparator);

  //增加引用计数
  void Ref() { ++refs_; }

  //减少引用计数
  void Unref() {
    --refs_;
    assert(refs_ >= 0);
    if (refs_ <= 0) {
      delete this;
    }
  }

  //内存使用量
  size_t ApproximateMemoryUsage();

  //遍历操作
  Iterator* NewIterator();

  //插入
  void Add(SequenceNumber seq, ValueType type,
           const Slice& key,
           const Slice& value);

  //查询
  bool Get(const LookupKey& key, std::string* value, Status* s);

private:
  ~MemTable();  // Private since only Unref() should be used to delete it

  //key compartor，用于排序
  struct KeyComparator {
    const InternalKeyComparator comparator;
    explicit KeyComparator(const InternalKeyComparator& c) : comparator(c) { }
    int operator()(const char* a, const char* b) const;
  };
  friend class MemTableIterator;
  friend class MemTableBackwardIterator;

  typedef SkipList<const char*, KeyComparator> Table;

  KeyComparator comparator_;
  int refs_; //引用计数
  Arena arena_; //内存分配器
  Table table_; //数据存放SkipList

  // No copying allowed
  MemTable(const MemTable&);
  void operator=(const MemTable&);
};

先看看插入

void MemTable::Add(SequenceNumber s, ValueType type,
                   const Slice& key,
                   const Slice& value) {
  //数据结构：
  //1.internal key size : Varint32 (length of 2+3)
  //2.key data
  //3.SequenceNumber+Key type: 8 bytes
  //4 value size: Varint32
  //5 value data
  size_t key_size = key.size();
  size_t val_size = value.size();
  size_t internal_key_size = key_size + 8;
  const size_t encoded_len =
      VarintLength(internal_key_size) + internal_key_size +
      VarintLength(val_size) + val_size;
  char* buf = arena_.Allocate(encoded_len);
  char* p = EncodeVarint32(buf, internal_key_size);
  memcpy(p, key.data(), key_size);
  p += key_size;
  EncodeFixed64(p, (s << 8) | type);
  p += 8;
  p = EncodeVarint32(p, val_size);
  memcpy(p, value.data(), val_size);
  assert((p + val_size) - buf == encoded_len);
  table_.Insert(buf);
}

查询

bool MemTable::Get(const LookupKey& key, std::string* value, Status* s) {
  Slice memkey = key.memtable_key();
  Table::Iterator iter(&table_);
  iter.Seek(memkey.data());
  if (iter.Valid()) {
    // entry format is:
    //    klength  varint32
    //    userkey  char[klength]
    //    tag      uint64
    //    vlength  varint32
    //    value    char[vlength]
    // Check that it belongs to same user key.  We do not check the
    // sequence number since the Seek() call above should have skipped
    // all entries with overly large sequence numbers.
    const char* entry = iter.key();
    uint32_t key_length;
    const char* key_ptr = GetVarint32Ptr(entry, entry+5, &key_length);
    if (comparator_.comparator.user_comparator()->Compare(
            Slice(key_ptr, key_length - 8),
            key.user_key()) == 0) {
      // Correct user key
      const uint64_t tag = DecodeFixed64(key_ptr + key_length - 8);
      switch (static_cast<ValueType>(tag & 0xff)) {
        case kTypeValue: {
          Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
          value->assign(v.data(), v.size());
          return true;
        }
        case kTypeDeletion:
          *s = Status::NotFound(Slice());
          return true;
      }
    }
  }
  return false;
}

小明 2012-03-19 16:31 发表评论

leveldb研究7-Version/VersionSet/VersionEdit

小明 — Fri, 16 Mar 2012 09:10:00 GMT

leveldb 使用 version 来保存数据库的状态。

先看看一个重要的数据结果，sst file的META info

struct FileMetaData {
  int refs; //引用计数
  int allowed_seeks; //允许的seeks次数
  uint64_t number;//文件编号
  uint64_t file_size;  //文件大小
  InternalKey smallest;    //最小的key
  InternalKey largest;      //最大的key

  FileMetaData() : refs(0), allowed_seeks(1 << 30), file_size(0) { }
};

这里面有一个很有意思的字段: allowed_seeks,代表了可以seek的次数，为0的时候表示这个文件需要被compaction.如何设置seeks次数呢？文件大小除以16k，不到100算100。

f->allowed_seeks = (f->file_size / 16384);
if (f->allowed_seeks < 100) f->allowed_seeks = 100;

原因，请看leveldb的注释：

// We arrange to automatically compact this file after a certain number of seeks. Let's assume:
      //   (1) One seek costs 10ms
      //   (2) Writing or reading 1MB costs 10ms (100MB/s)
      //   (3) A compaction of 1MB does 25MB of IO:
      //         1MB read from this level
      //         10-12MB read from next level (boundaries may be misaligned)
      //         10-12MB written to next level
      // This implies that 25 seeks cost the same as the compaction
      // of 1MB of data. I.e., one seek costs approximately the
      // same as the compaction of 40KB of data. We are a little
      // conservative and allow approximately one seek for every 16KB
      // of data before triggering a compaction.

接下来看Version的定义，version其实就是一系列的SST file的集合。

class Version {
public:
  //生成iterator用于遍历
  void AddIterators(const ReadOptions&, std::vector<Iterator*>* iters);

  //根据key来查询，若没有查到，更新GetStats
  struct GetStats {
    FileMetaData* seek_file;
    int seek_file_level;
  };
  Status Get(const ReadOptions&, const LookupKey& key, std::string* val,
             GetStats* stats);

  //是否需要进行compaction
  bool UpdateStats(const GetStats& stats);

  //引用计算，避免在被引用时候删除
  void Ref();
  void Unref();

  //查询和key range有关的files
  void GetOverlappingInputs(
      int level,
      const InternalKey* begin,         // NULL means before all keys
      const InternalKey* end,           // NULL means after all keys
      std::vector<FileMetaData*>* inputs);

  //计算是否level对某个key range是否有overlap
  bool OverlapInLevel(int level,
                      const Slice* smallest_user_key,
                      const Slice* largest_user_key);

  //memtable output应该放到哪个level
  int PickLevelForMemTableOutput(const Slice& smallest_user_key,
                                 const Slice& largest_user_key);

  //某个level的文件个数
   int NumFiles(int level) const { return files_[level].size(); }

  // Return a human readable string that describes this version's contents.
  std::string DebugString() const;

private:
  friend class Compaction;
  friend class VersionSet;

  class LevelFileNumIterator;
  Iterator* NewConcatenatingIterator(const ReadOptions&, int level) const;

  VersionSet* vset_;            // VersionSet to which this Version belongs
  Version* next_;               // Next version in linked list
  Version* prev_;               // Previous version in linked list
  int refs_;                    // Number of live refs to this version

  //sst files
  std::vector<FileMetaData*> files_[config::kNumLevels];

  //下一个要被compaction的文件
  FileMetaData* file_to_compact_;
  int file_to_compact_level_;

  //compaction score:>1表示要compaction
  double compaction_score_;
  int compaction_level_;

  explicit Version(VersionSet* vset)
      : vset_(vset), next_(this), prev_(this), refs_(0),
        file_to_compact_(NULL),
        file_to_compact_level_(-1),
        compaction_score_(-1),
        compaction_level_(-1) {
  }

  ~Version();

  // No copying allowed
  Version(const Version&);
  void operator=(const Version&);
};

那VersionSet呢？VersionSet 是version组成一个双向循环链表。

class VersionSet{
//. . .
Env* const env_;
  const std::string dbname_;
  const Options* const options_;
  TableCache* const table_cache_;
  const InternalKeyComparator icmp_;
  uint64_t next_file_number_;
  uint64_t manifest_file_number_;
  uint64_t last_sequence_;
  uint64_t log_number_;

  WritableFile* descriptor_file_;
  log::Writer* descriptor_log_;
  Version dummy_versions_;  // Head of circular doubly-linked list of versions.
  Version* current_;        // == dummy_versions_.prev_

  //每层都有一个compact pointer用于指示下次从哪里开始compact,以用于实现循环compact
  std::string compact_pointer_[config::kNumLevels];
//. . .
}

VersionEdit是version对象的变更记录，用于写入manifest.这样通过原始的version加上一系列的versionedit的记录，就可以恢复到最新状态。

class VersionEdit {
public:
  VersionEdit() { Clear(); }
  ~VersionEdit() { }

  void Clear();

  void SetComparatorName(const Slice& name) {
    has_comparator_ = true;
    comparator_ = name.ToString();
  }
  void SetLogNumber(uint64_t num) {
    has_log_number_ = true;
    log_number_ = num;
  }
  void SetPrevLogNumber(uint64_t num) {
    has_prev_log_number_ = true;
    prev_log_number_ = num;
  }
  void SetNextFile(uint64_t num) {
    has_next_file_number_ = true;
    next_file_number_ = num;
  }
  void SetLastSequence(SequenceNumber seq) {
    has_last_sequence_ = true;
    last_sequence_ = seq;
  }
  void SetCompactPointer(int level, const InternalKey& key) {
    compact_pointers_.push_back(std::make_pair(level, key));
  }

  //添加meta file
  void AddFile(int level, uint64_t file,
               uint64_t file_size,
               const InternalKey& smallest,
               const InternalKey& largest) {
    FileMetaData f;
    f.number = file;
    f.file_size = file_size;
    f.smallest = smallest;
    f.largest = largest;
    new_files_.push_back(std::make_pair(level, f));
  }

  //删除特定的文件
  void DeleteFile(int level, uint64_t file) {
    deleted_files_.insert(std::make_pair(level, file));
  }

  //编码，解码：用于写入manifest
  void EncodeTo(std::string* dst) const;
  Status DecodeFrom(const Slice& src);

  std::string DebugString() const;

private:
  friend class VersionSet;

  typedef std::set< std::pair<int, uint64_t> > DeletedFileSet;

  std::string comparator_;
  uint64_t log_number_;
  uint64_t prev_log_number_;
  uint64_t next_file_number_;
  SequenceNumber last_sequence_;
  bool has_comparator_;
  bool has_log_number_;
  bool has_prev_log_number_;
  bool has_next_file_number_;
  bool has_last_sequence_;

  std::vector< std::pair<int, InternalKey> > compact_pointers_;
  DeletedFileSet deleted_files_;
  std::vector< std::pair<int, FileMetaData> > new_files_;
};

小明 2012-03-16 17:10 发表评论

leveldb研究6- Level和Compaction

小明 — Thu, 15 Mar 2012 09:28:00 GMT

摘要: leveldb之所以使用level作为数据库名称，精华就在于level的设计。本质是一种归并排序算法。这样设计的好处主要是可以减少compaction的次数和每次的文件个数。Compaction为什么要compaction? compaction可以提高数据的查询效率，没有经过compaction，需要从很多SST file去查找，而做过compaction后，只需要从有限的SST文件去... 阅读全文

小明 2012-03-15 17:28 发表评论

leveldb研究5- Snapshot

小明 — Tue, 13 Mar 2012 08:54:00 GMT

所谓snapshot就是一个快照，我们可以从快照中读到旧的数据。

先写一个测试程序来看看snapshot的使用：

#include <iostream>
#include "leveldb/db.h"

using namespace std;
using namespace leveldb;

int main() {
    DB *db ;
    Options op;
    op.create_if_missing = true;
    Status s = DB::Open(op,"/tmp/testdb",&db);

    if(s.ok()){
        cout << "create successfully" << endl;
        s = db->Put(WriteOptions(),"abcd","1234");
        if(s.ok()){
            cout << "put successfully" << endl;
            string value;
            s = db->Get(ReadOptions(),"abcd",&value);
            if(s.ok()){
                cout << "get successfully,value:" << value << endl;
            }
        }
        if(s.ok()){
            string value;
            const Snapshot * ss =db->GetSnapshot();
            ReadOptions rop;
            db->Put(WriteOptions(),"abcd","123456");
            db->Get(rop,"abcd",&value);
            if(s.ok()){
                    cout << "get successfully,value:" << value << endl;
            }
            rop.snapshot = ss;
            db->Get(rop,"abcd",&value);
            if(s.ok()){
                    cout << "get from snapshot successfully,value:" << value << endl;
            }
            db->ReleaseSnapshot(ss);
        }
    }
    delete db;
    return 0;
}

程序运行的输出结果是：

create successfully
put successfully
get successfully,value:1234
get successfully,value:123456
get from snapshot successfully,value:1234

可以看出，即使在数据更新后，我们仍然可以从snapshot中读到旧的数据。

下面我们来分析leveldb中snapshot的实现。

SequenceNumber(db/dbformat.h)

SequenceNumber是leveldb很重要的东西，每次对数据库进行更新操作，都会生成一个新的SequenceNumber,64bits，其中高8位为0，可以跟key的类型(8bits)进行合并成64bits。

typedef uint64_t SequenceNumber;

// We leave eight bits empty at the bottom so a type and sequence#
// can be packed together into 64-bits.
static const SequenceNumber kMaxSequenceNumber =
((0x1ull << 56) - 1);

SnapShot(db/snapshot.h),，可以看出snapshot其实就是一个sequence number

class SnapshotImpl : public Snapshot {
public:
  //创建后保持不变
  SequenceNumber number_;

private:
  friend class SnapshotList;

  //双向循环链表
  SnapshotImpl* prev_;
  SnapshotImpl* next_;

  SnapshotList* list_;                 // just for sanity checks
};

创建snapshot:

const Snapshot* DBImpl::GetSnapshot() {
MutexLock l(&mutex_);
return snapshots_.New(versions_->LastSequence());
}

删除snapshot:

void DBImpl::ReleaseSnapshot(const Snapshot* s) {
MutexLock l(&mutex_);
snapshots_.Delete(reinterpret_cast<const SnapshotImpl*>(s));
}

小明 2012-03-13 16:54 发表评论

leveldb研究4- 数据文件的格式和生成

小明 — Mon, 12 Mar 2012 10:21:00 GMT

小明 2012-03-12 18:21 发表评论

leveldb研究3-数据库日志文件格式

小明 — Fri, 09 Mar 2012 08:00:00 GMT

摘要: leveldb在每次数据库操作之前都会把操作记录下来。主要实现在db\log_format.h,db\log_reader.h,db\log_reader.cc,db\log_write.h,db\log_write.cc中。我们来具体看看实现。日志格式 db\log_format.h log是分块的，每块为32K,每条记录的记录头为7个字节，前四个为CRC，然后是长度（2个字节）... 阅读全文

小明 2012-03-09 16:00 发表评论

leveldb研究2- 存储分析

小明 — Fri, 09 Mar 2012 03:44:00 GMT

摘要: 对于一个db来说，存储是至关重要的问题。运行上一篇的测试程序后，会发现leveldb会生成以下文件：SST文件：数据文件 -- sstable格式*.log: 数据库日志文件 -- 顺序记录所有数据库操作，用来恢复数据CURRENT: 文本文件，表明当面的manifest文件LOCK:空文件，数据库锁，防止多进程访问LOG: 日志文件，文本格式LOG.old:上一次的日志文件MANIFEST: 数... 阅读全文

小明 2012-03-09 11:44 发表评论

leveldb研究 - 编译/调试

小明 — Thu, 08 Mar 2012 03:44:00 GMT

leveldb是 google对bigtable的一个简化版的开源实现，很有研究价值。

我的编译环境:ubuntu 32&g++ 4.6

1.安装git并下载代码

sudo apt-get install git-core
git clone https://code.google.com/p/leveldb/

2. 编译leveldb

cd leveldb
./build_detect_platform
make

为了能够调试，修改Makefile为debug mode(B模式)
OPT ?= -g2

编译后会生成库文件：libleveldb.a

3. 编写测试程序
ldbtest.cpp

注意link的时候需要加上-lpthread.

运行后得到结果：(Eclipse中运行）

小明 2012-03-08 11:44 发表评论

Learn From HBase/Bigtable

小明 — Wed, 07 Mar 2012 02:42:00 GMT

学习软件有三个境界，第一个境界是会使用它，第二个境界是懂得背后的原理，明白它的架构体系，第三个境界学习他的所长，为我所用。研究HBase/BigTable架构和源码一段时间后，我总结了一些东西可以供我们在设计分布式系统借鉴使用。

1. 使用可信任的分布式组件来搭建自己的分布式系统。
设计一个可靠，健壮的分布式系统是比较困难的。我们知道，为了防止SPOF(Single Point Of Failure)问题，我们要分散风险，把数据放在多个nodes上面去，但是这样带来了是数据的同步问题和版本问题，解决这个问题需要运用复杂的 Paxos协议，系统的复杂度自然就升高了。另外一个需要解决的问题是分布式锁和事件通知机制，以及全局信息共享，设计这些都需要大量的精力和仔细的研究。

HBase就不用考虑这些问题，它把数据的同步和冗余问题交给了Hadoop,把锁机制和全局共享交给了Zookeeper,这大大简化了HBase的设计。

所以我们设计系统的时候，也要尽量利用这些可靠，稳定的组件。目前比较流行和稳定的有：
分布式文件系统 - HDFS
分布式锁和目录 - Zookeeper
缓存 - MemCached
消息队列 - ActiveMQ

2.避免单点问题(SPOF)
设计分布式系统要时刻考虑到失败，不单是软件可能失败，硬件也可能挂掉，所以我们系统里面就不能有不可替代的角色。

HBase 使用Master Server来监控所有的Region Server,一旦其中的一台出现问题，在其上的Region将会被转移到其他的Region Server，避免了服务中断。而Master Server也可以多台备选，一台挂掉之后，其他的备胎则会”继承遗志“，从而让整个系统得以生存。

那 HBase如何做到这个呢，一个是使用”心跳机制”，即Region Server要主动定期向Master汇报状况，另外一个是利用zookeeper里面的”生命节点“，每个server在启动后要在ZK里面注册，一旦这个server挂掉，它在ZK里面的节点就会消失，监听这个节点的server就会得到通知。

3.利用不变性提高系统的吞吐量
我们知道，很多进程/线程修改同一个东西的时候，我们就需要锁机制来避免冲突。但是锁带来的问题是系统性能下降。如果对于一个只读的对象，就不需要锁了。

HBase 在设计存储的时候考虑到这一点，最新的数据是放在memory里面，以提高性能。但是memory是有限的，我们不可能让数据一直放在memory里面，所以我们需要定时把这些数据写到HDFS/磁盘上面。一种设计是写到一个可修改的大文件中去，这样对这个文件的读写就需要加锁了。HBase是每次都写到一个新的文件中，一旦文件创建后，这个文件将不能被修改，就是所谓的create-one-read-many。当然这样也有一个问题，就是时间长了，会有很多的小文件，每次查找，需要查找这所有的文件，降低了系统的性能，HBase会定时的合并这些小文件生成一个大文件。

4.利用索引块提高文件的查询速度
HBase的存储文件(HFile)是用来存储很多排序后的Key-Value的，如何设计一种支持快速随机查询和压缩的文件是一个有意思的话题。

HFile 在文件的尾部增加了索引块，但是不可能对任何一个rowkey都做索引，这样的话索引块会很大，而且也不利于压缩。HFile的做法是定义一个Data Block的大小，这样就把数据划分了一个一个的Block，索引只针对这些block做，Block是可以被压缩的。当查询一个rowkey的时候，如果没有cache的话，首先使用二分法定位到具体的block，然后再解压，遍历查询具体的key。

HFile这样的设计兼顾了速度和文件大小的平衡。

5.自定义RPC机制提供更大的灵活性
HBase/Hadoop 都没有利用标准的Java远程调用规范RMI,而是自己搞了一套。这样做的好处有几点，一是减少网络流量，我们知道，java RMI使用了java serlizable来传递参数，java序列化有很多无关的类信息，都占用不少的空间，而且这会带来对java版本的依赖。二是带来更大的灵活性，你可以在其中加入版本检查，权限认证等。

那 HBase是怎么设计这个RPC呢？首先它定义了一个writable接口，来代替java序列化，实现这个接口就等于告诉HBase，怎么把这个对象写到RPC流中去。使用RPC的时候，需要先写一个服务器端和客户端共用的interface,这个interface必须继承 VersionedProtocol来处理版本问题。HBase利用Java的动态反射机制(Proxy.newProxyInstance)来生成代理对象，这样当Client调用代理对象的时候，Client就会把参数打包，发送到服务器端，然后等待返回结果。服务器会根据interface查找到具体的实现的对象，调用该对象的方法来执行远程调用。详细的做法可以参考HBase/Hadoop的源码。

6.内嵌Web Server增强系统的透明度
当一个后台进程启动之后，我们如何了解这个进程的内部状态呢？传统方法是通过进程管理器或者Debug log来看进程的情况，但是这些信息很有限。

HBase利用jetty在进程内部启动了一个web server，就可以即时的显示一些系统内部的信息，非常的方便。

利用Jetty支持jsp非常的容易，下面是一个示例的代码。注意的是，需要把jasper-runtime-5.5.12.jar,jasper- compiler-5.5.12.jar,jasper-compiler-jdt-5.5.12.jar,jsp-2.1.jar,jsp-api- 2.1.jar等jar包放在classpath里面，否则会出现页面解析错误。

server = new Server(port);

server.setSendServerVersion(false);
server.setSendDateHeader(false);
server.setStopAtShutdown(true);

WebAppContext wac = new WebAppContext();
wac.setContextPath("/");
wac.setWar("./webapps/job");
server.setHandler(wac);
server.setStopAtShutdown(true);

小明 2012-03-07 10:42 发表评论