tests: Disable some tests when jemalloc is not enabled

dbms/src/Storages/KVStore/FFI/JointThreadAllocInfo.cpp

@@ -149,15 +149,14 @@ void JointThreadInfoJeallocMap::recordThreadAllocInfoForProxy()
         {
             auto agg_thread_name = getThreadNameAggPrefix(k, '-');
             // Some thread may have shorter lifetime, we can't use this timed task here to upgrade.
-            if (PROXY_RECORD_WHITE_LIST_THREAD_PREFIX.contains(agg_thread_name) && v.has_ptr())
+            if (PROXY_RECORD_WHITE_LIST_THREAD_PREFIX.contains(agg_thread_name) && v.hasPtr())
             {
                 agg_allocate[agg_thread_name] += v.allocated();
                 agg_deallocate[agg_thread_name] += v.deallocated();
             }
         }
     }
 
-    // TODO: maybe we should move the following code to `recordThreadAllocInfo`
     auto & tiflash_metrics = TiFlashMetrics::instance();
     for (const auto & [k, v] : agg_allocate)
     {
@@ -236,27 +235,30 @@ void JointThreadInfoJeallocMap::reportThreadAllocInfoForStorage(
 
 void JointThreadInfoJeallocMap::recordThreadAllocInfoForStorage()
 {
-    std::shared_lock l(memory_allocation_mut);
     std::unordered_map<std::string, uint64_t> agg_allocate;
     std::unordered_map<std::string, uint64_t> agg_deallocate;
-    for (const auto & [k, v] : storage_map)
+
     {
-        auto agg_thread_name = getThreadNameAggPrefix(k, v.aggregate_delimer);
-        // Some thread may have shorter lifetime, we can't use this timed task here to upgrade.
-        if (v.has_ptr())
+        std::shared_lock l(memory_allocation_mut);
+        for (const auto & [k, v] : storage_map)
         {
-            agg_allocate[agg_thread_name] += v.allocated();
-            agg_deallocate[agg_thread_name] += v.deallocated();
+            auto agg_thread_name = getThreadNameAggPrefix(k, v.aggregate_delimer);
+            // Some thread may have shorter lifetime, we can't use this timed task here to upgrade.
+            if (v.hasPtr())
+            {
+                agg_allocate[agg_thread_name] += v.allocated();
+                agg_deallocate[agg_thread_name] += v.deallocated();
+            }
         }
     }
+
+    auto & tiflash_metrics = TiFlashMetrics::instance();
     for (const auto & [k, v] : agg_allocate)
     {
-        auto & tiflash_metrics = TiFlashMetrics::instance();
         tiflash_metrics.setStorageThreadMemory(TiFlashMetrics::MemoryAllocType::Alloc, k, v);
     }
     for (const auto & [k, v] : agg_deallocate)
     {
-        auto & tiflash_metrics = TiFlashMetrics::instance();
         tiflash_metrics.setStorageThreadMemory(TiFlashMetrics::MemoryAllocType::Dealloc, k, v);
     }
 }

dbms/src/Storages/KVStore/FFI/JointThreadAllocInfo.h

@@ -15,6 +15,7 @@
 #pragma once
 
 #include <shared_mutex>
+#include <thread>
 #include <unordered_map>
 
 namespace DB
@@ -30,14 +31,14 @@ struct ReportThreadAllocateInfoBatch;
 
 struct ThreadInfoJealloc
 {
-    ThreadInfoJealloc(char aggregate_delimer_)
+    explicit ThreadInfoJealloc(char aggregate_delimer_)
         : aggregate_delimer(aggregate_delimer_)
     {}
     char aggregate_delimer = '-';
     uint64_t allocated_ptr{0};
     uint64_t deallocated_ptr{0};
 
-    bool has_ptr() const { return allocated_ptr != 0 && deallocated_ptr != 0; }
+    bool hasPtr() const { return allocated_ptr != 0 && deallocated_ptr != 0; }
 
     uint64_t allocated() const
     {

dbms/src/Storages/KVStore/tests/gtest_new_kvstore.cpp

@@ -23,6 +23,7 @@
 #include <Storages/RegionQueryInfo.h>
 #include <TiDB/Schema/SchemaSyncService.h>
 #include <TiDB/Schema/TiDBSchemaManager.h>
+#include <common/config_common.h> // Included for `USE_JEMALLOC`
 
 #include <limits>
 
@@ -1056,23 +1057,24 @@ try
 }
 CATCH
 
+#if USE_JEMALLOC // following tests depends on jemalloc
 TEST(FFIJemallocTest, JemallocThread)
 try
 {
     std::thread t2([&]() {
         char * a = new char[888888];
         std::thread t1([&]() {
             auto [allocated, deallocated] = JointThreadInfoJeallocMap::getPtrs();
-            ASSERT(allocated != 0);
+            ASSERT_TRUE(allocated != nullptr);
             ASSERT_EQ(*allocated, 0);
-            ASSERT(deallocated != 0);
+            ASSERT_TRUE(deallocated != nullptr);
             ASSERT_EQ(*deallocated, 0);
         });
         t1.join();
         auto [allocated, deallocated] = JointThreadInfoJeallocMap::getPtrs();
-        ASSERT(allocated != 0);
+        ASSERT_TRUE(allocated != nullptr);
         ASSERT_GE(*allocated, 888888);
-        ASSERT(deallocated != 0);
+        ASSERT_TRUE(deallocated != nullptr);
         delete[] a;
     });
     t2.join();
@@ -1084,37 +1086,43 @@ try
 {
     using namespace std::chrono_literals;
     auto & ctx = TiFlashTestEnv::getGlobalContext();
-    auto size = TiFlashTestEnv::DEFAULT_BG_POOL_SIZE;
-    std::atomic_bool b;
     auto & pool = ctx.getBackgroundPool();
+    const auto size = TiFlashTestEnv::DEFAULT_BG_POOL_SIZE;
+    std::atomic_bool b = false;
     auto t = pool.addTask(
         [&]() {
             auto * x = new int[1000];
+            LOG_INFO(Logger::get(), "allocated");
             while (!b.load())
             {
                 std::this_thread::sleep_for(1500ms);
             }
             delete[] x;
+            LOG_INFO(Logger::get(), "released");
             return false;
         },
         false,
         5 * 60 * 1000);
     std::this_thread::sleep_for(500ms);
+
     JointThreadInfoJeallocMap & jm = *ctx.getJointThreadInfoJeallocMap();
     jm.recordThreadAllocInfo();
 
-    LOG_INFO(DB::Logger::get(), "size {}", size);
+    LOG_INFO(DB::Logger::get(), "bg pool size={}", size);
     UInt64 r = TiFlashMetrics::instance().getStorageThreadMemory(TiFlashMetrics::MemoryAllocType::Alloc, "bg");
     ASSERT_GE(r, sizeof(int) * 1000);
     jm.accessStorageMap([size](const JointThreadInfoJeallocMap::AllocMap & m) {
         // There are some other bg thread pools
-        ASSERT_GE(m.size(), size);
+        ASSERT_GE(m.size(), size) << m.size();
     });
     jm.accessProxyMap([](const JointThreadInfoJeallocMap::AllocMap & m) { ASSERT_EQ(m.size(), 0); });
+
     b.store(true);
+
     ctx.getBackgroundPool().removeTask(t);
 }
 CATCH
+#endif
 
 TEST(ProxyMode, Normal)
 try

dbms/src/Storages/KVStore/tests/gtest_raftstore_v2.cpp

@@ -956,7 +956,7 @@ try
         while (kvs.getOngoingPrehandleTaskCount() != 3)
         {
             loop += 1;
-            ASSERT(loop < 30);
+            ASSERT_TRUE(loop < 30);
             std::this_thread::sleep_for(std::chrono::milliseconds(100));
         }
         ASSERT_EQ(kvs.prehandling_trace.ongoing_prehandle_subtask_count.load(), 3);