FEATURE: change memstore_limit_percentage to tenant config

src/observer/ob_server_reload_config.cpp

@@ -180,7 +180,6 @@ int ObServerReloadConfig::operator()()
       (void)reload_diagnose_info_config(GCONF.enable_perf_event);
       (void)reload_trace_log_config(GCONF.enable_record_trace_log);
 
-      reload_tenant_freezer_config_();
       reload_tenant_scheduler_config_();
     }
   }
@@ -341,19 +340,3 @@ void ObServerReloadConfig::reload_tenant_scheduler_config_()
     omt->operate_in_each_tenant(f);
   }
 }
-
-void ObServerReloadConfig::reload_tenant_freezer_config_()
-{
-  int ret = OB_SUCCESS;
-  omt::ObMultiTenant *omt = GCTX.omt_;
-  if (OB_ISNULL(omt)) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("omt should not be null", K(ret));
-  } else {
-    auto f = [] () {
-      MTL(ObTenantFreezer *)->reload_config();
-      return OB_SUCCESS;
-    };
-    omt->operate_in_each_tenant(f);
-  }
-}

src/observer/ob_server_reload_config.h

@@ -33,7 +33,6 @@ public:
 
   int operator()();
 private:
-  void reload_tenant_freezer_config_();
   void reload_tenant_scheduler_config_();
 
 

src/observer/omt/ob_multi_tenant.cpp

@@ -1259,12 +1259,15 @@ int ObMultiTenant::update_tenant_config(uint64_t tenant_id)
   } else {
     MAKE_TENANT_SWITCH_SCOPE_GUARD(guard);
     if (OB_SUCC(guard.switch_to(tenant_id))) {
-      if (OB_SUCCESS != (tmp_ret = update_palf_config())) {
+      if (OB_TMP_FAIL(update_palf_config())) {
         LOG_WARN("failed to update palf disk config", K(tmp_ret), K(tenant_id));
       }
-      if (OB_SUCCESS != (tmp_ret = update_tenant_dag_scheduler_config())) {
+      if (OB_TMP_FAIL(update_tenant_dag_scheduler_config())) {
         LOG_WARN("failed to update tenant dag scheduler config", K(tmp_ret), K(tenant_id));
       }
+      if (OB_TMP_FAIL(update_tenant_freezer_config_())) {
+        LOG_WARN("failed to update tenant tenant freezer config", K(tmp_ret), K(tenant_id));
+      }
     }
   }
   LOG_INFO("update_tenant_config success", K(tenant_id));
@@ -1298,41 +1301,33 @@ int ObMultiTenant::update_tenant_dag_scheduler_config()
   return ret;
 }
 
+int ObMultiTenant::update_tenant_freezer_config_()
+{
+  int ret = OB_SUCCESS;
+  ObTenantFreezer *freezer = MTL(ObTenantFreezer*);
+  if (NULL == freezer) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("tenant freezer should not be null", K(ret));
+  } else if (OB_FAIL(freezer->reload_config())) {
+    LOG_WARN("tenant freezer config update failed", K(ret));
+  }
+  return ret;
+}
+
 int ObMultiTenant::update_tenant_freezer_mem_limit(const uint64_t tenant_id,
                                                    const int64_t tenant_min_mem,
                                                    const int64_t tenant_max_mem)
 {
   int ret = OB_SUCCESS;
-  int64_t before_min_mem = 0;
-  int64_t before_max_mem = 0;
 
   MAKE_TENANT_SWITCH_SCOPE_GUARD(guard);
   ObTenantFreezer *freezer = nullptr;
-  if (OB_SUCC(ret)) {
   if (tenant_id != MTL_ID() && OB_FAIL(guard.switch_to(tenant_id))) {
     LOG_WARN("switch tenant failed", K(ret), K(tenant_id));
-    }
-  }
-
-  if (OB_FAIL(ret)) {
-    // do nothing
   } else if (FALSE_IT(freezer = MTL(ObTenantFreezer *))) {
-  } else if (OB_FAIL(freezer->get_tenant_mem_limit(before_min_mem, before_max_mem))) {
+  } else if (freezer->is_tenant_mem_changed(tenant_min_mem, tenant_max_mem)) {
-    if (OB_NOT_REGISTERED == ret) {//tenant mem limit has not been setted
+    if (OB_FAIL(freezer->set_tenant_mem_limit(tenant_min_mem, tenant_max_mem))) {
-      ret = OB_SUCCESS;
+      LOG_WARN("set tenant mem limit failed", K(ret));
-    } else {
-      LOG_WARN("get tenant memory fail", K(tenant_id));
-    }
-  }
-  if (OB_SUCC(ret)) {
-    if (before_min_mem != tenant_min_mem
-        || before_max_mem != tenant_max_mem) {
-      LOG_INFO("tenant memory changed",
-               "before_min", before_min_mem,
-               "before_max", before_max_mem,
-               "after_min",  tenant_min_mem,
-               "after_max", tenant_max_mem);
-      freezer->set_tenant_mem_limit(tenant_min_mem, tenant_max_mem);
     }
   }
   return ret;

src/observer/omt/ob_multi_tenant.h

@@ -184,6 +184,8 @@ protected:
                                     const share::ObUnitInfoGetter::ObTenantConfig &expected_unit_config,
                                     share::ObUnitInfoGetter::ObTenantConfig &allowed_unit);
 
+private:
+  int update_tenant_freezer_config_();
 protected:
       static const int DEL_TRY_TIMES = 30;
       enum class ObTenantCreateStep {

src/share/allocator/ob_tenant_mutil_allocator_mgr.cpp

@@ -125,6 +125,28 @@ int ObTenantMutilAllocatorMgr::get_tenant_mutil_allocator_(const uint64_t tenant
   return ret;
 }
 
+int ObTenantMutilAllocatorMgr::get_tenant_memstore_limit_percent_(const uint64_t tenant_id,
+                                                                  int64_t &limit_percent) const
+{
+  int ret = OB_SUCCESS;
+
+  if (!is_inited_) {
+    ret = OB_NOT_INIT;
+  } else if (OB_UNLIKELY(tenant_id <= 0)) {
+    ret = OB_INVALID_ARGUMENT;
+    OB_LOG(WARN, "invalid arguments", K(ret), K(tenant_id));
+  } else {
+    omt::ObTenantConfigGuard tenant_config(TENANT_CONF(tenant_id));
+    if (!tenant_config.is_valid()) {
+      ret = OB_ERR_UNEXPECTED;
+      OB_LOG(ERROR, "tenant config invalid", K(ret), K(tenant_id));
+    } else {
+      limit_percent = tenant_config->memstore_limit_percentage;
+    }
+  }
+  return ret;
+}
+
 int ObTenantMutilAllocatorMgr::construct_allocator_(const uint64_t tenant_id,
                                                     TMA *&out_allocator)
 {
@@ -340,13 +362,14 @@ int ObTenantMutilAllocatorMgr::update_tenant_mem_limit(const share::TenantUnits
   // Update mem_limit for each tenant, called when the chane unit specifications or
   // memstore_limite_percentage
   int ret = OB_SUCCESS;
-  const int64_t cur_memstore_limit_percent = ObServerConfig::get_instance().memstore_limit_percentage;
+  int tmp_ret = OB_SUCCESS;
   if (!is_inited_) {
     ret = OB_NOT_INIT;
   } else {
     int64_t unit_cnt = all_tenant_units.count();
     for (int64_t i = 0; i < unit_cnt && OB_SUCC(ret); ++i) {
       const share::ObUnitInfoGetter::ObTenantConfig &tenant_config = all_tenant_units.at(i);
+      int64_t cur_memstore_limit_percent = 0;
       const uint64_t tenant_id = tenant_config.tenant_id_;
       const bool has_memstore = tenant_config.has_memstore_;
       int32_t nway = (int32_t)(tenant_config.config_.max_cpu());
@@ -358,15 +381,16 @@ int ObTenantMutilAllocatorMgr::update_tenant_mem_limit(const share::TenantUnits
       if (has_memstore) {
         // If the unit type of tenant is not Log, need to subtract
         // the reserved memory of memstore
-        if (cur_memstore_limit_percent > 100 || cur_memstore_limit_percent <= 0) {
+        if (OB_TMP_FAIL(get_tenant_memstore_limit_percent_(tenant_id, cur_memstore_limit_percent))) {
+          OB_LOG(WARN, "memstore_limit_percentage val is unexpected", K(cur_memstore_limit_percent));
+        } else if (cur_memstore_limit_percent > 100 || cur_memstore_limit_percent <= 0) {
           OB_LOG(WARN, "memstore_limit_percentage val is unexpected", K(cur_memstore_limit_percent));
         } else {
           new_tma_limit = memory_size / 100 * ( 100 - cur_memstore_limit_percent);
         }
       }
-      int tmp_ret = OB_SUCCESS;
       ObTenantMutilAllocator *tma= NULL;
-      if (OB_SUCCESS != (tmp_ret = get_tenant_mutil_allocator_(tenant_id, tma))) {
+      if (OB_TMP_FAIL(get_tenant_mutil_allocator_(tenant_id, tma))) {
         OB_LOG(WARN, "get_tenant_mutil_allocator_ failed", K(tmp_ret), K(tenant_id));
       } else if (NULL == tma) {
         OB_LOG(WARN, "get_tenant_mutil_allocator_ failed", K(tenant_id));
@@ -382,7 +406,7 @@ int ObTenantMutilAllocatorMgr::update_tenant_mem_limit(const share::TenantUnits
 
       //update memstore threshold of GmemstoreAllocator
       ObGMemstoreAllocator* memstore_allocator = NULL;
-      if (OB_SUCCESS != (tmp_ret = ObMemstoreAllocatorMgr::get_instance().get_tenant_memstore_allocator(tenant_id, memstore_allocator))) {
+      if (OB_TMP_FAIL(ObMemstoreAllocatorMgr::get_instance().get_tenant_memstore_allocator(tenant_id, memstore_allocator))) {
       } else if (OB_ISNULL(memstore_allocator)) {
         OB_LOG(WARN, "get_tenant_memstore_allocator failed", K(tenant_id));
       } else if (OB_FAIL(memstore_allocator->set_memstore_threshold(tenant_id))) {

src/share/allocator/ob_tenant_mutil_allocator_mgr.h

@@ -52,6 +52,8 @@ public:
 private:
   int64_t get_slot_(const int64_t tenant_id) const;
   int get_tenant_mutil_allocator_(const uint64_t tenant_id, TMA *&out_allocator);
+  int get_tenant_memstore_limit_percent_(const uint64_t tenant_id,
+                                         int64_t &limit_percent) const;
   int delete_tenant_mutil_allocator_(const uint64_t tenant_id);
   int construct_allocator_(const uint64_t tenant_id,
                            TMA *&out_allocator);

src/share/parameter/ob_parameter_seed.ipp

@@ -360,7 +360,7 @@ DEF_BOOL(_nested_loop_join_enabled, OB_TENANT_PARAMETER, "True",
          ObParameterAttr(Section::TENANT, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
 
 // tenant memtable consumption related
-DEF_INT(memstore_limit_percentage, OB_CLUSTER_PARAMETER, "50", "(0, 100)",
+DEF_INT(memstore_limit_percentage, OB_TENANT_PARAMETER, "50", "(0, 100)",
         "used in calculating the value of MEMSTORE_LIMIT parameter: "
         "memstore_limit_percentage = memstore_limit / memory_size,memory_size, "
         "where MEMORY_SIZE is determined when the tenant is created. Range: (0, 100)",

src/sql/dtl/ob_dtl_channel_mem_manager.cpp

@@ -28,7 +28,7 @@ using namespace oceanbase::sql::dtl;
 
 ObDtlChannelMemManager::ObDtlChannelMemManager(uint64_t tenant_id, ObDtlTenantMemManager &tenant_mgr) :
   tenant_id_(tenant_id), size_per_buffer_(GCONF.dtl_buffer_size), seqno_(-1), allocator_(tenant_id), pre_alloc_cnt_(0),
-  max_mem_percent_(0), alloc_cnt_(0), free_cnt_(0), real_alloc_cnt_(0), real_free_cnt_(0), tenant_mgr_(tenant_mgr),
+  max_mem_percent_(0), memstore_limit_percent_(0), alloc_cnt_(0), free_cnt_(0), real_alloc_cnt_(0), real_free_cnt_(0), tenant_mgr_(tenant_mgr),
   mem_used_(0), last_update_memory_time_(-1)
 {}
 
@@ -65,6 +65,19 @@ int ObDtlChannelMemManager::get_max_mem_percent()
   return ret;
 }
 
+int ObDtlChannelMemManager::get_memstore_limit_percentage_()
+{
+  int ret = OB_SUCCESS;
+  ObTenantConfigGuard tenant_config(TENANT_CONF(tenant_id_));
+  if (tenant_config.is_valid()) {
+    memstore_limit_percent_ = tenant_config->memstore_limit_percentage;
+  } else {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("failed to init tenant config", K(tenant_id_), K(ret));
+  }
+  return ret;
+}
+
 void ObDtlChannelMemManager::destroy()
 {
   int ret = OB_SUCCESS;
@@ -107,10 +120,9 @@ ObDtlLinkedBuffer *ObDtlChannelMemManager::alloc(int64_t chid, int64_t size)
   if (nullptr != allocated_buf) {
   } else if (out_of_memory()) {
     ret = OB_ALLOCATE_MEMORY_FAILED;
-    int64_t memstore_percent = GCONF.memstore_limit_percentage;
     LOG_WARN("the memory of dtl reach the maxinum memory limit", K(ret), K(get_used_memory_size()),
       K(get_max_tenant_memory_limit_size()), K(get_max_dtl_memory_size()),
-      K(max_mem_percent_), K(memstore_percent), K(allocated_buf), K(size));
+      K(max_mem_percent_), K_(memstore_limit_percent), K(allocated_buf), K(size));
   } else {
     const int64_t alloc_size = sizeof (ObDtlLinkedBuffer)
         + std::max(size, size_per_buffer_);

src/sql/dtl/ob_dtl_channel_mem_manager.h

@@ -72,6 +72,7 @@ private:
   int64_t get_used_memory_size();
   int64_t get_max_dtl_memory_size();
   int64_t get_max_tenant_memory_limit_size();
+  int get_memstore_limit_percentage_();
   void real_free(ObDtlLinkedBuffer *buf);
 private:
   uint64_t tenant_id_;
@@ -83,6 +84,7 @@ private:
 
   int64_t pre_alloc_cnt_;
   double max_mem_percent_;
+  int64_t memstore_limit_percent_;
 
   // some statistics
   int64_t alloc_cnt_;
@@ -105,7 +107,11 @@ OB_INLINE int64_t ObDtlChannelMemManager::get_max_dtl_memory_size()
 
 OB_INLINE int64_t ObDtlChannelMemManager::get_max_tenant_memory_limit_size()
 {
-  int64_t percent_execpt_memstore = 100 - GCONF.memstore_limit_percentage;
+  int ret = OB_SUCCESS;
+  if (0 == memstore_limit_percent_) {
+    get_memstore_limit_percentage_();
+  }
+  int64_t percent_execpt_memstore = 100 - memstore_limit_percent_;
   return lib::get_tenant_memory_limit(tenant_id_) * percent_execpt_memstore / 100;
 }
 
@@ -122,6 +128,7 @@ OB_INLINE bool ObDtlChannelMemManager::out_of_memory()
 
 OB_INLINE void ObDtlChannelMemManager::update_max_memory_percent()
 {
+  get_memstore_limit_percentage_();
   get_max_mem_percent();
 }
 

src/storage/tx_storage/ob_tenant_freezer.cpp

@@ -44,7 +44,6 @@ ObTenantFreezer::ObTenantFreezer()
     svr_rpc_proxy_(nullptr),
     common_rpc_proxy_(nullptr),
     rs_mgr_(nullptr),
-    config_(nullptr),
     allocator_mgr_(nullptr),
     freeze_thread_pool_(),
     freeze_thread_pool_lock_(common::ObLatchIds::FREEZE_THREAD_POOL_LOCK),
@@ -66,7 +65,6 @@ void ObTenantFreezer::destroy()
   svr_rpc_proxy_ = nullptr;
   common_rpc_proxy_ = nullptr;
   rs_mgr_ = nullptr;
-  config_ = nullptr;
   allocator_mgr_ = nullptr;
 
   is_inited_ = false;
@@ -87,12 +85,10 @@ int ObTenantFreezer::init()
              OB_ISNULL(GCTX.net_frame_) ||
              OB_ISNULL(GCTX.srv_rpc_proxy_) ||
              OB_ISNULL(GCTX.rs_rpc_proxy_) ||
-             OB_ISNULL(GCTX.rs_mgr_) ||
+             OB_ISNULL(GCTX.rs_mgr_)) {
-             OB_ISNULL(GCTX.config_)) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("[TenantFreezer] invalid argument", KR(ret), KP(GCTX.srv_rpc_proxy_),
-             KP(GCTX.rs_rpc_proxy_), KP(GCTX.rs_mgr_), KP(GCTX.config_),
+             KP(GCTX.rs_rpc_proxy_), KP(GCTX.rs_mgr_), K(GCONF.self_addr_));
-             K(GCONF.self_addr_));
   } else if (OB_FAIL(freeze_trigger_pool_.init_and_start(FREEZE_TRIGGER_THREAD_NUM))) {
     LOG_WARN("[TenantFreezer] fail to initialize freeze trigger pool", KR(ret));
   } else if (OB_FAIL(freeze_thread_pool_.init_and_start(FREEZE_THREAD_NUM))) {
@@ -110,7 +106,6 @@ int ObTenantFreezer::init()
     svr_rpc_proxy_ = GCTX.srv_rpc_proxy_;
     common_rpc_proxy_ = GCTX.rs_rpc_proxy_;
     rs_mgr_ = GCTX.rs_mgr_;
-    config_ = GCTX.config_;
     allocator_mgr_ = &ObMemstoreAllocatorMgr::get_instance();
     tenant_info_.tenant_id_ = MTL_ID();
     is_inited_ = true;
@@ -792,8 +787,37 @@ int ObTenantFreezer::unset_tenant_slow_freeze(const common::ObTabletID &tablet_i
   return ret;
 }
 
-int ObTenantFreezer::set_tenant_mem_limit(
+bool ObTenantFreezer::is_tenant_mem_changed(const int64_t curr_lower_limit,
-    const int64_t lower_limit,
+                                            const int64_t curr_upper_limit) const
+{
+  int ret = OB_SUCCESS;
+  bool is_changed = false;
+  int64_t old_lower_limit = 0;
+  int64_t old_upper_limit = 0;
+  const uint64_t tenant_id = tenant_info_.tenant_id_;
+  if (!is_inited_) {
+    ret = OB_NOT_INIT;
+    LOG_WARN("[TenantFreezer] tenant manager not init", KR(ret));
+  } else if (false == tenant_info_.is_loaded_) {
+    is_changed = true;
+  } else {
+    // 1. tenant memory limit changed
+    tenant_info_.get_mem_limit(old_lower_limit, old_upper_limit);
+    is_changed = (is_changed ||
+                  old_lower_limit != curr_lower_limit ||
+                  old_upper_limit != curr_upper_limit);
+  }
+  if (is_changed) {
+    LOG_INFO("tenant memory changed",
+             "before_min", old_lower_limit,
+             "before_max", old_upper_limit,
+             "after_min", curr_lower_limit,
+             "after_max", curr_upper_limit);
+  }
+  return is_changed;
+}
+
+int ObTenantFreezer::set_tenant_mem_limit(const int64_t lower_limit,
                                           const int64_t upper_limit)
 {
   int ret = OB_SUCCESS;
@@ -805,16 +829,16 @@ int ObTenantFreezer::set_tenant_mem_limit(
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("[TenantFreezer] invalid argument", KR(ret), K(lower_limit), K(upper_limit));
   } else {
-    int64_t freeze_trigger_percentage = get_freeze_trigger_percentage_();
+    const int64_t freeze_trigger_percentage = get_freeze_trigger_percentage_();
-    if ((NULL != config_) &&
+    const int64_t memstore_limit_percent = get_memstore_limit_percentage_();
-        (((int64_t)(config_->memstore_limit_percentage)) > 100 ||
+    if (memstore_limit_percent > 100 ||
-         ((int64_t)(config_->memstore_limit_percentage)) <= 0 ||
+        memstore_limit_percent <= 0 ||
         freeze_trigger_percentage > 100 ||
-         freeze_trigger_percentage <= 0)) {
+        freeze_trigger_percentage <= 0) {
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("[TenantFreezer] memstore limit percent in ObServerConfig is invaild",
                "memstore limit percent",
-               (int64_t)config_->memstore_limit_percentage,
+               memstore_limit_percent,
                "minor freeze trigger percent",
                freeze_trigger_percentage,
                KR(ret));
@@ -822,16 +846,12 @@ int ObTenantFreezer::set_tenant_mem_limit(
       const uint64_t tenant_id = tenant_info_.tenant_id_;
       ObTenantFreezeCtx ctx;
       tenant_info_.update_mem_limit(lower_limit, upper_limit);
-      if (NULL != config_) {
+      tenant_info_.update_memstore_limit(memstore_limit_percent);
-        tenant_info_.update_memstore_limit(config_->memstore_limit_percentage);
-      }
       tenant_info_.is_loaded_ = true;
       tenant_info_.get_freeze_ctx(ctx);
-      if (NULL != config_) {
       if (OB_FAIL(get_freeze_trigger_(ctx))) {
         LOG_WARN("[TenantFreezer] fail to get minor freeze trigger", KR(ret), K(tenant_id));
       }
-      }
       if (OB_SUCC(ret)) {
         LOG_INFO("[TenantFreezer] set tenant mem limit",
                  "tenant id", tenant_id,
@@ -1243,6 +1263,22 @@ int64_t ObTenantFreezer::get_freeze_trigger_percentage_()
   return percent;
 }
 
+int64_t ObTenantFreezer::get_memstore_limit_percentage_()
+{
+  int ret = OB_SUCCESS;
+  static const int64_t DEFAULT_MEMSTORE_LIMIT_PERCENTAGE = 50;
+  int64_t percent = DEFAULT_MEMSTORE_LIMIT_PERCENTAGE;
+  omt::ObTenantConfigGuard tenant_config(TENANT_CONF(MTL_ID()));
+  if (tenant_config.is_valid()) {
+    percent = tenant_config->memstore_limit_percentage;
+  } else {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_ERROR("memstore limit percentage is invalid", K(ret));
+  }
+  return percent;
+}
+
+
 int ObTenantFreezer::post_freeze_request_(
     const storage::ObFreezeType freeze_type,
     const int64_t try_frozen_scn)
@@ -1303,39 +1339,35 @@ int ObTenantFreezer::rpc_callback()
   return ret;
 }
 
-void ObTenantFreezer::reload_config()
+int ObTenantFreezer::reload_config()
 {
   int ret = OB_SUCCESS;
-  int64_t freeze_trigger_percentage = get_freeze_trigger_percentage_();
+  const int64_t freeze_trigger_percentage = get_freeze_trigger_percentage_();
+  const int64_t memstore_limit_percent = get_memstore_limit_percentage_();
   if (!is_inited_) {
     ret = OB_NOT_INIT;
     LOG_WARN("[TenantFreezer] tenant manager not init", KR(ret));
-  } else if (NULL == config_) {
+  } else if (memstore_limit_percent > 100
-    ret = OB_ERR_UNEXPECTED;
+             || memstore_limit_percent <= 0
-    LOG_WARN("[TenantFreezer] config_ shouldn't be null here", KR(ret), KP(config_));
-  } else if (((int64_t)(config_->memstore_limit_percentage)) > 100
-             || ((int64_t)(config_->memstore_limit_percentage)) <= 0
              || freeze_trigger_percentage > 100
              || freeze_trigger_percentage <= 0) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("[TenantFreezer] memstore limit percent in ObServerConfig is invalid",
              "memstore limit percent",
-             (int64_t)config_->memstore_limit_percentage,
+             memstore_limit_percent,
              "minor freeze trigger percent",
              freeze_trigger_percentage,
              KR(ret));
-  } else {
+  } else if (true == tenant_info_.is_loaded_ &&
-    if (true == tenant_info_.is_loaded_) {
+             tenant_info_.is_memstore_limit_changed(memstore_limit_percent)) {
-      tenant_info_.update_memstore_limit(config_->memstore_limit_percentage);
+    tenant_info_.update_memstore_limit(memstore_limit_percent);
-    }
-  }
-  if (OB_SUCCESS == ret) {
     LOG_INFO("[TenantFreezer] reload config for tenant freezer",
              "new memstore limit percent",
-             (int64_t)config_->memstore_limit_percentage,
+             memstore_limit_percent,
              "new minor freeze trigger percent",
              freeze_trigger_percentage);
   }
+  return ret;
 }
 
 int ObTenantFreezer::print_tenant_usage(

src/storage/tx_storage/ob_tenant_freezer.h

@@ -99,6 +99,11 @@ public:
   //                       unset success if the tablet is the one who slow the tenant.
   //                       else do nothing.
   int unset_tenant_slow_freeze(const common::ObTabletID &tablet_id);
+  // check whether the tenant mem limit, memstore limit has been changed.
+  // @param[in] curr_lower_limit, the new lower limit
+  // @param[in] curr_upper_limit, the new upper limit
+  bool is_tenant_mem_changed(const int64_t curr_lower_limit,
+                             const int64_t curr_upper_limit) const;
   // set tenant mem limit, both for min and max memory limit.
   // @param[in] lower_limit, the min memory limit will be set.
   // @param[in] upper_limit, the max memory limit will be set.
@@ -127,7 +132,7 @@ public:
   // used to print a log.
   static int rpc_callback();
   // update the memstore limit use sysconf.
-  void reload_config();
+  int reload_config();
   // print the tenant usage info into print_buf.
   // @param[out] print_buf, the buf is used to print.
   // @param[in] buf_len, the buf length.
@@ -142,7 +147,6 @@ public:
     retry_major_info_ = retry_major_info;
   }
   static int64_t get_freeze_trigger_interval() { return FREEZE_TRIGGER_INTERVAL; }
-  ObServerConfig *get_config() { return config_; }
   bool exist_ls_freezing();
 private:
   int check_memstore_full_(bool &last_result,
@@ -170,6 +174,7 @@ private:
   // @param[in] rollback_freeze_cnt, reduce the tenant's freeze count by 1, if true.
   int unset_tenant_freezing_(const bool rollback_freeze_cnt);
   static int64_t get_freeze_trigger_percentage_();
+  static int64_t get_memstore_limit_percentage_();
   int post_freeze_request_(const storage::ObFreezeType freeze_type,
                            const int64_t try_frozen_version);
   int retry_failed_major_freeze_(bool &triggered);
@@ -209,7 +214,6 @@ private:
   obrpc::ObCommonRpcProxy *common_rpc_proxy_;
   const share::ObRsMgr *rs_mgr_;
   ObAddr self_;
-  common::ObServerConfig *config_;
   ObRetryMajorInfo retry_major_info_;
   common::ObMemstoreAllocatorMgr *allocator_mgr_;
 

src/storage/tx_storage/ob_tenant_freezer_common.cpp

@@ -182,6 +182,14 @@ int64_t ObTenantInfo::get_memstore_limit() const
   return mem_memstore_limit_;
 }
 
+bool ObTenantInfo::is_memstore_limit_changed(const int64_t curr_memstore_limit_percentage) const
+{
+  SpinRLockGuard guard(lock_);
+  const int64_t tmp_var = mem_upper_limit_ / 100;
+  const int64_t curr_mem_memstore_limit = tmp_var * curr_memstore_limit_percentage;
+  return (curr_mem_memstore_limit != mem_memstore_limit_);
+}
+
 void ObTenantInfo::get_freeze_ctx(ObTenantFreezeCtx &ctx) const
 {
   SpinRLockGuard guard(lock_);

src/storage/tx_storage/ob_tenant_freezer_common.h

@@ -126,6 +126,7 @@ public:
   void get_mem_limit(int64_t &lower_limit, int64_t &upper_limit) const;
   void update_memstore_limit(const int64_t memstore_limit_percentage);
   int64_t get_memstore_limit() const;
+  bool is_memstore_limit_changed(const int64_t curr_memstore_limit_percentage) const;
   void get_freeze_ctx(ObTenantFreezeCtx &ctx) const;
 
   // used slow freeze.