feat: add tcmalloc support

crates/memtrack/src/allocators/dynamic.rs

@@ -1,51 +1,43 @@
 use crate::{AllocatorKind, AllocatorLib};
 use std::path::PathBuf;
 
-/// Returns the glob patterns used to find this allocator's shared libraries.
-fn get_allocator_paths(lib: &AllocatorKind) -> &'static [&'static str] {
-    match lib {
-        AllocatorKind::Libc => &[
-            // Debian, Ubuntu: Standard Linux multiarch paths
-            "/lib/*-linux-gnu/libc.so.6",
-            "/usr/lib/*-linux-gnu/libc.so.6",
+impl AllocatorKind {
+    /// Build glob patterns for finding this allocator's shared libraries.
+    fn search_patterns(&self) -> Vec<String> {
+        const LIB_DIRS: &[&str] = &[
+            // Debian, Ubuntu: multiarch paths
+            "/lib/*-linux-gnu",
+            "/usr/lib/*-linux-gnu",
             // RHEL, Fedora, CentOS, Arch
-            "/lib*/libc.so.6",
-            "/usr/lib*/libc.so.6",
-            // NixOS: find all glibc versions in the Nix store
-            "/nix/store/*glibc*/lib/libc.so.6",
-        ],
-        AllocatorKind::LibCpp => &[
-            // Standard Linux multiarch paths
-            "/lib/*-linux-gnu/libstdc++.so*",
-            "/usr/lib/*-linux-gnu/libstdc++.so*",
-            // RHEL, Fedora, CentOS, Arch
-            "/lib*/libstdc++.so*",
-            "/usr/lib*/libstdc++.so*",
-            // NixOS: find all gcc lib versions in the Nix store
-            "/nix/store/*gcc*/lib/libstdc++.so*",
-        ],
-        AllocatorKind::Jemalloc => &[
-            // Debian, Ubuntu: Standard Linux multiarch paths
-            "/lib/*-linux-gnu/libjemalloc.so*",
-            "/usr/lib/*-linux-gnu/libjemalloc.so*",
-            // RHEL, Fedora, CentOS, Arch
-            "/lib*/libjemalloc.so*",
-            "/usr/lib*/libjemalloc.so*",
-            "/usr/local/lib*/libjemalloc.so*",
-            // NixOS
-            "/nix/store/*jemalloc*/lib/libjemalloc.so*",
-        ],
-        AllocatorKind::Mimalloc => &[
-            // Debian, Ubuntu: Standard Linux multiarch paths
-            "/lib/*-linux-gnu/libmimalloc.so*",
-            "/usr/lib/*-linux-gnu/libmimalloc.so*",
-            // RHEL, Fedora, CentOS, Arch
-            "/lib*/libmimalloc.so*",
-            "/usr/lib*/libmimalloc.so*",
-            "/usr/local/lib*/libmimalloc.so*",
-            // NixOS
-            "/nix/store/*mimalloc*/lib/libmimalloc.so*",
-        ],
+            "/lib*",
+            "/usr/lib*",
+            // Local installs
+            "/usr/local/lib*",
+        ];
+
+        let (filenames, nix_hints): (&[&str], &[&str]) = match self {
+            AllocatorKind::Libc => (&["libc.so.6"], &["glibc"]),
+            AllocatorKind::LibCpp => (&["libstdc++.so*"], &["gcc"]),
+            AllocatorKind::Jemalloc => (&["libjemalloc.so*"], &["jemalloc"]),
+            AllocatorKind::Mimalloc => (&["libmimalloc.so*"], &["mimalloc"]),
+            AllocatorKind::Tcmalloc => (&["libtcmalloc*.so*"], &["tcmalloc", "gperftools"]),
+        };
+
+        let mut patterns = Vec::new();
+
+        for dir in LIB_DIRS {
+            for filename in filenames {
+                patterns.push(format!("{dir}/{filename}"));
+            }
+        }
+
+        for hint in nix_hints {
+            for filename in filenames {
+                patterns.push(format!("/nix/store/*{hint}*/lib/{filename}"));
+            }
+        }
+
+        patterns
     }
 }
 
@@ -57,10 +49,8 @@ pub fn find_all() -> anyhow::Result<Vec<AllocatorLib>> {
     let mut seen_paths: HashSet<PathBuf> = HashSet::new();
 
     for kind in AllocatorKind::all() {
-        let mut found_any = false;
-
-        for pattern in get_allocator_paths(kind) {
-            let paths = glob::glob(pattern)
+        for pattern in kind.search_patterns() {
+            let paths = glob::glob(&pattern)
                 .ok()
                 .into_iter()
                 .flatten()
@@ -77,15 +67,9 @@ pub fn find_all() -> anyhow::Result<Vec<AllocatorLib>> {
             for path in paths {
                 if seen_paths.insert(path.clone()) {
                     results.push(AllocatorLib { kind: *kind, path });
-                    found_any = true;
                 }
             }
         }
-
-        // FIXME: Do we still need this?
-        if kind.is_required() && !found_any {
-            anyhow::bail!("Could not find required allocator: {}", kind.name());
-        }
     }
 
     Ok(results)

crates/memtrack/src/allocators/mod.rs

@@ -19,8 +19,18 @@ pub enum AllocatorKind {
     Jemalloc,
     /// mimalloc - Microsoft's allocator
     Mimalloc,
+    /// TCMalloc - Google's thread-caching malloc
+    ///
+    /// Two variants exist:
+    /// - **gperftools** (github.com/gperftools/gperftools): Original ~2005 release.
+    ///   Exports both standard symbols (malloc/free) AND tc_* prefixed symbols.
+    /// - **google/tcmalloc** (github.com/google/tcmalloc): Modern ~2020 rewrite.
+    ///   Exports ONLY standard symbols (malloc/free/etc.) - no tc_* prefix.
+    ///
+    /// We'll always try to attach to both the standard and `tc_*` API. If the newer rewrite is
+    /// used, we'll only attach to the standard API.
+    Tcmalloc,
     // Future allocators:
-    // Tcmalloc,
     // Hoard,
     // Rpmalloc,
 }
@@ -33,6 +43,7 @@ impl AllocatorKind {
         &[
             AllocatorKind::Jemalloc,
             AllocatorKind::Mimalloc,
+            AllocatorKind::Tcmalloc,
             AllocatorKind::LibCpp,
             AllocatorKind::Libc,
         ]
@@ -45,21 +56,7 @@ impl AllocatorKind {
             AllocatorKind::LibCpp => "libc++",
             AllocatorKind::Jemalloc => "jemalloc",
             AllocatorKind::Mimalloc => "mimalloc",
-        }
-    }
-
-    /// Returns true if this allocator is required (must be found).
-    pub fn is_required(&self) -> bool {
-        matches!(self, AllocatorKind::Libc)
-    }
-
-    /// Returns the symbol names used to detect this allocator in binaries.
-    pub fn symbols(&self) -> &'static [&'static str] {
-        match self {
-            AllocatorKind::Libc => &["malloc", "free"],
-            AllocatorKind::LibCpp => &["_Znwm", "_Znam", "_ZdlPv", "_ZdaPv"],
-            AllocatorKind::Jemalloc => &["_rjem_malloc", "je_malloc", "je_malloc_default"],
-            AllocatorKind::Mimalloc => &["mi_malloc_aligned", "mi_malloc", "mi_free"],
+            AllocatorKind::Tcmalloc => "tcmalloc",
         }
     }
 }

crates/memtrack/src/allocators/static_linked.rs

@@ -4,6 +4,19 @@ use std::path::{Path, PathBuf};
 
 use crate::allocators::{AllocatorKind, AllocatorLib};
 
+impl AllocatorKind {
+    /// Returns the symbol names used to detect this allocator in binaries.
+    pub fn symbols(&self) -> &'static [&'static str] {
+        match self {
+            AllocatorKind::Libc => &["malloc", "free"],
+            AllocatorKind::LibCpp => &["_Znwm", "_Znam", "_ZdlPv", "_ZdaPv"],
+            AllocatorKind::Jemalloc => &["_rjem_malloc", "je_malloc", "je_malloc_default"],
+            AllocatorKind::Mimalloc => &["mi_malloc_aligned", "mi_malloc", "mi_free"],
+            AllocatorKind::Tcmalloc => &["tc_malloc", "tc_free", "tc_version"],
+        }
+    }
+}
+
 /// Walk upward and downward from current directory to find build directories.
 /// Returns all found build directories in order of preference.
 fn find_build_dirs() -> Vec<PathBuf> {

crates/memtrack/src/ebpf/memtrack.rs

@@ -282,15 +282,23 @@ impl MemtrackBpf {
                 self.attach_libcpp_probes(lib_path)
             }
             AllocatorKind::Jemalloc => {
-                // Try C++ operators (jemalloc exports these for C++ programs)
+                // Jemalloc exposes libc/libcpp compatible allocator functions:
+                let _ = self.attach_libc_probes(lib_path);
                 let _ = self.attach_libcpp_probes(lib_path);
                 self.attach_jemalloc_probes(lib_path)
             }
             AllocatorKind::Mimalloc => {
-                // Try C++ operators (mimalloc exports these for C++ programs)
+                // Mimalloc exposes libc/libcpp compatible allocator functions:
+                let _ = self.attach_libc_probes(lib_path);
                 let _ = self.attach_libcpp_probes(lib_path);
                 self.attach_mimalloc_probes(lib_path)
             }
+            AllocatorKind::Tcmalloc => {
+                // Tcmalloc exposes libc/libcpp compatible allocator functions:
+                let _ = self.attach_libc_probes(lib_path);
+                let _ = self.attach_libcpp_probes(lib_path);
+                self.attach_tcmalloc_probes(lib_path)
+            }
         }
     }
 
@@ -314,12 +322,17 @@ impl MemtrackBpf {
         for prefix in &prefixes_with_base {
             for suffix in &suffixes_with_base {
                 self.try_attach_malloc(lib_path, &format!("{prefix}malloc{suffix}"));
+                self.try_attach_malloc(lib_path, &format!("{prefix}valloc{suffix}"));
+                self.try_attach_malloc(lib_path, &format!("{prefix}pvalloc{suffix}"));
                 self.try_attach_calloc(lib_path, &format!("{prefix}calloc{suffix}"));
                 self.try_attach_realloc(lib_path, &format!("{prefix}realloc{suffix}"));
                 self.try_attach_aligned_alloc(lib_path, &format!("{prefix}aligned_alloc{suffix}"));
                 self.try_attach_memalign(lib_path, &format!("{prefix}memalign{suffix}"));
                 self.try_attach_memalign(lib_path, &format!("{prefix}posix_memalign{suffix}"));
                 self.try_attach_free(lib_path, &format!("{prefix}free{suffix}"));
+                self.try_attach_free(lib_path, &format!("{prefix}free_sized{suffix}"));
+                self.try_attach_free(lib_path, &format!("{prefix}free_aligned_sized{suffix}"));
+                self.try_attach_free(lib_path, &format!("{prefix}cfree{suffix}"));
             }
         }
 
@@ -400,6 +413,21 @@ impl MemtrackBpf {
 
         Ok(())
     }
+
+    /// Attach TCMalloc probes ( tc_* API).
+    ///
+    /// See:
+    /// - https://github.com/google/tcmalloc/blob/master/docs/reference.md
+    /// - https://github.com/gperftools/gperftools/blob/a47243150ec41097602730ff8779fafcc172d1fb/src/tcmalloc.cc#L178-L190
+    fn attach_tcmalloc_probes(&mut self, lib_path: &Path) -> Result<()> {
+        self.attach_standard_probes(lib_path, &["tc_"], &[])?;
+
+        self.try_attach_free(lib_path, "free_sized");
+        self.try_attach_free(lib_path, "free_aligned_sized");
+        self.try_attach_free(lib_path, "sdallocx");
+
+        Ok(())
+    }
     attach_tracepoint!(sched_fork);
 
     pub fn attach_tracepoints(&mut self) -> Result<()> {

crates/memtrack/testdata/alloc_cpp/CMakeLists.txt

@@ -50,6 +50,53 @@ if(NOT JEMALLOC_STATIC_LIB)
     message(STATUS "Static jemalloc not found, will fall back to dynamic linking")
 endif()
 
+# TCMalloc support via system gperftools package
+# gperftools provides libtcmalloc on most Linux distributions
+# (Ubuntu: libtcmalloc-minimal4, Fedora: gperftools-libs, NixOS: gperftools)
+find_package(Threads REQUIRED)
+
+# Search in common paths including NixOS store
+file(GLOB TCMALLOC_NIX_PATHS "/nix/store/*gperftools*/lib")
+
+# Find static library
+set(_old_suffixes ${CMAKE_FIND_LIBRARY_SUFFIXES})
+set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
+find_library(TCMALLOC_STATIC_LIB
+    NAMES libtcmalloc_minimal.a libtcmalloc.a tcmalloc_minimal tcmalloc
+    HINTS ${TCMALLOC_NIX_PATHS}
+    DOC "Static TCMalloc library (from gperftools)"
+)
+set(CMAKE_FIND_LIBRARY_SUFFIXES ${_old_suffixes})
+
+if(NOT TCMALLOC_STATIC_LIB)
+    message(STATUS "Static TCMalloc not found, will fall back to dynamic linking")
+endif()
+
+# Find dynamic library
+find_package(PkgConfig)
+if(PKG_CONFIG_FOUND)
+    pkg_check_modules(TCMALLOC QUIET libtcmalloc_minimal libtcmalloc)
+endif()
+
+if(NOT TCMALLOC_FOUND)
+    find_library(TCMALLOC_LIBRARY
+        NAMES tcmalloc_minimal tcmalloc
+        HINTS ${TCMALLOC_NIX_PATHS}
+        DOC "TCMalloc library (from gperftools)"
+    )
+    if(TCMALLOC_LIBRARY)
+        set(TCMALLOC_FOUND TRUE)
+        set(TCMALLOC_LIBRARIES ${TCMALLOC_LIBRARY})
+    endif()
+endif()
+
+if(TCMALLOC_FOUND OR TCMALLOC_STATIC_LIB)
+    message(STATUS "Found TCMalloc: static=${TCMALLOC_STATIC_LIB}, dynamic=${TCMALLOC_LIBRARIES}")
+    set(TCMALLOC_AVAILABLE ON)
+else()
+    message(STATUS "TCMalloc not found, tcmalloc test targets will not link correctly")
+endif()
+
 # Target: alloc_cpp_system
 set(alloc_cpp_system_SOURCES
 	cmake.toml
@@ -169,3 +216,67 @@ get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} D
 if(NOT CMKR_VS_STARTUP_PROJECT)
 	set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT alloc_cpp_mimalloc_dynamic)
 endif()
+
+# Target: alloc_cpp_tcmalloc_static
+set(alloc_cpp_tcmalloc_static_SOURCES
+	cmake.toml
+	"src/main.cpp"
+)
+
+add_executable(alloc_cpp_tcmalloc_static)
+
+target_sources(alloc_cpp_tcmalloc_static PRIVATE ${alloc_cpp_tcmalloc_static_SOURCES})
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${alloc_cpp_tcmalloc_static_SOURCES})
+
+target_compile_definitions(alloc_cpp_tcmalloc_static PRIVATE
+	USE_TCMALLOC=1
+)
+
+get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} DEFINITION VS_STARTUP_PROJECT)
+if(NOT CMKR_VS_STARTUP_PROJECT)
+	set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT alloc_cpp_tcmalloc_static)
+endif()
+
+set(CMKR_TARGET alloc_cpp_tcmalloc_static)
+if(TCMALLOC_STATIC_LIB)
+    # Use --whole-archive to ensure malloc override symbols are included
+    target_link_options(alloc_cpp_tcmalloc_static PRIVATE "LINKER:--whole-archive")
+    target_link_libraries(alloc_cpp_tcmalloc_static PRIVATE ${TCMALLOC_STATIC_LIB})
+    target_link_options(alloc_cpp_tcmalloc_static PRIVATE "LINKER:--no-whole-archive")
+    target_link_libraries(alloc_cpp_tcmalloc_static PRIVATE Threads::Threads)
+elseif(TCMALLOC_LIBRARIES)
+    # Fallback to dynamic linking
+    target_link_libraries(alloc_cpp_tcmalloc_static PRIVATE ${TCMALLOC_LIBRARIES})
+else()
+    message(WARNING "TCMalloc not found, alloc_cpp_tcmalloc_static will not link correctly")
+endif()
+
+# Target: alloc_cpp_tcmalloc_dynamic
+set(alloc_cpp_tcmalloc_dynamic_SOURCES
+	cmake.toml
+	"src/main.cpp"
+)
+
+add_executable(alloc_cpp_tcmalloc_dynamic)
+
+target_sources(alloc_cpp_tcmalloc_dynamic PRIVATE ${alloc_cpp_tcmalloc_dynamic_SOURCES})
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${alloc_cpp_tcmalloc_dynamic_SOURCES})
+
+target_compile_definitions(alloc_cpp_tcmalloc_dynamic PRIVATE
+	USE_TCMALLOC=1
+)
+
+get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} DEFINITION VS_STARTUP_PROJECT)
+if(NOT CMKR_VS_STARTUP_PROJECT)
+	set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT alloc_cpp_tcmalloc_dynamic)
+endif()
+
+set(CMKR_TARGET alloc_cpp_tcmalloc_dynamic)
+if(TCMALLOC_AVAILABLE)
+    target_link_libraries(alloc_cpp_tcmalloc_dynamic PRIVATE ${TCMALLOC_LIBRARIES})
+    if(TCMALLOC_INCLUDE_DIRS)
+        target_include_directories(alloc_cpp_tcmalloc_dynamic PRIVATE ${TCMALLOC_INCLUDE_DIRS})
+    endif()
+else()
+    message(WARNING "TCMalloc not found, alloc_cpp_tcmalloc_dynamic will not link correctly")
+endif()