[Refactor] Remove tcmalloc (StarRocks#27130)

Signed-off-by: trueeyu <[email protected]>

Author: trueeyu

be/CMakeLists.txt

@@ -808,16 +808,10 @@ set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS}
     -static-libgcc
 )
 
-# Add sanitize static link flags or tcmalloc
+# Add sanitize static link flags or jemalloc
 if ("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG" OR "${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
-    if (USE_JEMALLOC)
-        message("use jemalloc")
-        add_definitions(-DUSE_JEMALLOC)
-        set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} jemalloc)
-    else()
-        message("use tcmalloc")
-        set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} tcmalloc)
-    endif()
+    message("use jemalloc")
+    set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} jemalloc)
 elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "ASAN")
     if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
         set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-libsan)
@@ -827,14 +821,8 @@ elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "ASAN")
 elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "LSAN")
     set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-liblsan)
 elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN")
-    if (USE_JEMALLOC)
-        message("use jemalloc")
-        add_definitions(-DUSE_JEMALLOC)
-        set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-libubsan jemalloc)
-    else()
-        message("use tcmalloc")
-        set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-libubsan tcmalloc)
-    endif()
+    message("use jemalloc")
+    set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-libubsan jemalloc)
 elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "TSAN")
     set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-libtsan)
 else()

be/src/common/config.h

@@ -55,16 +55,6 @@ CONF_Int32(brpc_num_threads, "-1");
 // If no ip match this rule, will choose one randomly.
 CONF_String(priority_networks, "");
 
-////
-//// tcmalloc gc parameter
-////
-// Min memory for TCmalloc, when used memory is smaller than this, do not returned to OS.
-CONF_mInt64(tc_use_memory_min, "0");
-// free memory rate.[0-100]
-CONF_mInt64(tc_free_memory_rate, "0");
-// tcmalloc gc period, default 60, it should be between [1, 180]
-CONF_mInt64(tc_gc_period, "60");
-
 CONF_mBool(enable_auto_adjust_pagecache, "true");
 // Memory urget water level, if the memory usage exceeds this level, reduce the size of
 // the Pagecache immediately, it should be between (memory_high_level, 100].
@@ -77,17 +67,6 @@ CONF_mInt64(pagecache_adjust_period, "20");
 // Sleep time in seconds between pagecache adjust iterations.
 CONF_mInt64(auto_adjust_pagecache_interval_seconds, "10");
 
-// Bound on the total amount of bytes allocated to thread caches.
-// This bound is not strict, so it is possible for the cache to go over this bound
-// in certain circumstances. The maximum value of this flag is capped to 1GB.
-// This value defaults to 1GB.
-// If you suspect your application is not scaling to many threads due to lock contention in TCMalloc,
-// you can try increasing this value. This may improve performance, at a cost of extra memory
-// use by TCMalloc.
-// reference: https://gperftools.github.io/gperftools/tcmalloc.html: TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES
-//            https://github.com/gperftools/gperftools/issues/1111
-CONF_Int64(tc_max_total_thread_cache_bytes, "1073741824");
-
 // process memory limit specified as number of bytes
 // ('<int>[bB]?'), megabytes ('<float>[mM]'), gigabytes ('<float>[gG]'),
 // or percentage of the physical memory ('<int>%').

be/src/common/daemon.cpp

@@ -35,18 +35,14 @@
 #include "common/daemon.h"
 
 #include <gflags/gflags.h>
-#ifdef USE_JEMALLOC
-#include "jemalloc/jemalloc.h"
-#else
-#include <gperftools/malloc_extension.h>
-#endif
 
 #include "column/column_helper.h"
 #include "column/column_pool.h"
 #include "common/config.h"
 #include "common/minidump.h"
 #include "exec/workgroup/work_group.h"
 #include "gutil/cpu.h"
+#include "jemalloc/jemalloc.h"
 #include "runtime/memory/mem_chunk_allocator.h"
 #include "runtime/time_types.h"
 #include "runtime/user_function_cache.h"
@@ -101,44 +97,14 @@ class ReleaseColumnPool {
 void gc_memory(void* arg_this) {
     using namespace starrocks;
     const static float kFreeRatio = 0.5;
-    GCHelper gch(config::tc_gc_period, config::memory_maintenance_sleep_time_s, MonoTime::Now());
 
     auto* daemon = static_cast<Daemon*>(arg_this);
     while (!daemon->stopped()) {
         sleep(static_cast<unsigned int>(config::memory_maintenance_sleep_time_s));
-#if !defined(ADDRESS_SANITIZER) && !defined(LEAK_SANITIZER) && !defined(THREAD_SANITIZER) && !defined(USE_JEMALLOC)
-        MallocExtension::instance()->MarkThreadBusy();
-#endif
+
         ReleaseColumnPool releaser(kFreeRatio);
         ForEach<ColumnPoolList>(releaser);
         LOG_IF(INFO, releaser.freed_bytes() > 0) << "Released " << releaser.freed_bytes() << " bytes from column pool";
-
-#if !defined(ADDRESS_SANITIZER) && !defined(LEAK_SANITIZER) && !defined(THREAD_SANITIZER) && !defined(USE_JEMALLOC)
-        size_t used_size = 0;
-        size_t free_size = 0;
-        MallocExtension::instance()->GetNumericProperty("generic.current_allocated_bytes", &used_size);
-        MallocExtension::instance()->GetNumericProperty("tcmalloc.pageheap_free_bytes", &free_size);
-        size_t phy_size = used_size + free_size; // physical memory usage
-        size_t total_bytes_to_gc = 0;
-        if (phy_size > config::tc_use_memory_min) {
-            size_t max_free_size = phy_size * config::tc_free_memory_rate / 100;
-            if (free_size > max_free_size) {
-                total_bytes_to_gc = free_size - max_free_size;
-            }
-        }
-        size_t bytes_to_gc = gch.bytes_should_gc(MonoTime::Now(), total_bytes_to_gc);
-        if (bytes_to_gc > 0) {
-            size_t bytes = bytes_to_gc;
-            while (bytes >= GCBYTES_ONE_STEP) {
-                MallocExtension::instance()->ReleaseToSystem(GCBYTES_ONE_STEP);
-                bytes -= GCBYTES_ONE_STEP;
-            }
-            if (bytes > 0) {
-                MallocExtension::instance()->ReleaseToSystem(bytes);
-            }
-        }
-        MallocExtension::instance()->MarkThreadIdle();
-#endif
     }
 }
 

be/src/http/action/pprof_actions.cpp

@@ -33,11 +33,7 @@
 // under the License.
 
 #include "http/action/pprof_actions.h"
-#ifdef USE_JEMALLOC
-#include "jemalloc/jemalloc.h"
-#endif
-#include <gperftools/heap-profiler.h>
-#include <gperftools/malloc_extension.h>
+
 #include <gperftools/profiler.h>
 
 #include <fstream>
@@ -51,6 +47,7 @@
 #include "http/http_channel.h"
 #include "http/http_headers.h"
 #include "http/http_request.h"
+#include "jemalloc/jemalloc.h"
 #include "util/bfd_parser.h"
 
 namespace starrocks {
@@ -69,7 +66,7 @@ void HeapAction::handle(HttpRequest* req) {
     std::string str = "Heap profiling is not available with address sanitizer builds.";
 
     HttpChannel::send_reply(req, str);
-#elif defined(USE_JEMALLOC)
+#else
     (void)kPprofDefaultSampleSecs; // Avoid unused variable warning.
 
     std::lock_guard<std::mutex> lock(kPprofActionMutex);
@@ -85,30 +82,8 @@ void HeapAction::handle(HttpRequest* req) {
         std::ifstream f(fname_cstr);
         str = std::string(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
     } else {
-        std::string str = "dump jemalloc prof file failed";
-    }
-    HttpChannel::send_reply(req, str);
-#else
-    std::lock_guard<std::mutex> lock(kPprofActionMutex);
-
-    int seconds = kPprofDefaultSampleSecs;
-    const std::string& seconds_str = req->param(SECOND_KEY);
-    if (!seconds_str.empty()) {
-        seconds = std::atoi(seconds_str.c_str());
+        str = "dump jemalloc prof file failed";
     }
-
-    std::stringstream tmp_prof_file_name;
-    // Build a temporary file name that is hopefully unique.
-    tmp_prof_file_name << config::pprof_profile_dir << "/heap_profile." << getpid() << "." << rand();
-
-    HeapProfilerStart(tmp_prof_file_name.str().c_str());
-    // Sleep to allow for some samples to be collected.
-    sleep(seconds);
-    const char* profile = GetHeapProfile();
-    HeapProfilerStop();
-    std::string str = profile;
-    delete profile;
-
     HttpChannel::send_reply(req, str);
 #endif
 }
@@ -117,18 +92,11 @@ void GrowthAction::handle(HttpRequest* req) {
 #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || defined(THREAD_SANITIZER)
     std::string str = "Growth profiling is not available with address sanitizer builds.";
     HttpChannel::send_reply(req, str);
-#elif defined(USE_JEMALLOC)
+#else
     std::string str =
             "Growth profiling is not available with jemalloc builds.You can set the `--base` flag to jeprof to compare "
             "the results of two Heap Profiling";
     HttpChannel::send_reply(req, str);
-#else
-    std::lock_guard<std::mutex> lock(kPprofActionMutex);
-
-    std::string heap_growth_stack;
-    MallocExtension::instance()->GetHeapGrowthStacks(&heap_growth_stack);
-
-    HttpChannel::send_reply(req, heap_growth_stack);
 #endif
 }
 

be/src/http/default_path_handlers.cpp

@@ -34,11 +34,6 @@
 
 #include "http/default_path_handlers.h"
 
-#ifdef USE_JEMALLOC
-#include "jemalloc/jemalloc.h"
-#else
-#include <gperftools/malloc_extension.h>
-#endif
 #include <gutil/strings/numbers.h>
 #include <gutil/strings/substitute.h>
 
@@ -47,6 +42,7 @@
 
 #include "common/configbase.h"
 #include "http/web_page_handler.h"
+#include "jemalloc/jemalloc.h"
 #include "runtime/exec_env.h"
 #include "runtime/mem_tracker.h"
 #include "storage/storage_engine.h"
@@ -211,12 +207,10 @@ void mem_tracker_handler(MemTracker* mem_tracker, const WebPageHandler::Argument
     (*output) << "</tbody></table>\n";
 }
 
-#ifdef USE_JEMALLOC
 void malloc_stats_write_cb(void* opaque, const char* data) {
     auto* buf = static_cast<std::string*>(opaque);
     buf->append(data);
 }
-#endif
 
 // Registered to handle "/memz", and prints out memory allocation statistics.
 void mem_usage_handler(MemTracker* mem_tracker, const WebPageHandler::ArgumentMap& args, std::stringstream* output) {
@@ -234,18 +228,11 @@ void mem_usage_handler(MemTracker* mem_tracker, const WebPageHandler::ArgumentMa
     (*output) << "<pre>";
 #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || defined(THREAD_SANITIZER)
     (*output) << "Memory tracking is not available with address sanitizer builds.";
-#elif defined(USE_JEMALLOC)
+#else
     std::string buf;
     je_malloc_stats_print(malloc_stats_write_cb, &buf, "a");
     boost::replace_all(buf, "\n", "<br>");
     (*output) << buf << "</pre>";
-#else
-    char buf[2048];
-    MallocExtension::instance()->GetStats(buf, 2048);
-    // Replace new lines with <br> for html
-    std::string tmp(buf);
-    boost::replace_all(tmp, "\n", "<br>");
-    (*output) << tmp << "</pre>";
 #endif
     (*output) << "<pre>";
     string stats = StorageEngine::instance()->update_manager()->detail_memory_stats();

be/src/service/mem_hook.cpp

@@ -12,19 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifdef USE_JEMALLOC
-#include "jemalloc/jemalloc.h"
-#else
-#include <gperftools/nallocx.h>
-#include <gperftools/tcmalloc.h>
-#endif
-
 #include <atomic>
 #include <iostream>
 
 #include "common/compiler_util.h"
 #include "common/config.h"
 #include "glog/logging.h"
+#include "jemalloc/jemalloc.h"
 #include "util/stack_util.h"
 
 #ifndef BE_TEST
@@ -191,7 +185,6 @@ void operator delete[](void* p, size_t size, std::align_val_t al) noexcept {
 }
 */
 
-#ifdef USE_JEMALLOC
 #define STARROCKS_MALLOC_SIZE(ptr) je_malloc_usable_size(ptr)
 #define STARROCKS_NALLOX(size, flags) je_nallocx(size, flags)
 #define STARROCKS_MALLOC(size) je_malloc(size)
@@ -202,18 +195,6 @@ void operator delete[](void* p, size_t size, std::align_val_t al) noexcept {
 #define STARROCKS_POSIX_MEMALIGN(ptr, align, size) je_posix_memalign(ptr, align, size)
 #define STARROCKS_CFREE(ptr) je_free(ptr)
 #define STARROCKS_VALLOC(size) je_valloc(size)
-#else
-#define STARROCKS_MALLOC_SIZE(ptr) tc_malloc_size(ptr)
-#define STARROCKS_NALLOX(size, flags) tc_nallocx(size, flags)
-#define STARROCKS_MALLOC(size) tc_malloc(size)
-#define STARROCKS_FREE(ptr) tc_free(ptr)
-#define STARROCKS_REALLOC(ptr, size) tc_realloc(ptr, size)
-#define STARROCKS_CALLOC(number, size) tc_calloc(number, size)
-#define STARROCKS_ALIGNED_ALLOC(align, size) tc_memalign(align, size)
-#define STARROCKS_POSIX_MEMALIGN(ptr, align, size) tc_posix_memalign(ptr, align, size)
-#define STARROCKS_CFREE(ptr) tc_cfree(ptr)
-#define STARROCKS_VALLOC(size) tc_valloc(size)
-#endif
 
 #ifndef BE_TEST
 #define MEMORY_CONSUME_SIZE(size)                                      \
@@ -256,7 +237,6 @@ std::atomic<int64_t> g_mem_usage(0);
 #define IS_BAD_ALLOC_CATCHED() false
 #endif
 
-#ifdef USE_JEMALLOC
 const size_t large_memory_alloc_report_threshold = 1073741824;
 inline thread_local bool skip_report = false;
 inline void report_large_memory_alloc(size_t size) {
@@ -271,9 +251,6 @@ inline void report_large_memory_alloc(size_t size) {
     }
 }
 #define STARROCKS_REPORT_LARGE_MEM_ALLOC(size) report_large_memory_alloc(size)
-#else
-#define STARROCKS_REPORT_LARGE_MEM_ALLOC(size) (void)0
-#endif
 
 extern "C" {
 // malloc
@@ -491,7 +468,5 @@ void* aligned_alloc(size_t align, size_t size) __THROW ALIAS(my_aligned_alloc);
 void* valloc(size_t size) __THROW ALIAS(my_valloc);
 void* pvalloc(size_t size) __THROW ALIAS(my_pvalloc);
 int posix_memalign(void** r, size_t a, size_t s) __THROW ALIAS(my_posix_memalign);
-#ifdef USE_JEMALLOC
 size_t malloc_usable_size(void* ptr) __THROW ALIAS(my_malloc_usebale_size);
-#endif
 }

be/src/service/starrocks_main.cpp

@@ -134,13 +134,6 @@ int main(int argc, char** argv) {
         exit(-1);
     }
 
-    if (getenv("TCMALLOC_HEAP_LIMIT_MB") == nullptr) {
-        fprintf(stderr,
-                "Environment variable TCMALLOC_HEAP_LIMIT_MB is not set,"
-                " maybe you forgot to replace bin directory\n");
-        exit(-1);
-    }
-
     // S2 will crashes when deserialization fails and FLAGS_s2debug was true.
     FLAGS_s2debug = false;
 
@@ -190,22 +183,6 @@ int main(int argc, char** argv) {
     starrocks::Status::access_directory_of_inject();
 #endif
 
-#if !defined(ADDRESS_SANITIZER) && !defined(LEAK_SANITIZER) && !defined(THREAD_SANITIZER) && !defined(USE_JEMALLOC)
-    // Aggressive decommit is required so that unused pages in the TCMalloc page heap are
-    // not backed by physical pages and do not contribute towards memory consumption.
-    //
-    //  2020-08-31: Disable aggressive decommit,  which will decrease the performance of
-    //  memory allocation and deallocation.
-    // MallocExtension::instance()->SetNumericProperty("tcmalloc.aggressive_memory_decommit", 1);
-
-    // Change the total TCMalloc thread cache size if necessary.
-    if (!MallocExtension::instance()->SetNumericProperty("tcmalloc.max_total_thread_cache_bytes",
-                                                         starrocks::config::tc_max_total_thread_cache_bytes)) {
-        fprintf(stderr, "Failed to change TCMalloc total thread cache size.\n");
-        return -1;
-    }
-#endif
-
     Aws::SDKOptions aws_sdk_options;
     if (starrocks::config::aws_sdk_logging_trace_enabled) {
         auto level = parse_aws_sdk_log_level(starrocks::config::aws_sdk_logging_trace_level);