next.js / scripts /benchmark-boot-time.sh

Upload folder using huggingface_hub

b91e262 verified 3 months ago

6 kB

	#!/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