Much faster memleak_translate.sh (#4604)

## Motivation

The current version of the script uses `addr2line`, which is incredibly
slow.

## Proposal

Use `llvm-symbolizer` instead, which is much faster, and cache the
translations so we don't translate the same address twice.

## Test Plan

Tested this while debugging the GoL backend memory leak, and it's way
way faster

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

Author: ndr-ds

scripts/memleak_translate.sh

@@ -2,42 +2,125 @@
 
 # memleak_translate.sh <PID>
 #
-# Works with the default `memleak-libbpf`/`memleak` output that looks like
+# IMPORTANT: This script is for FILE PROCESSING ONLY - NOT for real-time translation.
+# It reads the ENTIRE input into memory first, then translates all addresses
+# in a single batch for maximum performance.
+#
+# Usage:
+#   1. Save memleak output to a file: memleak -p <PID> > memleak_output.txt
+#   2. Translate the file: cat memleak_output.txt | ./memleak_translate.sh <PID>
+#
+# Works with the default `memleak-libbpf`/`memleak` output that looks like:
 #   0 [<0000aaaaeac54784>] [/linera-server]
-# and replaces the address line with the addr2line translated result, which should be the function
-# name, file name and line number.
 #
-# add2line takes a while to execute, so it is recommended to run `memleak` for a while, while
-# redirecting the output to a file. Then inspect the file for what you want (maybe only the last
-# few lines of the output), and then run this script while the binary is still running, from within
-# the same container.
+# Requires llvm-symbolizer to be installed. Makes exactly ONE call to
+# llvm-symbolizer for ALL unique addresses.
 
 set -euo pipefail
 
 [[ $# -eq 1 ]] || { echo "usage: $0 <pid>" >&2; exit 1; }
 
+# Check that llvm-symbolizer is available
+if ! command -v llvm-symbolizer &> /dev/null; then
+    echo "Error: llvm-symbolizer not found. Please install it first." >&2
+    echo "  Ubuntu/Debian: apt-get install llvm" >&2
+    echo "  macOS: brew install llvm" >&2
+    exit 1
+fi
+
 PID=$1
 exe="/proc/$PID/exe"
 
 BASE=$(awk -v bin="$(readlink -f /proc/$PID/exe)" '$NF==bin { split($1,a,"-"); print "0x"a[1]; exit }' /proc/$PID/maps)
 
 [[ -n $BASE ]] || { echo "could not find base address for $exe" >&2; exit 1; }
 
-# helper: translate <$addr> using addr2line, compensating for PIE base
-translate () {
-    local addr=$1
-    addr=${addr//[<>[\]]}
-    [[ $addr != 0x* ]] && addr="0x${addr}"
-    local rel=$(printf "0x%x" $(( addr - BASE )))
-    addr2line -e "$exe" -f -C -p "$rel" 2>/dev/null || echo "$addr"
-}
+# Read entire input into array
+mapfile -t LINES
+
+# Extract all unique addresses
+declare -A UNIQUE_ADDRS
+declare -a ADDR_ORDER
+
+for line in "${LINES[@]}"; do
+    if [[ $line =~ \[\<([0-9a-fA-F]+)\>\] ]]; then
+        addr="${BASH_REMATCH[1]}"
+        [[ $addr != 0x* ]] && addr="0x${addr}"
+        if [[ -z "${UNIQUE_ADDRS[$addr]:-}" ]]; then
+            UNIQUE_ADDRS[$addr]=1
+            ADDR_ORDER+=("$addr")
+        fi
+    fi
+done
+
+# If no addresses found, just output the original lines
+if [[ ${#ADDR_ORDER[@]} -eq 0 ]]; then
+    printf "%s\n" "${LINES[@]}"
+    exit 0
+fi
+
+# Convert all addresses to relative offsets
+declare -a REL_ADDRS
+for addr in "${ADDR_ORDER[@]}"; do
+    rel=$(printf "0x%x" $(( addr - BASE )))
+    REL_ADDRS+=("$rel")
+done
+
+# Translate ALL addresses in ONE llvm-symbolizer call
+declare -A TRANSLATIONS
+
+# Run llvm-symbolizer
+if ! SYMBOLS=$(printf "%s\n" "${REL_ADDRS[@]}" | llvm-symbolizer -e "$exe" --demangle --functions=linkage --inlining=false 2>&1); then
+    echo "Error: llvm-symbolizer failed to run" >&2
+    echo "$SYMBOLS" >&2
+    exit 1
+fi
+
+# Parse output - llvm-symbolizer outputs exactly 3 lines per address:
+# Line 1: function name, Line 2: file path and line, Line 3: empty line
+readarray -t SYMBOL_LINES <<< "$SYMBOLS"
+
+for ((i=0; i<${#ADDR_ORDER[@]}; i++)); do
+    addr="${ADDR_ORDER[$i]}"
+    line_base=$((i * 3))
+
+    if [[ $line_base -lt ${#SYMBOL_LINES[@]} ]]; then
+        func_line="${SYMBOL_LINES[$line_base]}"
+    else
+        func_line=""
+    fi
+
+    if [[ $((line_base + 1)) -lt ${#SYMBOL_LINES[@]} ]]; then
+        loc_line="${SYMBOL_LINES[$((line_base + 1))]}"
+    else
+        loc_line=""
+    fi
+
+    translation="${func_line} ${loc_line}"
+    translation=$(echo "$translation" | sed 's/  */ /g' | sed 's/ $//')
+
+    if [[ -z "$translation" || "$translation" =~ ^"?? " ]]; then
+        translation="$addr"
+    fi
+
+    TRANSLATIONS[$addr]="$translation"
+done
+
+# Ensure all addresses have translations
+for addr in "${ADDR_ORDER[@]}"; do
+    if [[ -z "${TRANSLATIONS[$addr]:-}" ]]; then
+        TRANSLATIONS[$addr]="$addr"
+    fi
+done
 
-while IFS= read -r line; do
+# Output all lines with translations applied
+for line in "${LINES[@]}"; do
     if [[ $line =~ ([0-9]+)\ \[\<([0-9a-fA-F]+)\>\]\ \[([^]]+)\] ]]; then
         stack_pos="${BASH_REMATCH[1]}"
         addr="${BASH_REMATCH[2]}"
         origin="${BASH_REMATCH[3]}"
-        echo "        $stack_pos $(translate "$addr") [$origin]"
+        [[ $addr != 0x* ]] && addr="0x${addr}"
+        echo "        $stack_pos ${TRANSLATIONS[$addr]} [$origin]"
     else
         echo "$line"
     fi