File size: 5,997 Bytes

b91e262

#!/bin/bash
#
# Benchmark dev server boot time (wall-clock)
#
# Measures TWO metrics:
#   1. listen_time: When server starts accepting TCP connections
#   2. ready_time: When server responds to first HTTP request
#
# The delta between these shows how much initialization is deferred after "Ready".
#
# Usage:
#   ./scripts/benchmark-boot-time.sh [runs] [test-dir]
#
# Examples:
#   ./scripts/benchmark-boot-time.sh           # 5 runs, uses /tmp/next-boot-test
#   ./scripts/benchmark-boot-time.sh 3         # 3 runs
#   ./scripts/benchmark-boot-time.sh 5 ./my-app  # 5 runs on existing app

set -e

RUNS=${1:-5}
TEST_DIR=${2:-/tmp/next-boot-test}
NEXT_BIN="$(dirname "$0")/../packages/next/dist/bin/next"
PORT=3456

echo "=== Dev Server Boot Time Benchmark ==="
echo "Runs: $RUNS"
echo "Test dir: $TEST_DIR"
echo "Next.js: $NEXT_BIN"
echo ""
echo "Metrics:"
echo "  listen_time: TCP port accepting connections"
echo "  ready_time:  First HTTP request succeeds"
echo "  delta:       ready_time - listen_time (deferred init)"
echo ""

# Create test app if it doesn't exist
if [ ! -f "$TEST_DIR/package.json" ]; then
  echo "Creating test app..."
  mkdir -p "$TEST_DIR/app"
  cat > "$TEST_DIR/package.json" << 'EOF'
{
  "name": "boot-test",
  "private": true,
  "dependencies": {
    "react": "19.0.0",
    "react-dom": "19.0.0"
  }
}
EOF
  cat > "$TEST_DIR/app/layout.tsx" << 'EOF'
export default function RootLayout({ children }: { children: React.ReactNode }) {
  return <html><body>{children}</body></html>
}
EOF
  cat > "$TEST_DIR/app/page.tsx" << 'EOF'
export default function Home() { return <h1>Hello</h1> }
EOF
  (cd "$TEST_DIR" && npm install --silent)
  # Link local next
  (cd "$TEST_DIR" && npm link "$(dirname "$NEXT_BIN")/.." 2>/dev/null || true)
fi

# Kill any existing next dev on our port
pkill -f "next dev.*$PORT" 2>/dev/null || true
sleep 0.5

# Returns: listen_time,ready_time (comma-separated)
benchmark_run() {
  local label=$1
  local clean_next=$2

  if [ "$clean_next" = "true" ]; then
    rm -rf "$TEST_DIR/.next"
  fi

  # Measure wall-clock time from command start
  local start_time=$(python3 -c 'import time; print(int(time.time() * 1000))')

  "$NEXT_BIN" dev --turbopack --port $PORT "$TEST_DIR" > /dev/null 2>&1 &
  local pid=$!

  local timeout=600  # 30s at 50ms intervals
  local listen_time=""
  local ready_time=""

  # Phase 1: Wait for port to be listening (nc -z)
  for i in $(seq 1 $timeout); do
    if nc -z localhost $PORT 2>/dev/null; then
      listen_time=$(python3 -c 'import time; print(int(time.time() * 1000))')
      break
    fi
    sleep 0.05
  done

  # Phase 2: Wait for HTTP response (curl)
  if [ -n "$listen_time" ]; then
    for i in $(seq 1 $timeout); do
      if curl -s "http://localhost:$PORT" > /dev/null 2>&1; then
        ready_time=$(python3 -c 'import time; print(int(time.time() * 1000))')
        break
      fi
      sleep 0.05
    done
  fi

  # Kill the server
  kill $pid 2>/dev/null || true
  wait $pid 2>/dev/null || true

  if [ -n "$listen_time" ] && [ -n "$ready_time" ]; then
    local listen_delta=$((listen_time - start_time))
    local ready_delta=$((ready_time - start_time))
    echo "$listen_delta,$ready_delta"
  else
    echo "TIMEOUT,TIMEOUT"
  fi
}

run_benchmark_series() {
  local series_name=$1
  local clean_next=$2

  echo "--- $series_name ---"
  echo "Run | Listen | Ready | Delta"
  echo "----|--------|-------|------"

  local listen_times=""
  local ready_times=""
  local deltas=""

  for i in $(seq 1 $RUNS); do
    RESULT=$(benchmark_run "$series_name-$i" "$clean_next")
    LISTEN=$(echo "$RESULT" | cut -d',' -f1)
    READY=$(echo "$RESULT" | cut -d',' -f2)

    if [ "$LISTEN" != "TIMEOUT" ] && [ "$READY" != "TIMEOUT" ]; then
      DELTA=$((READY - LISTEN))
      printf "%3d | %5dms | %5dms | %5dms\n" "$i" "$LISTEN" "$READY" "$DELTA"
      listen_times="$listen_times $LISTEN"
      ready_times="$ready_times $READY"
      deltas="$deltas $DELTA"
    else
      printf "%3d | TIMEOUT | TIMEOUT | -\n" "$i"
    fi
  done

  # Calculate averages
  local listen_avg=$(echo $listen_times | tr ' ' '\n' | grep -v '^$' | awk '{sum+=$1; count++} END {if(count>0) printf "%.0f", sum/count; else print "N/A"}')
  local ready_avg=$(echo $ready_times | tr ' ' '\n' | grep -v '^$' | awk '{sum+=$1; count++} END {if(count>0) printf "%.0f", sum/count; else print "N/A"}')
  local delta_avg=$(echo $deltas | tr ' ' '\n' | grep -v '^$' | awk '{sum+=$1; count++} END {if(count>0) printf "%.0f", sum/count; else print "N/A"}')

  echo ""
  echo "Average: listen=${listen_avg}ms, ready=${ready_avg}ms, delta=${delta_avg}ms"
  echo ""

  # Export for summary
  export "${series_name}_LISTEN_AVG=$listen_avg"
  export "${series_name}_READY_AVG=$ready_avg"
  export "${series_name}_DELTA_AVG=$delta_avg"
}

# Run cold start benchmarks
run_benchmark_series "COLD" true

# Warmup for bytecode cache
echo "--- Warming up bytecode cache (12s) ---"
"$NEXT_BIN" dev --turbopack --port $PORT "$TEST_DIR" > /dev/null 2>&1 &
WARMUP_PID=$!
for i in $(seq 1 200); do
  if curl -s "http://localhost:$PORT" > /dev/null 2>&1; then
    break
  fi
  sleep 0.05
done
sleep 12
kill $WARMUP_PID 2>/dev/null || true
wait $WARMUP_PID 2>/dev/null || true
echo ""

# Run warm start benchmarks
run_benchmark_series "WARM" false

# Summary
echo "=============================================="
echo "                  SUMMARY"
echo "=============================================="
echo ""
echo "Cold Start ($RUNS runs):"
echo "  Port listening: ${COLD_LISTEN_AVG}ms"
echo "  First request:  ${COLD_READY_AVG}ms"
echo "  Deferred init:  ${COLD_DELTA_AVG}ms"
echo ""
echo "Warm Start ($RUNS runs):"
echo "  Port listening: ${WARM_LISTEN_AVG}ms"
echo "  First request:  ${WARM_READY_AVG}ms"
echo "  Deferred init:  ${WARM_DELTA_AVG}ms"
echo ""

if [ "$COLD_READY_AVG" != "N/A" ] && [ "$WARM_READY_AVG" != "N/A" ]; then
  CACHE_BENEFIT=$((COLD_READY_AVG - WARM_READY_AVG))
  echo "Cache benefit: ${CACHE_BENEFIT}ms (cold - warm ready)"
fi