亚洲综合色区中文字幕,亚洲AV无码专区国产乱码4SE ,亚洲va成无码人在线观看

leveldb研究10- ��程分析�Q�写数据

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

��M��来说,leveldb的写操作有两个步骤，首先是针对log的append操作�Q�然后是对memtable的插入操作�?br />
影响写性能的因素有�Q?br />1. write_buffer_size
2. kL0_SlowdownWritesTrigger and kL0_StopWritesTrigger.提高�q�两个��|��能够增加写的性能�Q�但是降低读的性能

看看WriteOptions有哪些参数可以指�?br />

struct WriteOptions {
  //讄��sync=true,leveldb�?x��)调用fsync()�Q�这�?x��)降低插入性能
  //同时�?x��)增加数据的安全�?nbsp;
  //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);
}

接下来就是真正的插入�?br />�q�里使用�?ji��n)两把锁�Q�主要是��x(ch��ng)��高�ƈ发能力，减少上锁的时间�?br />首先是检查是否可写，然后append log�Q�最后是插入memtable

Status DBImpl::Write(const WriteOptions& options, WriteBatch* updates) {
  Status status;
  //加锁
  MutexLock l(&mutex_);
  LoggerId self;
  //拿到写log的权�?/span>
  AcquireLoggingResponsibility(&self);
  //��(g��)查是否可�?/span>
  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操作�Q�写入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�?/span>
  ReleaseLoggingResponsibility(&self);
  return status;
}

写流量控�Ӟ��(x��)

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�Q�这��L(f��ng)��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�Q�需要等�?/span>
      bg_cv_.Wait();
    } else if (versions_->NumLevelFiles(0) >= config::kL0_StopWritesTrigger) {
      // level0文�g个数大于kL0_StopWritesTrigger,需要等�?/span>
      Log(options_.info_log, "waiting\n");
      bg_cv_.Wait();
    } else {
      //生成新的额memtable和logfile�Q�把当前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

// 发�vcompaction,dump imm_

      MaybeScheduleCompaction();
    }
  }
  return s;
}

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

��明 — 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- 内存?sh��)��的数据�l�构Memtable/SkipList

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

我们知道,leveldb在写数据的时候，除了(ji��n)log文�g�Q�都要在内存?sh��)��写一份�?br />
先看看SkipList【蟩表】这个数据结构：(x��)

SkipList有如下特点：(x��)
1. 本质上一个排序好的链�?br />2. 分层�Q�上层节�Ҏ(gu��)��下层的少�Q�更��h��跌��?br />3. 查询的复杂度是O(logn)

SkipList跟红黑树(w��i)�{�还是比较容易实现和理解的，主要长处是比较容易实现Lock free和遍历�?br />我们来看看leveldb的实�?br />插入�Q?br />

//插入一个新的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_;
    }
    //讄��当前最大高�?/span>
    max_height_.NoBarrier_Store(reinterpret_cast<void*>(height));
  }

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

查询�Q?br />

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; //从高层开始查找，依次�? level
  while (true) {
    Node* next = x->Next(level);
    if (KeyIsAfterNode(key, next)) { //比next key 要大
      // Keep searching in this list
      x = next;
    } else { //比next key��，查找下一�?br />      //标记当前level的前�|�节�?/span>
      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的实玎ͼ�很简单了(ji��n)�Q�基本是对SkipList讉K��一个封�?br />

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

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

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

  //内存?sh��)��用�?/span>
  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�Q�用于排�?/span>
  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_; //内存分配�?/span>
  Table table_; //数据存放SkipList

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

先看看插�?br />

void MemTable::Add(SequenceNumber s, ValueType type,
                   const Slice& key,
                   const Slice& value) {
  //数据�l�构�Q?br />  //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 来保存数据库的状态�?br />
先看看一个重要的数据�l�果�Q�sst file的META info

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

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

�q�里面有一个很有意思的字段: allowed_seeks,代表�?ji��n)可以seek的次敎ͼ��?的时候表�C��个文仉��要被compaction.如何讄��seeks�ơ数呢？文�g大小除以16k�Q�不�?00��?00�?br />

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

原因�Q�请看leveldb的注释：(x��)

// 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其实��是一�p�d��的SST file的集合�?br />

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

  //�Ҏ(gu��)��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);

  //引用计算�Q�避免在被引用时候删�?/span>
  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�Ҏ(gu��)��个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的文件个�?/span>
   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的文�?/span>
  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�l�成一个双向��@环链表�?br />

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.�q�样通过原始的version加上一�p�d��的versionedit的记录，��可以恢复到最新状态�?br />

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));
  }

  //��d��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));
  }

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

  //�~�码�Q�解码：(x��)用于写入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作�ؓ(f��)数据库名�U�ͼ��_�֍��在于level的设计。本质是一�U�归�q�排序算法。这栯��计的好处主要是可以减��compaction的次数和每次的文件个数。Compaction��Z��么要compaction? compaction可以提高数据的查询效率，没有�l�过compaction�Q�需要从很多SST file��L��找，而做�q�compaction后，只需要从有限的SST文�g�?.. 阅读全文

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

leveldb研究5- Snapshot

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

所谓snapshot��是一个快照，我们可以从快照中��d��旧的数据�?br />
先写一个测试程序来看看snapshot的��用：(x��)

#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;
}

�E�序�q�行的输出结果是�Q?br />

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

可以看出�Q�即使在数据更新后，我们仍然可以从snapshot中读到旧的数据�?br />
下面我们来分析leveldb中snapshot的实现�?br />
SequenceNumber(db/dbformat.h)

SequenceNumber是leveldb很重要的东西�Q�每�ơ对数据库进行更新操作，都会(x��)生成一个新的SequenceNumber,64bits�Q�其中高8位�ؓ(f��)0�Q�可以跟key的类�?8bits)�q�行合�ƈ�?4bits�?/div>

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),�Q�可以看出snapshot其实��是一个sequence number

class SnapshotImpl : public Snapshot {
public:
  //创徏后保持不�?/span>
  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- 数据文�g的格式和生成

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

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

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

摘要: leveldb在每�ơ数据库操作之前都会(x��)把操作记录下来�?主要实现在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是分块的�Q�每块�ؓ(f��)32K,每条记录的记录头�?个字节，前四个�ؓ(f��)CRC�Q�然后是长度�Q?个字节）(j��)... 阅读全文

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

leveldb研究2- 存储分析

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

摘要: 对于一个db来说�Q�存储是臛_��重要的问题。运行上一��的��试�E�序后，�?x��)发现l(f��)eveldb�?x��)生成以下文�Ӟ�?x��)SST文�g�Q�数据文�?-- sstable格式*.log: 数据库日志文�?-- ��序记录所有数据库操作�Q�用来恢复数据CURRENT: 文本文�g�Q�表明当面的manifest文�gLOCK:�I�文�Ӟ��数据库锁�Q�防止多�q�程讉K��LOG: 日志文�g�Q�文本格式LOG.old:上一�ơ的日志文�gMANIFEST: �?.. 阅读全文

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

leveldb研究 - �~�译/调试

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

leveldb�?google对bigtable的一个简化版的开源实玎ͼ�很有研究价倹{�?br />
我的�~�译环境:ubuntu 32&g++ 4.6

1.安装git�q�下载代�?br />

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

2. �~�译leveldb

cd leveldb
./build_detect_platform
make

��Z��(ji��n)能够调试�Q�修改Makefile为debug mode(B模式)
OPT ?= -g2

�~�译后会(x��)生成库文�Ӟ��(x��)libleveldb.a

3. �~�写��试�E�序
ldbtest.cpp

注意link的时候需要加�?lpthread.

�q�行后得到结果：(x��)(Eclipse中运行）(j��)

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

Learn From HBase/Bigtable

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

学习(f��n)软�g有三个境界，�W�一个境界是�?x��)��用它�Q�第二个境界是懂得背后的原理�Q�明白它的架构体�p�，�W�三个境界学�?f��n)他的所长，为我所用。研�I�HBase/BigTable架构和源码一�D�|��间后�Q�我�ȝ��?ji��n)一些东西可以供我们在设计分布式�pȝ��借鉴使用�?/p>

1. 使用可信�ȝ��分布式组件来搭徏自己的分布式�pȝ��?/strong>
�?计一个可靠，健壮的分布式�pȝ��是比较困隄��。我们知道，��Z��(ji��n)防止SPOF(Single Point Of Failure)问题�Q�我们要分散风险�Q�把数据攑֜�多个nodes上面去，但是�q�样带来�?ji��n)是数据的同步问题和版本问题�Q�解册��个问题需要运用复杂的 Paxos协议�Q�系�l�的复杂度自然就升高?sh��)��(ji��n)。另外一个需要解决的问题是分布式锁和事�g通知机制�Q�以�?qi��ng)全局信息�׃�n�Q�设计这些都需要大量的�_�֊�和仔�l�的�? �I��?/p>

HBase��׃��用考虑�q�些问题�Q�它把数据的同步和冗余问题�(sh��)��l�了(ji��n)Hadoop,把锁机制和全局�׃�n交给�?ji��n)Zookeeper,�q�大大简化了(ji��n)HBase的设计�?/p>

所以我们设计系�l�的时候，也要��量利用�q�些可靠�Q�稳定的�l��g。目前比较流行和�E�_��的有�Q?br /> 分布式文件系�l?nbsp;- HDFS
分布式锁和目�?nbsp;- Zookeeper
�~�存 - MemCached
消息队列 - ActiveMQ

2.避免单点问题(SPOF)
设计分布式系�l�要时刻考虑到失败，不单是��Y件可能失败，��g也可能挂掉，所以我们系�l�里面就不能有不可替代的角色�?/p>

HBase 使用Master Server来监控所有的Region Server,一旦其中的一台出现问题，在其上的Region��会(x��)被�{�U�d��其他的Region Server�Q�避免了(ji��n)服务中断。而Master Server也可以多台备选，一台挂掉之后，其他的备胎则�?#8221;�l�承遗志“�Q�从而让整个�pȝ��得以生存�?/p>

�? HBase如何做到�q�个呢，一个是使用”�?j��)蟩机�?#8221;�Q�即Region Server要主动定期向Master汇报状况�Q�另外一个是利用zookeeper里面�?#8221;生命节点“�Q�每个server在启动后要在ZK里面注册�Q�一�? �q�个server挂掉�Q�它在ZK里面的节点就�?x��)消失，监听�q�个节点的server��׃��(x��)得到通知�?/p>

3.利用不变性提高系�l�的吞吐�?/strong>
我们知道�Q�很多进�E?�U�程修改同一个东西的时候，我们��需要锁机制来避免冲�H�。但是锁带来的问题是�pȝ��性能下降。如果对于一个只�ȝ��对象�Q�就不需要锁�?ji��n)�?/p>

HBase 在设计存储的时候考虑到这一点，最新的数据是放在memory里面�Q�以提高性能。但是memory是有限的�Q�我们不可能让数据一直放在memory里面�Q? 所以我们需要定时把�q�些数据写到HDFS/��盘?sh��)��面。一�U�设计是写到一个可修改的大文�g中去�Q�这样对�q�个文�g的读写就需要加锁了(ji��n)。HBase是每�ơ都写到一个新的文件中�Q�一旦文件创建后�Q�这个文件将不能被修改，��是所谓的create-one-read-many。当然这样也有一个问题，��是旉��长了(ji��n)�Q�会(x��) 有很多的��文�Ӟ��每次查找�Q�需要查找这所有的文�g�Q�降低了(ji��n)�pȝ��的性能�Q�HBase�?x��)定时的合�ƈ�q�些��文件生成一个大文�g�?/p>

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

HFile 在文件的��N��增加�?ji��n)�?ch��)引块�Q�但是不可能对�Q何一个rowkey都做索引�Q�这��L(f��ng)��话烦(ch��)引块�?x��)很大，而且也不利于压羃。HFile的做法是定义一个Data Block的大��，�q�样��把数据划分�?ji��n)一个一个的Block�Q�烦(ch��)引只针对�q�些block做，Block是可以被压羃的。当查询一个rowkey的时候，�? 果没有cache的话�Q�首先��用二分法定位到具体的block�Q�然后再解压�Q�遍历查询具体的key�?/p>

HFile�q�样的设计兼��了(ji��n)速度和文件大��的�q��?/p>

5.自定义RPC机制提供更大的灵�z�L�?/strong>
HBase/Hadoop 都没有利用标准的Java�q�程调用规范RMI,而是自己搞了(ji��n)一套。这样做的好处有几点�Q�一是减��网�l�流量，我们知道�Q�java RMI使用�?ji��n)java serlizable来传递参敎ͼ�java序列化有很多无关的类信息�Q�都占用不少的空��_(d��)��而且�q�会(x��)带来对java版本的依赖。二是带来更大的灉|��性，你可以在其中加入版本��(g��)查，权限认证�{��?/p>

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

6.内嵌W(xu��)eb Server增强�pȝ��的透明�?/strong>
当一个后台进�E�启动之后，我们如何�?ji��n)解�q�个�q�程的内部状态呢�Q�传�l�方法是通过�q�程��理器或者Debug log来看�q�程的情况，但是�q�些信息很有限�?/p>

HBase利用jetty在进�E�内部启动了(ji��n)一个web server�Q�就可以��x(ch��ng)��的显�C�Z��些系�l�内部的信息�Q�非常的方便�?/p>

�? 用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里面�Q�否则会(x��)出现��面解析错误�?/p>

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 发表评论