V8性能分析工具 ​

// 方法1：通过 inspect 启动
// node --inspect app.js

// 方法2：在代码中触发
const inspector = require('inspector');
const fs = require('fs');

const session = new inspector.Session();
session.connect();

// 开始采集
session.post('Profiler.enable', () => {
  session.post('Profiler.start', () => {
    // 执行要分析的代码
    runBenchmark();
    
    // 停止采集
    session.post('Profiler.stop', (err, { profile }) => {
      fs.writeFileSync('profile.cpuprofile', JSON.stringify(profile));
      console.log('Profile saved!');
    });
  });
});

const v8 = require('v8');
const fs = require('fs');

// 生成堆快照
function takeHeapSnapshot(filename) {
  const snapshotPath = filename || `heap-${Date.now()}.heapsnapshot`;
  v8.writeHeapSnapshot(snapshotPath);
  console.log(`Heap snapshot written to ${snapshotPath}`);
  return snapshotPath;
}

// 使用示例
setInterval(() => {
  const usage = process.memoryUsage();
  console.log(`Heap used: ${(usage.heapUsed / 1024 / 1024).toFixed(2)} MB`);
  
  // 内存超过阈值时生成快照
  if (usage.heapUsed > 500 * 1024 * 1024) {
    takeHeapSnapshot();
  }
}, 10000);

const inspector = require('inspector');
const fs = require('fs');

async function takeHeapSnapshot() {
  const session = new inspector.Session();
  session.connect();
  
  return new Promise((resolve, reject) => {
    const chunks = [];
    
    session.on('HeapProfiler.addHeapSnapshotChunk', (m) => {
      chunks.push(m.params.chunk);
    });
    
    session.post('HeapProfiler.takeHeapSnapshot', null, (err, r) => {
      if (err) return reject(err);
      
      const snapshotPath = `heap-${Date.now()}.heapsnapshot`;
      fs.writeFileSync(snapshotPath, chunks.join(''));
      console.log(`Snapshot saved: ${snapshotPath}`);
      
      session.disconnect();
      resolve(snapshotPath);
    });
  });
}

// 生成多个快照进行对比
const snapshots = [];

async function compareMemory() {
  // 快照1：初始状态
  snapshots.push(await takeHeapSnapshot());
  
  // 执行操作
  runOperation();
  
  // 快照2：操作后状态
  snapshots.push(await takeHeapSnapshot());
  
  console.log('Compare snapshots in Chrome DevTools:');
  console.log(snapshots);
  // 在 DevTools 中选择 "Comparison" 视图
}

// 常见反优化原因
function problematic(obj) {
  // wrong map: 对象结构不一致
  return obj.x + obj.y;
}

problematic({ x: 1, y: 2 });
problematic({ y: 2, x: 1 });  // 属性顺序不同，不同的隐藏类

// not a Smi: 期望小整数，收到其他类型
function add(a, b) {
  return a + b;
}

add(1, 2);
add(1.5, 2.5);  // 浮点数触发反优化

// out of bounds: 数组越界
function getElement(arr, i) {
  return arr[i];
}

const arr = [1, 2, 3];
getElement(arr, 10);  // 越界访问

const { PerformanceObserver } = require('perf_hooks');

const gcStats = {
  scavenge: { count: 0, totalTime: 0 },
  markSweep: { count: 0, totalTime: 0 }
};

const obs = new PerformanceObserver((list) => {
  list.getEntries().forEach(entry => {
    const kind = entry.detail.kind;
    const stats = kind === 1 ? gcStats.scavenge : gcStats.markSweep;
    
    stats.count++;
    stats.totalTime += entry.duration;
  });
});

obs.observe({ entryTypes: ['gc'] });

// 定期报告
setInterval(() => {
  console.log('GC Stats:');
  console.log(`  Scavenge: ${gcStats.scavenge.count} times, ${gcStats.scavenge.totalTime.toFixed(2)}ms total`);
  console.log(`  Mark-Sweep: ${gcStats.markSweep.count} times, ${gcStats.markSweep.totalTime.toFixed(2)}ms total`);
}, 30000);

// 简单的性能监控
const monitor = {
  startTime: process.hrtime.bigint(),
  requests: 0,
  
  recordRequest(duration) {
    this.requests++;
    // 记录慢请求
    if (duration > 100) {
      console.warn(`Slow request: ${duration}ms`);
    }
  },
  
  report() {
    const uptime = Number(process.hrtime.bigint() - this.startTime) / 1e9;
    console.log(`Uptime: ${uptime.toFixed(2)}s, Requests: ${this.requests}`);
    console.log(`Memory: ${(process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2)}MB`);
  }
};

setInterval(() => monitor.report(), 10000);

// 在代码中添加计时
const { performance } = require('perf_hooks');

function measureSync(name, fn) {
  const start = performance.now();
  const result = fn();
  const duration = performance.now() - start;
  console.log(`${name}: ${duration.toFixed(2)}ms`);
  return result;
}

async function measureAsync(name, fn) {
  const start = performance.now();
  const result = await fn();
  const duration = performance.now() - start;
  console.log(`${name}: ${duration.toFixed(2)}ms`);
  return result;
}

// 使用
const data = measureSync('parseData', () => parseData(input));
const result = await measureAsync('queryDB', () => db.query(sql));

// 优化前后对比
const Benchmark = require('benchmark');

const suite = new Benchmark.Suite();

suite
  .add('原始实现', () => {
    originalFunction(testData);
  })
  .add('优化实现', () => {
    optimizedFunction(testData);
  })
  .on('cycle', (event) => {
    console.log(String(event.target));
  })
  .on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').map('name'));
  })
  .run({ async: true });