memwatch分析

摘要：介绍是一个扩展，主要用来观察内存泄露问题，基本用法如下实现分析分析的版本为。的入口函数在文件中，通过进行声明。下面分析下函数的具体实现函数内部会递归调用函数得到最终堆快照的结果。回调的触发与的钩子有关，详细看下一节分析。

memwatch是一个c++扩展，主要用来观察nodejs内存泄露问题，基本用法如下：

const memwatch = require("@airbnb/memwatch");
function LeakingClass() {
}

memwatch.gc();
var arr = [];
var hd = new memwatch.HeapDiff();
for (var i = 0; i < 10000; i++) arr.push(new LeakingClass);
var hde = hd.end();
console.log(JSON.stringify(hde, null, 2));

分析的版本为@airbnb/memwatch。首先从binding.gyp开始入手:

{
  "targets": [
    {
      "target_name": "memwatch",
      "include_dirs": [
        "
这份配置表示其生成的目标是memwatch.node,源码是src目录下的heapdiff.cc、init.cc、memwatch.cc、util.cc,在项目编译的过程中还需要include额外的nan目录，nan目录通过执行node -e "require("nan")按照node模块系统寻找nan依赖， 表示后面是一条指令。

memwatch的入口函数在init.cc文件中，通过NODE_MODULE(memwatch, init);进行声明。当执行require("@airbnb/memwatch")的时候会首先调用init函数：
void init (v8::Handle target)
{
    Nan::HandleScope scope;
    heapdiff::HeapDiff::Initialize(target);

    Nan::SetMethod(target, "upon_gc", memwatch::upon_gc);
    Nan::SetMethod(target, "gc", memwatch::trigger_gc);

    Nan::AddGCPrologueCallback(memwatch::before_gc);
    Nan::AddGCEpilogueCallback(memwatch::after_gc);
}
init函数的入口参数v8:Handle target可以类比nodejs中的module.exports的exports对象。函数内部做的实现可以分为三块，初始化target、给target绑定upon_gc和gc两个函数、在nodejs的gc前后分别挂上对应的钩子函数。
Initialize实现
到heapdiff.cc文件中来看heapdiff::HeapDiff::Initialize(target);的实现。
void heapdiff::HeapDiff::Initialize ( v8::Handle target )
{
    Nan::HandleScope scope;
    
    v8::Local t = Nan::New(New);
    t->InstanceTemplate()->SetInternalFieldCount(1);
    t->SetClassName(Nan::New("HeapDiff").ToLocalChecked());

    Nan::SetPrototypeMethod(t, "end", End);
    target->Set(Nan::New("HeapDiff").ToLocalChecked(), t->GetFunction());
}
Initialize函数中创建一个叫做HeapDiff的函数t，同时在t的原型链上绑了end方法，使得js层面可以执行vat hp = new memwatch.HeapDiff();hp.end()。

new memwatch.HeapDiff实现
当js执行new memwatch.HeapDiff();的时候，c++层面会执行heapdiff::HeapDiff::New函数，去掉注释和不必要的宏，New函数精简如下：
NAN_METHOD(heapdiff::HeapDiff::New)
{
    if (!info.IsConstructCall()) {
        return Nan::ThrowTypeError("Use the new operator to create instances of this object.");
    }

    Nan::HandleScope scope;

    HeapDiff * self = new HeapDiff();
    self->Wrap(info.This());

    s_inProgress = true;
    s_startTime = time(NULL);
    
    self->before = v8::Isolate::GetCurrent()->GetHeapProfiler()->TakeHeapSnapshot(NULL);

    s_inProgress = false;

    info.GetReturnValue().Set(info.This());
}
可以看到用户在js层面执行var hp = new memwatch.HeapDiff();的时候，c++层面会调用nodejs中的v8的api对对堆上内存打一个snapshot保存到self->before中，并将当前对象返回出去。

memwatch.HeapDiff.End实现
当用户执行hp.end()的时候，会执行原型链上的end方法，也就是c++的heapdiff::HeapDiff::End方法。同样去掉冗余的注释以及宏，End方法可以精简如下：
NAN_METHOD(heapdiff::HeapDiff::End)
{
    Nan::HandleScope scope;

    HeapDiff *t = Unwrap( info.This() );

    if (t->ended) {
        return Nan::ThrowError("attempt to end() a HeapDiff that was already ended");
    }
    t->ended = true;

    s_inProgress = true;
    t->after = v8::Isolate::GetCurrent()->GetHeapProfiler()->TakeHeapSnapshot(NULL);
    s_inProgress = false;

    v8::Local comparison = compare(t->before, t->after);
    
    ((HeapSnapshot *) t->before)->Delete();
    t->before = NULL;
    ((HeapSnapshot *) t->after)->Delete();
    t->after = NULL;

    info.GetReturnValue().Set(comparison);
}
在End函数中，拿到当前的HeapDiff对象之后，再对当前的堆上内存再打一个snapshot，调用compare函数对前后两个snapshot对比后得到comparison后，将前后两次snapshot对象释放掉，并将结果通知给js。
下面分析下compare函数的具体实现：
compare函数内部会递归调用buildIDSet函数得到最终堆快照的diff结果。
static v8::Local
compare(const v8::HeapSnapshot * before, const v8::HeapSnapshot * after)
{
    Nan::EscapableHandleScope scope;
    int s, diffBytes;

    Local