Node.js와 Deno의 벤치마킹: 종합적인 비교-JS 튜토리얼-php.cn

계속 진화하는 JavaScript 런타임 환경에서 Node.js와 Deno는 서버측 애플리케이션 구축을 위한 강력한 플랫폼으로 두각을 나타내고 있습니다. 두 가지 모두 유사점을 공유하지만 성능 측정 및 벤치마킹에 대한 접근 방식은 크게 다릅니다. 이 두 런타임의 벤치마킹 기능에 대해 자세히 살펴보겠습니다.

벤치마킹의 필요성

성능이 중요합니다. 트래픽이 많은 웹 서비스, 복잡한 백엔드 애플리케이션을 구축하거나 코드의 한계를 탐색하는 경우 다양한 구현이 어떻게 수행되는지 이해하는 것이 중요합니다. 벤치마킹은 개발자에게 다음과 같은 도움을 줍니다.

성능 병목 현상 식별
다양한 구현 전략 비교
정보를 바탕으로 건축 결정을 내리세요
중요 코드 경로 최적화

Node.js: 맞춤형 벤치마킹 솔루션

Node.js에는 개발자가 맞춤형 솔루션을 만들 수 있게 해주는 벤치마킹 프레임워크가 내장되어 있지 않습니다. 제공된 예는 벤치마킹에 대한 정교한 접근 방식을 보여줍니다.

bench.js

class Benchmark {
  constructor(name, fn, options = {}) {
    this.name = name;
    this.fn = fn;
    this.options = options;
    this.results = [];
  }

  async run() {
    const { async = false, iterations = 1000 } = this.options;
    const results = [];

    // Warmup
    for (let i = 0; i < 10; i++) {
      async ? await this.fn() : this.fn();
    }

    // Main benchmark
    for (let i = 0; i < iterations; i++) {
      const start = process.hrtime.bigint();
      async ? await this.fn() : this.fn();
      const end = process.hrtime.bigint();
      results.push(Number(end - start)); // Nanoseconds
    }

    // Sort results to calculate metrics
    results.sort((a, b) => a - b);
    this.results = {
      avg: results.reduce((sum, time) => sum + time, 0) / iterations,
      min: results[0],
      max: results[results.length - 1],
      p75: results[Math.ceil(iterations * 0.75) - 1],
      p99: results[Math.ceil(iterations * 0.99) - 1],
      p995: results[Math.ceil(iterations * 0.995) - 1],
      iterPerSec: Math.round(
        1e9 / (results.reduce((sum, time) => sum + time, 0) / iterations)
      ),
    };
  }

  getReportObject() {
    const { avg, min, max, p75, p99, p995, iterPerSec } = this.results;
    return {
      Benchmark: this.name,
      "time/iter (avg)": `${(avg / 1e3).toFixed(1)} ns`,
      "iter/s": iterPerSec,
      "(min … max)": `${(min / 1e3).toFixed(1)} ns … ${(max / 1e3).toFixed(
        1
      )} ns`,
      p75: `${(p75 / 1e3).toFixed(1)} ns`,
      p99: `${(p99 / 1e3).toFixed(1)} ns`,
      p995: `${(p995 / 1e3).toFixed(1)} ns`,
    };
  }
}

class BenchmarkSuite {
  constructor() {
    this.benchmarks = [];
  }

  add(name, fn, options = {}) {
    const benchmark = new Benchmark(name, fn, options);
    this.benchmarks.push(benchmark);
  }

  async run() {
    const reports = [];

    for (const benchmark of this.benchmarks) {
      await benchmark.run();
      reports.push(benchmark.getReportObject());
    }

    console.log(`\nBenchmark Results:\n`);
    console.table(reports);

    // Optionally, add summaries for grouped benchmarks
    this.printSummary();
  }

  printSummary() {
    const groups = this.benchmarks.reduce((acc, benchmark) => {
      const group = benchmark.options.group;
      if (group) {
        if (!acc[group]) acc[group] = [];
        acc[group].push(benchmark);
      }
      return acc;
    }, {});

    for (const [group, benchmarks] of Object.entries(groups)) {
      console.log(`\nGroup Summary: ${group}`);
      const baseline = benchmarks.find((b) => b.options.baseline);
      if (baseline) {
        for (const benchmark of benchmarks) {
          if (benchmark !== baseline) {
            const factor = (
              baseline.results.avg / benchmark.results.avg
            ).toFixed(2);
            console.log(
              `  ${baseline.name} is ${factor}x faster than ${benchmark.name}`
            );
          }
        }
      }
    }
  }
}

const suite = new BenchmarkSuite();

// Add benchmarks
suite.add("URL parsing", () => new URL("https://nodejs.org"));
suite.add(
  "Async method",
  async () => await crypto.subtle.digest("SHA-256", new Uint8Array([1, 2, 3])),
  { async: true }
);
suite.add("Long form", () => new URL("https://nodejs.org"));
suite.add("Date.now()", () => Date.now(), { group: "timing", baseline: true });
suite.add("performance.now()", () => performance.now(), { group: "timing" });

// Run benchmarks
suite.run();

로그인 후 복사

node bench.js

로그인 후 복사

Benchmarking in Node.js vs Deno: A Comprehensive Comparison

Node.js 벤치마킹 접근 방식의 주요 특징:

완전한 맞춤형 구현
자세한 성과 지표
동기화 및 비동기화 기능 모두 지원
초기 성능 변화를 완화하기 위한 준비 단계
종합적인 통계 분석(평균, 최소, 최대, 백분위수)
그룹 기반 비교
수동 반복 및 결과 수집

Deno: 내장된 벤치마킹

Deno는 내장된 Deno.bench() 메서드를 사용하여 다른 접근 방식을 취합니다.

bench.ts

Deno.bench("URL parsing", () => {
  new URL("https://deno.land");
});
Deno.bench("Async method", async () => {
  await crypto.subtle.digest("SHA-256", new Uint8Array([1, 2, 3]));
});
Deno.bench({
  name: "Long form",
  fn: () => {
    new URL("https://deno.land");
  },
});
Deno.bench({
  name: "Date.now()",
  group: "timing",
  baseline: true,
  fn: () => {
    Date.now();
  },
});

Deno.bench({
  name: "performance.now()",
  group: "timing",
  fn: () => {
    performance.now();
  },
});

로그인 후 복사