前端开发-Node.js 抓取堆快照过程解析-职坐标

前端开发-Node.js 抓取堆快照过程解析

小职 2021-11-04 来源：编程杂技阅读 948 评论 0

摘要：本篇主要介绍了前端开发-Node.js 抓取堆快照过程解析，通过具体的内容展现，希望对大家web前端Node.js的学习有一定的帮助。

本篇主要介绍了前端开发-Node.js 抓取堆快照过程解析，通过具体的内容展现，希望对大家web前端Node.js的学习有一定的帮助。

前端开发-Node.js 抓取堆快照过程解析

前言：在 Node.js 中，我们有时候需要抓取进程堆快照来判断是否有内存泄漏，本文介绍Node.js 中抓取堆快照的实现。

首先来看一下 Node.js 中如何抓取堆快照。

const { Session } = require('inspector');

const session = new Session();

let chunk = '';

const cb = (result) => {

chunk += result.params.chunk;

};

session.on('HeapProfiler.addHeapSnapshotChunk', cb);

session.post('HeapProfiler.takeHeapSnapshot', (err, r) => {

session.off('HeapProfiler.addHeapSnapshotChunk', cb);

console.log(err || chunk);

});

下面看一下 HeapProfiler.addHeapSnapshotChunk 命令的实现。

{

v8_crdtp::SpanFrom("takeHeapSnapshot"),

&DomainDispatcherImpl::takeHeapSnapshot

}

对应 DomainDispatcherImpl::takeHeapSnapshot 函数。

void DomainDispatcherImpl::takeHeapSnapshot(const v8_crdtp::Dispatchable& dispatchable){

std::unique_ptr<DomainDispatcher::WeakPtr> weak = weakPtr();

// 抓取快照

DispatchResponse response = m_backend->takeHeapSnapshot(std::move(params.reportProgress), std::move(params.treatGlobalObjectsAsRoots), std::move(params.captureNumericValue));

// 抓取完毕，响应

if (weak->get())

weak->get()->sendResponse(dispatchable.CallId(), response);

return;

}

上面代码中 m_backend 是 V8HeapProfilerAgentImpl 对象。

Response V8HeapProfilerAgentImpl::takeHeapSnapshot(

Maybe<bool> reportProgress, Maybe<bool> treatGlobalObjectsAsRoots,

Maybe<bool> captureNumericValue) {

v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();

// 抓取快照

const v8::HeapSnapshot* snapshot = profiler->TakeHeapSnapshot(

progress.get(), &resolver, treatGlobalObjectsAsRoots.fromMaybe(true),

captureNumericValue.fromMaybe(false));

// 抓取完毕后通知调用方

HeapSnapshotOutputStream stream(&m_frontend);

snapshot->Serialize(&stream);

const_cast<v8::HeapSnapshot*>(snapshot)->Delete();

// HeapProfiler.takeHeapSnapshot 命令结束，回调调用方

return Response::Success();

}

我们重点看一下 profiler->TakeHeapSnapshot。

const HeapSnapshot* HeapProfiler::TakeHeapSnapshot(

ActivityControl* control, ObjectNameResolver* resolver,

bool treat_global_objects_as_roots, bool capture_numeric_value) {

return reinterpret_cast<const HeapSnapshot*>(

reinterpret_cast<i::HeapProfiler*>(this)->TakeSnapshot(

control, resolver, treat_global_objects_as_roots,

capture_numeric_value));

}

继续看真正的 TakeSnapshot。

HeapSnapshot* HeapProfiler::TakeSnapshot(

v8::ActivityControl* control,

v8::HeapProfiler::ObjectNameResolver* resolver,

bool treat_global_objects_as_roots, bool capture_numeric_value) {

is_taking_snapshot_ = true;

HeapSnapshot* result = new HeapSnapshot(this, treat_global_objects_as_roots,

capture_numeric_value);

{

HeapSnapshotGenerator generator(result, control, resolver, heap());

if (!generator.GenerateSnapshot()) {

delete result;

result = nullptr;

} else {

snapshots_.emplace_back(result);

}

return result;

}

我们看到新建了一个 HeapSnapshot 对象，然后通过 HeapSnapshotGenerator 对象的 GenerateSnapshot 抓取快照。看一下 GenerateSnapshot。

bool HeapSnapshotGenerator::GenerateSnapshot() {

Isolate* isolate = Isolate::FromHeap(heap_);

base::Optional<HandleScope> handle_scope(base::in_place, isolate);

v8_heap_explorer_.CollectGlobalObjectsTags();

// 抓取前先回收不用内存，保证看到的是存活的对象，否则影响内存泄漏的分析

heap_->CollectAllAvailableGarbage(GarbageCollectionReason::kHeapProfiler);

// 收集内存信息

snapshot_->AddSyntheticRootEntries();

FillReferences();

snapshot_->FillChildren();

return true;

}

GenerateSnapshot 的逻辑是首先进行GC 回收不用的内存，然后收集 GC 后的内存信息到 HeapSnapshot 对象。接着看收集完后的逻辑。

HeapSnapshotOutputStream stream(&m_frontend);

snapshot->Serialize(&stream);

HeapSnapshotOutputStream 是用于通知调用方收集的数据(通过 m_frontend)。

explicit HeapSnapshotOutputStream(protocol::HeapProfiler::Frontend* frontend)

: m_frontend(frontend) {}

void EndOfStream() override {}

int GetChunkSize() override { return 102400; }

WriteResult WriteAsciiChunk(char* data, int size) override {

m_frontend->addHeapSnapshotChunk(String16(data, size));

m_frontend->flush();

return kContinue;

}

HeapSnapshotOutputStream 通过 WriteAsciiChunk 告诉调用方收集的数据，但是目前我们还没有数据源，下面看看数据源怎么来的。

snapshot->Serialize(&stream);

看一下 Serialize。

void HeapSnapshot::Serialize(OutputStream* stream,

HeapSnapshot::SerializationFormat format) const {

i::HeapSnapshotJSONSerializer serializer(ToInternal(this));

serializer.Serialize(stream);

}

最终调了 HeapSnapshotJSONSerializer 的 Serialize。

void HeapSnapshotJSONSerializer::Serialize(v8::OutputStream* stream) {

// 写者

writer_ = new OutputStreamWriter(stream);

// 开始写

SerializeImpl();

}

我们看一下 SerializeImpl。

void HeapSnapshotJSONSerializer::SerializeImpl() {

DCHECK_EQ(0, snapshot_->root()->index());

writer_->AddCharacter('{');

writer_->AddString("\"snapshot\":{");

SerializeSnapshot();