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