[TASK] Add real CPU/memory metrics to benchmarks

- Fix bar chart height to prevent overflow with changelog bar
- Install GNU time in Docker image for accurate metrics
- Run /usr/bin/time -v inside container (not outside)
- Capture wall time, CPU time, CPU%, and peak memory
- Update JSON output with extended metrics structure

Now reports actual PHP process metrics instead of estimates.
Example: 5.18s wall, 10.48s CPU (202%), 119.8MB memory

Author: CybotTM

Dockerfile

@@ -36,6 +36,8 @@ COPY --from=ghcr.io/php/pie:bin /pie /usr/bin/pie
 RUN apk add --update $PHPIZE_DEPS
 RUN pie install arnaud-lb/inotify && docker-php-ext-install pcntl
 
+# Install GNU time for benchmarking (busybox time doesn't support -v)
+RUN apk add --no-cache time
 RUN apk del $PHPIZE_DEPS && rm -rf /var/cache/apk/* /tmp/* /usr/share/php/* /usr/local/lib/php/doc/* /usr/local/lib/php/test/*
 
 COPY . /opt/guides

benchmark/benchmark-docker.sh

@@ -89,13 +89,14 @@ clean_caches() {
     rm -rf "$PROJECT_DIR/.cache" 2>/dev/null || true
 }
 
-# Run single benchmark using wall-clock timing
+# Run single benchmark with CPU and memory metrics via /usr/bin/time inside container
 # Pass "fresh" as second arg to force clean output directory
 run_benchmark_simple() {
     local run_num=$1
     local fresh_output="${2:-no}"
     local output_dir="/tmp/benchmark-output"
     local log_file="/tmp/benchmark-log-$run_num.txt"
+    local time_file="/tmp/benchmark-time-$run_num.txt"
 
     # Only clean output dir if fresh is requested (cold scenario)
     if [ "$fresh_output" = "fresh" ]; then
@@ -109,56 +110,52 @@ run_benchmark_simple() {
         config_arg="--config=$DOCS_INPUT"
     fi
 
-    # Run guides with wall-clock timing
-    local start_time end_time elapsed
-    start_time=$(date +%s.%N)
-
-    # Run container - mount full project at /project, output at /output
-    # Use relative paths for input and config
-    # Use --user to match host user for output permissions
+    # Run container with /usr/bin/time -v INSIDE the container for accurate metrics
     # Note: project mounted read-write so incremental rendering cache can be written
     # Mount shared /tmp for Twig cache persistence between warm runs
     local shared_tmp="/tmp/typo3-guides-benchmark-cache"
     mkdir -p "$shared_tmp"
+
+    # Run time inside container, output time stats to stderr which we capture
     docker run --rm \
         --user "$(id -u):$(id -g)" \
         -v "$PROJECT_DIR:/project" \
         -v "$output_dir:/output" \
         -v "$shared_tmp:/tmp" \
+        --entrypoint /usr/bin/time \
         "$IMAGE_TAG" \
-        --no-progress $config_arg --output=/output "$DOCS_INPUT" > "$log_file" 2>&1
+        -v php /opt/guides/vendor/bin/guides --no-progress $config_arg --output=/output "$DOCS_INPUT" \
+        > "$log_file" 2> "$time_file"
     local docker_exit=$?
 
-    end_time=$(date +%s.%N)
-    elapsed=$(echo "$end_time - $start_time" | bc)
+    # Parse /usr/bin/time output for metrics (GNU time format)
+    local elapsed user_time sys_time peak_memory_kb cpu_percent
+    elapsed=$(grep "Elapsed (wall clock)" "$time_file" | sed 's/.*: //' | awk -F: '{if (NF==3) print $1*3600+$2*60+$3; else if (NF==2) print $1*60+$2; else print $1}')
+    user_time=$(grep "User time" "$time_file" | awk '{print $NF}')
+    sys_time=$(grep "System time" "$time_file" | awk '{print $NF}')
+    peak_memory_kb=$(grep "Maximum resident set size" "$time_file" | awk '{print $NF}')
+    cpu_percent=$(grep "Percent of CPU" "$time_file" | sed 's/.*: //' | tr -d '%')
+
+    # Convert to MB and calculate totals
+    local peak_memory_mb cpu_time
+    peak_memory_mb=$(echo "scale=1; ${peak_memory_kb:-0} / 1024" | bc)
+    cpu_time=$(echo "scale=2; ${user_time:-0} + ${sys_time:-0}" | bc)
 
     # Count output files
     local file_count
     file_count=$(find "$output_dir" -name "*.html" 2>/dev/null | wc -l | tr -d ' ')
 
-    # Estimate memory from container (rough estimate based on output size)
-    local output_size_kb estimated_memory_mb
-    output_size_kb=$(du -sk "$output_dir" 2>/dev/null | awk '{print $1}')
-    output_size_kb=${output_size_kb:-0}
-    # Rough heuristic: memory is typically 50-100x output size for docs rendering
-    if [ "$output_size_kb" -gt 0 ]; then
-        estimated_memory_mb=$(echo "scale=0; ($output_size_kb * 60) / 1024" | bc)
-    else
-        estimated_memory_mb=64
-    fi
-    if [ "$estimated_memory_mb" -lt 50 ]; then
-        estimated_memory_mb=64  # minimum reasonable estimate
-    fi
-
-    # Output JSON result
-    echo "{\"total_time_seconds\": $elapsed, \"peak_memory_mb\": $estimated_memory_mb, \"files_rendered\": $file_count}"
+    # Output JSON result with extended metrics
+    echo "{\"total_time_seconds\": $elapsed, \"cpu_time_seconds\": $cpu_time, \"cpu_percent\": ${cpu_percent:-0}, \"peak_memory_mb\": $peak_memory_mb, \"files_rendered\": $file_count}"
 }
 
 # Run scenario and collect results
 run_scenario() {
     local scenario=$1
     local results=()
     local times=()
+    local cpu_times=()
+    local cpu_percents=()
     local memories=()
     local files=0
 
@@ -172,9 +169,11 @@ run_scenario() {
                 result=$(run_benchmark_simple $i fresh)
                 results+=("$result")
                 time_s=$(echo "$result" | jq -r '.total_time_seconds')
+                cpu_s=$(echo "$result" | jq -r '.cpu_time_seconds')
+                cpu_pct=$(echo "$result" | jq -r '.cpu_percent')
                 memory_mb=$(echo "$result" | jq -r '.peak_memory_mb')
                 files=$(echo "$result" | jq -r '.files_rendered')
-                log_success "    Time: ${time_s}s, Memory: ~${memory_mb}MB, Files: $files"
+                log_success "    Time: ${time_s}s, CPU: ${cpu_s}s (${cpu_pct}%), Memory: ${memory_mb}MB, Files: $files"
             done
             ;;
         warm)
@@ -188,9 +187,11 @@ run_scenario() {
                 result=$(run_benchmark_simple $i)  # Reuse existing cache
                 results+=("$result")
                 time_s=$(echo "$result" | jq -r '.total_time_seconds')
+                cpu_s=$(echo "$result" | jq -r '.cpu_time_seconds')
+                cpu_pct=$(echo "$result" | jq -r '.cpu_percent')
                 memory_mb=$(echo "$result" | jq -r '.peak_memory_mb')
                 files=$(echo "$result" | jq -r '.files_rendered')
-                log_success "    Time: ${time_s}s, Memory: ~${memory_mb}MB, Files: $files"
+                log_success "    Time: ${time_s}s, CPU: ${cpu_s}s (${cpu_pct}%), Memory: ${memory_mb}MB, Files: $files"
             done
             ;;
         partial)
@@ -211,35 +212,46 @@ run_scenario() {
                 result=$(run_benchmark_simple $i)  # Reuse existing cache
                 results+=("$result")
                 time_s=$(echo "$result" | jq -r '.total_time_seconds')
+                cpu_s=$(echo "$result" | jq -r '.cpu_time_seconds')
+                cpu_pct=$(echo "$result" | jq -r '.cpu_percent')
                 memory_mb=$(echo "$result" | jq -r '.peak_memory_mb')
                 files=$(echo "$result" | jq -r '.files_rendered')
-                log_success "    Time: ${time_s}s, Memory: ~${memory_mb}MB, Files: $files"
+                log_success "    Time: ${time_s}s, CPU: ${cpu_s}s (${cpu_pct}%), Memory: ${memory_mb}MB, Files: $files"
             done
             ;;
     esac
 
     # Extract values for aggregation
     for result in "${results[@]}"; do
         times+=($(echo "$result" | jq -r '.total_time_seconds'))
+        cpu_times+=($(echo "$result" | jq -r '.cpu_time_seconds'))
+        cpu_percents+=($(echo "$result" | jq -r '.cpu_percent'))
         memories+=($(echo "$result" | jq -r '.peak_memory_mb'))
     done
 
     # Calculate aggregates
-    local time_sum=0 mem_sum=0
+    local time_sum=0 cpu_sum=0 cpu_pct_sum=0 mem_sum=0
     local time_min=${times[0]} time_max=${times[0]}
+    local cpu_min=${cpu_times[0]} cpu_max=${cpu_times[0]}
     local mem_min=${memories[0]} mem_max=${memories[0]}
 
     for i in "${!times[@]}"; do
         time_sum=$(echo "$time_sum + ${times[$i]}" | bc)
+        cpu_sum=$(echo "$cpu_sum + ${cpu_times[$i]}" | bc)
+        cpu_pct_sum=$(echo "$cpu_pct_sum + ${cpu_percents[$i]}" | bc)
         mem_sum=$(echo "$mem_sum + ${memories[$i]}" | bc)
 
         if (( $(echo "${times[$i]} < $time_min" | bc -l) )); then time_min=${times[$i]}; fi
         if (( $(echo "${times[$i]} > $time_max" | bc -l) )); then time_max=${times[$i]}; fi
+        if (( $(echo "${cpu_times[$i]} < $cpu_min" | bc -l) )); then cpu_min=${cpu_times[$i]}; fi
+        if (( $(echo "${cpu_times[$i]} > $cpu_max" | bc -l) )); then cpu_max=${cpu_times[$i]}; fi
         if (( $(echo "${memories[$i]} < $mem_min" | bc -l) )); then mem_min=${memories[$i]}; fi
         if (( $(echo "${memories[$i]} > $mem_max" | bc -l) )); then mem_max=${memories[$i]}; fi
     done
 
     local time_avg=$(echo "scale=3; $time_sum / ${#times[@]}" | bc)
+    local cpu_avg=$(echo "scale=2; $cpu_sum / ${#cpu_times[@]}" | bc)
+    local cpu_pct_avg=$(echo "scale=0; $cpu_pct_sum / ${#cpu_percents[@]}" | bc)
     local mem_avg=$(echo "scale=1; $mem_sum / ${#memories[@]}" | bc)
 
     # Save to JSON
@@ -255,19 +267,27 @@ run_scenario() {
     "timestamp": "$TIMESTAMP",
     "runs": $RUNS,
     "metrics": {
-        "time": {
+        "wall_time": {
             "avg_seconds": $time_avg,
             "min_seconds": $time_min,
             "max_seconds": $time_max
         },
+        "cpu_time": {
+            "avg_seconds": $cpu_avg,
+            "min_seconds": $cpu_min,
+            "max_seconds": $cpu_max,
+            "avg_percent": $cpu_pct_avg
+        },
         "memory": {
             "avg_mb": $mem_avg,
             "min_mb": $mem_min,
             "max_mb": $mem_max
         },
         "files_rendered": $files
     },
-    "raw_times_seconds": [$(IFS=,; echo "${times[*]}")],
+    "raw_wall_times_seconds": [$(IFS=,; echo "${times[*]}")],
+    "raw_cpu_times_seconds": [$(IFS=,; echo "${cpu_times[*]}")],
+    "raw_cpu_percents": [$(IFS=,; echo "${cpu_percents[*]}")],
     "raw_memories_mb": [$(IFS=,; echo "${memories[*]}")]
 }
 EOF
@@ -277,8 +297,9 @@ EOF
     # Print summary
     echo ""
     echo "=== $scenario Summary ==="
-    echo "  Avg Time:   ${time_avg}s (min: ${time_min}s, max: ${time_max}s)"
-    echo "  Avg Memory: ~${mem_avg}MB (estimated)"
+    echo "  Wall Time:  ${time_avg}s (min: ${time_min}s, max: ${time_max}s)"
+    echo "  CPU Time:   ${cpu_avg}s (~${cpu_pct_avg}% utilization)"
+    echo "  Memory:     ${mem_avg}MB peak"
     echo "  Files:      $files"
     echo ""
 }

docs/index.html

@@ -294,9 +294,9 @@
         .bar-chart {
             display: flex;
             align-items: flex-end;
-            height: 200px;
+            height: 280px;
             gap: 2rem;
-            padding: 1rem 0;
+            padding: 2rem 0 1rem 0;
         }
 
         .bar-group {