Node.js中首次调用函数为何更快？如何保证测试一致性？

测试场景与问题 #

在Node.js中对比自研牛顿法平方根实现NewtonSquareRoot与原生Math.sqrt()的执行效率，编写了以下性能测试函数：

function getDuration(func, argumentGenerator, multiplier = 1, argumentOffset = 0) {
    let args = []
    for (let i = 0; i < multiplier; i++)  {
        args.push(argumentGenerator(i + argumentOffset))
    }
    let result = []
    const start = performance.now()
    for (let i = 0; i < multiplier; i++)  {
        result.push(func(args[i]))
    }
    const end = performance.now()

    return {
        time: end - start,
        result: result,
    }
}

function measureTime(func, repeat = 1, argumentGenerator, multiplier = 1) {
    let result = []
    for (let i = 0; i < repeat; i++) {
        result.push(
            getDuration(func, argumentGenerator, multiplier, i * multiplier)
        );
    }
    return result
}

测试对象代码：

const indexArg = (i) => i * i + 1;

let functionsToTest = [
  [
    function BOTH(x) { 
      return Math.sqrt(x) - NewtonSquareRoot(x)
    }, 
    1e3, indexArg, 1e4
  ],
  [
    NewtonSquareRoot, 
    1e3, indexArg, 1e4
  ],
  [
    Math.sqrt, 
    1e3, indexArg, 1e4
  ],
];

let results = {}
for (const fArg of functionsToTest) {
  let result = measureTime(...fArg)
  results[fArg[0].name] = MMMM(result.map(x => x.time))
}

console.table(results);

测试中发现无论测试顺序如何调整，首个执行的函数耗时始终显著低于后续函数，例如：
首次测试顺序（BOTH → NewtonSquareRoot → sqrt）的结果：

┌──────────────────┬────────┬────────┬────────┬────────┐
│     (index)      │  min   │  max   │  mean  │ median │
├──────────────────┼────────┼────────┼────────┼────────┤
│       BOTH       │ 0.9142 │ 3.8853 │ 1.3225 │ 1.2812 │
│ NewtonSquareRoot │ 0.9435 │ 2.515  │ 1.6164 │ 1.6612 │
│       sqrt       │ 0.1026 │ 0.9474 │ 0.1225 │ 0.107  │
└──────────────────┴────────┴────────┴────────┴────────┘

调整顺序为（NewtonSquareRoot → sqrt → BOTH）后的结果：

┌──────────────────┬────────┬────────┬────────┬────────┐
│     (index)      │  min   │  max   │  mean  │ median │
├──────────────────┼────────┼────────┼────────┼────────┤
│ NewtonSquareRoot │ 0.8823 │ 3.3975 │ 1.2753 │ 1.2644 │
│       sqrt       │ 0.1025 │ 0.8317 │ 0.1325 │ 0.1067 │
│       BOTH       │ 1.1295 │ 2.443  │  1.55  │ 1.541  │
└──────────────────┴────────┴────────┴────────┴────────┘

尝试过用dummy函数预热，但方案不够优雅且需要足够重复次数，需要明确该现象的原因及更合理的解决方法。

现象原因分析 #

这个问题本质是Node.js底层V8引擎的运行机制与硬件缓存特性共同作用的结果，核心原因有两点：

1. V8引擎的冷启动与后台资源占用：
   Node.js进程启动后，V8处于冷状态，首次执行函数时仅触发基础编译/解释执行，无额外后台操作干扰；后续函数执行时，引擎可能在后台进行垃圾回收（GC）、或为之前的函数做优化编译，这些操作会占用CPU资源，导致耗时增加。
2. CPU缓存的预热与冲突：
   首个函数执行时，会将自身指令、处理数据加载到CPU的L1/L2缓存中；后续函数的指令和数据需要替换缓存内容，导致缓存命中率下降，额外增加内存访问开销，从而耗时变长。

解决办法 #

要让首个函数的测试结果与后续保持一致，需从预热环境和隔离干扰两方面入手：

1. 全局预热所有测试函数 #

在正式测试前，先调用所有待测试函数若干次，让V8完成函数编译、CPU缓存加载相关指令与数据，消除冷启动影响：

// 预热：每个函数执行少量次数，触发编译与缓存加载
functionsToTest.forEach(([func, _, argGen]) => {
  for (let i = 0; i < 100; i++) {
    func(argGen(i));
  }
});

// 手动触发GC（需启动Node时添加--expose-gc参数），清理预热产生的临时内存
if (typeof gc === 'function') {
  gc();
}

// 执行正式测试
let results = {}
for (const fArg of functionsToTest) {
  let result = measureTime(...fArg)
  results[fArg[0].name] = MMMM(result.map(x => x.time))
}

console.table(results);

2. 随机化测试顺序 #

多次测试时随机调整函数的测试顺序，取多轮结果的平均值，消除固定顺序带来的偏差：

// 随机打乱数组顺序
function shuffleArray(array) {
  for (let i = array.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [array[i], array[j]] = [array[j], array[i]];
  }
  return array;
}

// 重复多轮测试，每次打乱顺序
const testRounds = 5;
let allResults = {};

for (let round = 0; round < testRounds; round++) {
  const shuffledTests = shuffleArray([...functionsToTest]);
  let roundResults = {};
  for (const fArg of shuffledTests) {
    let result = measureTime(...fArg)
    roundResults[fArg[0].name] = MMMM(result.map(x => x.time))
  }
  // 合并多轮结果
  for (const name in roundResults) {
    if (!allResults[name]) allResults[name] = [];
    allResults[name].push(roundResults[name]);
  }
}

// 计算多轮结果的平均值
const finalResults = {};
for (const name in allResults) {
  finalResults[name] = {
    min: allResults[name].reduce((acc, curr) => Math.min(acc, curr.min), Infinity),
    max: allResults[name].reduce((acc, curr) => Math.max(acc, curr.max), -Infinity),
    mean: allResults[name].reduce((acc, curr) => acc + curr.mean, 0) / allResults[name].length,
    median: allResults[name].reduce((acc, curr) => acc + curr.median, 0) / allResults[name].length
  };
}

console.table(finalResults);

3. 隔离测试环境 #

每次测试前手动触发GC，清理上一个测试产生的临时对象，减少内存碎片与GC对当前测试的干扰（需启动Node时添加--expose-gc参数）：

let results = {}
for (const fArg of functionsToTest) {
  // 测试前触发GC，隔离内存环境
  if (typeof gc === 'function') {
    gc();
  }
  let result = measureTime(...fArg)
  results[fArg[0].name] = MMMM(result.map(x => x.time))
}

console.table(results);

总结 #

通过全局预热消除冷启动与缓存差异，结合随机化顺序和GC隔离，可以有效解决首个测试函数耗时偏低的问题，得到更准确、稳定的性能对比结果。

内容的提问来源于stack exchange，提问作者M M