Node.js 抓取堆快照過程解析

作者：theanarkh 2021-10-23 06:42:46

在 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(); 
  if (writer_->aborted()) return; 
  writer_->AddString("},\n"); 
  writer_->AddString("\"nodes\":["); 
  SerializeNodes(); 
  if (writer_->aborted()) return; 
  writer_->AddString("],\n"); 
  writer_->AddString("\"edges\":["); 
  SerializeEdges(); 
  if (writer_->aborted()) return; 
  writer_->AddString("],\n"); 
 
  writer_->AddString("\"trace_function_infos\":["); 
  SerializeTraceNodeInfos(); 
  if (writer_->aborted()) return; 
  writer_->AddString("],\n"); 
  writer_->AddString("\"trace_tree\":["); 
  SerializeTraceTree(); 
  if (writer_->aborted()) return; 
  writer_->AddString("],\n"); 
 
  writer_->AddString("\"samples\":["); 
  SerializeSamples(); 
  if (writer_->aborted()) return; 
  writer_->AddString("],\n"); 
 
  writer_->AddString("\"locations\":["); 
  SerializeLocations(); 
  if (writer_->aborted()) return; 
  writer_->AddString("],\n"); 
 
  writer_->AddString("\"strings\":["); 
  SerializeStrings(); 
  if (writer_->aborted()) return; 
  writer_->AddCharacter(']'); 
  writer_->AddCharacter('}'); 
  writer_->Finalize(); 
 
}

SerializeImpl 函數的邏輯就是把快照數據通過 OutputStreamWriter 對象 writer_ 寫到 writer_ 持有的 stream 中。寫的數據有很多種類型，這里以 AddCharacter 為例。

void AddCharacter(char c) { 
  chunk_[chunk_pos_++] = c; 
  MaybeWriteChunk(); 
 
}

每次寫的時候都會判斷是不達到閾值，是的話則先推給調用方。看一下 MaybeWriteChunk。

void MaybeWriteChunk() { 
  if (chunk_pos_ == chunk_size_) { 
    WriteChunk(); 
  } 
 
} 
 
 
 
void WriteChunk() { 
 
  // stream 控制是否還需要寫入，通過 kAbort 和 kContinue 
  if (stream_->WriteAsciiChunk(chunk_.begin(), chunk_pos_) == 
      v8::OutputStream::kAbort) 
    aborted_ = true; 
  chunk_pos_ = 0; 
 
}

我們看到最終通過 stream 的 WriteAsciiChunk 寫到 stream 中。

WriteResult WriteAsciiChunk(char* data, int size) override { 
  m_frontend->addHeapSnapshotChunk(String16(data, size)); 
  m_frontend->flush(); 
  return kContinue; 
 
}

WriteAsciiChunk 調用 addHeapSnapshotChunk 通知調用方。

void Frontend::addHeapSnapshotChunk(const String& chunk){ 
    v8_crdtp::ObjectSerializer serializer; 
    serializer.AddField(v8_crdtp::MakeSpan("chunk"), chunk); 
    frontend_channel_->SendProtocolNotification(v8_crdtp::CreateNotification("HeapProfiler.addHeapSnapshotChunk", serializer.Finish())); 
 
}

觸發 HeapProfiler.addHeapSnapshotChunk 事件，并傳入快照的數據，最終觸發 JS 層的事件。再看一下文章開頭的代碼。

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.takeHeapSnapshot 命令后，V8 就開始收集內存，然后不斷觸發

HeapProfiler.addHeapSnapshotChunk 事件，直到堆數據寫完，然后執行 JS 回調。

總結：整個過程不算復雜，因為我們沒有涉及到堆內存管理那部分，V8 Inspector 提供了很多命令，有時間的話后續再分析其他的命令。

責任編輯：姜華來源：編程雜技