heap profiling (53.0) not working with absl time lib (Linux)

[sifangli-labs]

Hi, I have tried the old and latest absl libs and the problem remains - here is the minimum code to reproduce the problem in our env:

#include <iostream>
#include "absl/time/time.h"

int main(int argc, char** argv) {
    std::cout << "====" << absl::UTCTimeZone() << std::endl; // <==============THIS LINE
    auto leaked = new int [100000];
    for (auto i = 0; i < 100000; ++i) {
        leaked[i] = i % 37;
    }
    std::cout << "************leaked output=" << leaked[0] + leaked [100000 - 1]  << std::endl;
    return 0;
}

Just comment out the marked out line, the generated trace show the leaks calling stack correctly - otherwise it shows:

root
ERROR MEMORY_INVALID (the leaked size seems to be correct but no symbols)
unknown

[LalitMaganti]

Hi, thanks for reporting this. We tried to reproduce the issue but were unable to on our setup (Linux x86_64, clang 19, kernel 6.17). We tested with:

• absl statically linked (debug build)
• absl statically linked with -O2 -fomit-frame-pointer
• absl as a shared library with -O2 -fomit-frame-pointer

In all cases, the heap profiler produced correct callstacks with no ERROR MEMORY_INVALID.

Here's what we used to reproduce — could you try the same steps and let us know where things diverge?

1. Build perfetto from source (if you haven't already):

git clone https://github.com/google/perfetto.git && cd perfetto
tools/install-build-deps
tools/setup_all_configs.py
tools/ninja -C out/linux_clang_release traced perfetto heapprofd_glibc_preload

2. Compile your repro binary (adjust to match your own build flags):

clang++ -std=c++17 -O2 -o repro repro.cc -labsl_time -labsl_strings -labsl_base -lpthread

3. Start traced:

out/linux_clang_release/traced &

4. Start the profiling session:

tools/heap_profile -i 1 -n repro --print-config | \
  out/linux_clang_release/perfetto -c - --txt -o /tmp/heap_trace

5. In another terminal, run your binary with the profiler:

LD_PRELOAD=out/linux_clang_release/libheapprofd_glibc_preload.so \
  PERFETTO_HEAPPROFD_BLOCKING_INIT=1 \
  ./repro

6. Ctrl-C the perfetto command, then inspect the trace:

out/linux_clang_release/trace_processor_shell /tmp/heap_trace -q /dev/stdin <<SQL
WITH RECURSIVE callstack(id, parent_id, depth, frame_id) AS (
  SELECT spc.id, spc.parent_id, spc.depth, spc.frame_id
  FROM heap_profile_allocation hpa
  JOIN stack_profile_callsite spc ON hpa.callsite_id = spc.id
  WHERE hpa.size > 0
  ORDER BY hpa.size DESC LIMIT 1
  UNION ALL
  SELECT spc.id, spc.parent_id, spc.depth, spc.frame_id
  FROM stack_profile_callsite spc
  JOIN callstack cs ON spc.id = cs.parent_id
)
SELECT cs.depth, hpf.name FROM callstack cs
JOIN stack_profile_frame hpf ON cs.frame_id = hpf.id
ORDER BY cs.depth DESC;
SQL

A few things that could help us narrow this down:

• What compiler and flags did you use to build your binary? (e.g. gcc vs clang, -O2, -fomit-frame-pointer, etc.)
• Is absl statically or dynamically linked? (ldd ./your_binary)
• Do unwind tables exist in your binary and absl library? (readelf -S ./your_binary | grep -i eh_frame — if this is empty, unwinding will fail)
• What distro/kernel/arch are you on?
• Are you using a custom allocator (jemalloc, tcmalloc, etc.)?

Thanks!