From ff79506de25f265798ed026cb249d12d008f8cbe Mon Sep 17 00:00:00 2001 From: obdev Date: Tue, 10 Oct 2023 12:44:03 +0000 Subject: [PATCH] FEATURE: change memstore_limit_percentage to tenant config --- src/observer/ob_server_reload_config.cpp | 17 --- src/observer/ob_server_reload_config.h | 1 - src/observer/omt/ob_multi_tenant.cpp | 57 +++++---- src/observer/omt/ob_multi_tenant.h | 2 + .../ob_tenant_mutil_allocator_mgr.cpp | 34 +++++- .../allocator/ob_tenant_mutil_allocator_mgr.h | 2 + src/share/parameter/ob_parameter_seed.ipp | 2 +- src/sql/dtl/ob_dtl_channel_mem_manager.cpp | 18 ++- src/sql/dtl/ob_dtl_channel_mem_manager.h | 9 +- src/storage/tx_storage/ob_tenant_freezer.cpp | 110 +++++++++++------- src/storage/tx_storage/ob_tenant_freezer.h | 10 +- .../tx_storage/ob_tenant_freezer_common.cpp | 8 ++ .../tx_storage/ob_tenant_freezer_common.h | 1 + 13 files changed, 170 insertions(+), 101 deletions(-) diff --git a/src/observer/ob_server_reload_config.cpp b/src/observer/ob_server_reload_config.cpp index d360db0fe..50728190d 100644 --- a/src/observer/ob_server_reload_config.cpp +++ b/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); - } -} diff --git a/src/observer/ob_server_reload_config.h b/src/observer/ob_server_reload_config.h index 43170af78..5755b3846 100644 --- a/src/observer/ob_server_reload_config.h +++ b/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_(); diff --git a/src/observer/omt/ob_multi_tenant.cpp b/src/observer/omt/ob_multi_tenant.cpp index ae9cbd5e8..47c8d4e62 100644 --- a/src/observer/omt/ob_multi_tenant.cpp +++ b/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_mem_limit(const uint64_t tenant_id, - const int64_t tenant_min_mem, - const int64_t tenant_max_mem) +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 + if (tenant_id != MTL_ID() && OB_FAIL(guard.switch_to(tenant_id))) { + LOG_WARN("switch tenant failed", K(ret), K(tenant_id)); } else if (FALSE_IT(freezer = MTL(ObTenantFreezer *))) { - } else if (OB_FAIL(freezer->get_tenant_mem_limit(before_min_mem, before_max_mem))) { - if (OB_NOT_REGISTERED == ret) {//tenant mem limit has not been setted - ret = OB_SUCCESS; - } 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); + } else if (freezer->is_tenant_mem_changed(tenant_min_mem, tenant_max_mem)) { + if (OB_FAIL(freezer->set_tenant_mem_limit(tenant_min_mem, tenant_max_mem))) { + LOG_WARN("set tenant mem limit failed", K(ret)); } } return ret; diff --git a/src/observer/omt/ob_multi_tenant.h b/src/observer/omt/ob_multi_tenant.h index 95af0cf56..fb612f4f8 100644 --- a/src/observer/omt/ob_multi_tenant.h +++ b/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 { diff --git a/src/share/allocator/ob_tenant_mutil_allocator_mgr.cpp b/src/share/allocator/ob_tenant_mutil_allocator_mgr.cpp index 1e4cafa7e..cb833c4ad 100644 --- a/src/share/allocator/ob_tenant_mutil_allocator_mgr.cpp +++ b/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))) { diff --git a/src/share/allocator/ob_tenant_mutil_allocator_mgr.h b/src/share/allocator/ob_tenant_mutil_allocator_mgr.h index 050094da4..671cf8ff9 100644 --- a/src/share/allocator/ob_tenant_mutil_allocator_mgr.h +++ b/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); diff --git a/src/share/parameter/ob_parameter_seed.ipp b/src/share/parameter/ob_parameter_seed.ipp index 5f1e373b8..b1251d007 100755 --- a/src/share/parameter/ob_parameter_seed.ipp +++ b/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)", diff --git a/src/sql/dtl/ob_dtl_channel_mem_manager.cpp b/src/sql/dtl/ob_dtl_channel_mem_manager.cpp index b38560138..9ed8943d6 100644 --- a/src/sql/dtl/ob_dtl_channel_mem_manager.cpp +++ b/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_); diff --git a/src/sql/dtl/ob_dtl_channel_mem_manager.h b/src/sql/dtl/ob_dtl_channel_mem_manager.h index f05ba048c..6e714dc48 100644 --- a/src/sql/dtl/ob_dtl_channel_mem_manager.h +++ b/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(); } diff --git a/src/storage/tx_storage/ob_tenant_freezer.cpp b/src/storage/tx_storage/ob_tenant_freezer.cpp index 7d11a0b28..d2583414c 100755 --- a/src/storage/tx_storage/ob_tenant_freezer.cpp +++ b/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.config_)) { + OB_ISNULL(GCTX.rs_mgr_)) { 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_), - K(GCONF.self_addr_)); + KP(GCTX.rs_rpc_proxy_), KP(GCTX.rs_mgr_), 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,9 +787,38 @@ int ObTenantFreezer::unset_tenant_slow_freeze(const common::ObTabletID &tablet_i return ret; } -int ObTenantFreezer::set_tenant_mem_limit( - const int64_t lower_limit, - const int64_t upper_limit) +bool ObTenantFreezer::is_tenant_mem_changed(const int64_t curr_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; if (!is_inited_) { @@ -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_(); - if ((NULL != config_) && - (((int64_t)(config_->memstore_limit_percentage)) > 100 || - ((int64_t)(config_->memstore_limit_percentage)) <= 0 || - freeze_trigger_percentage > 100 || - freeze_trigger_percentage <= 0)) { + const int64_t freeze_trigger_percentage = get_freeze_trigger_percentage_(); + const int64_t memstore_limit_percent = get_memstore_limit_percentage_(); + if (memstore_limit_percent > 100 || + memstore_limit_percent <= 0 || + freeze_trigger_percentage > 100 || + 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,15 +846,11 @@ 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(config_->memstore_limit_percentage); - } + tenant_info_.update_memstore_limit(memstore_limit_percent); 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_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", @@ -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_) { - ret = OB_ERR_UNEXPECTED; - 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 + } else if (memstore_limit_percent > 100 + || memstore_limit_percent <= 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 { - if (true == tenant_info_.is_loaded_) { - tenant_info_.update_memstore_limit(config_->memstore_limit_percentage); - } - } - if (OB_SUCCESS == ret) { + } else if (true == tenant_info_.is_loaded_ && + tenant_info_.is_memstore_limit_changed(memstore_limit_percent)) { + tenant_info_.update_memstore_limit(memstore_limit_percent); 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( diff --git a/src/storage/tx_storage/ob_tenant_freezer.h b/src/storage/tx_storage/ob_tenant_freezer.h index 63a36d6fe..9af7b8f24 100755 --- a/src/storage/tx_storage/ob_tenant_freezer.h +++ b/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_; diff --git a/src/storage/tx_storage/ob_tenant_freezer_common.cpp b/src/storage/tx_storage/ob_tenant_freezer_common.cpp index 343722103..9162a6d31 100644 --- a/src/storage/tx_storage/ob_tenant_freezer_common.cpp +++ b/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_); diff --git a/src/storage/tx_storage/ob_tenant_freezer_common.h b/src/storage/tx_storage/ob_tenant_freezer_common.h index a8a722a77..f0e7516e3 100644 --- a/src/storage/tx_storage/ob_tenant_freezer_common.h +++ b/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.