hcq/oceanbase
hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

FEATURE: change memstore_limit_percentage to tenant config

Browse Source
This commit is contained in:
obdev 2023-10-10 12:44:03 +00:00 committed by ob-robot
parent 424bb7628e
commit ff79506de2
13 changed files with 170 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/observer/ob_server_reload_config.cpp
View File

@ -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);
}
}

1
src/observer/ob_server_reload_config.h
View File

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

57
src/observer/omt/ob_multi_tenant.cpp
View File

@ -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;

2
src/observer/omt/ob_multi_tenant.h
View File

@ -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 {

34
src/share/allocator/ob_tenant_mutil_allocator_mgr.cpp
View File

@ -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))) {

2
src/share/allocator/ob_tenant_mutil_allocator_mgr.h
View File

@ -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);

2
src/share/parameter/ob_parameter_seed.ipp
View File

@ -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)",

18
src/sql/dtl/ob_dtl_channel_mem_manager.cpp
View File

@ -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_);

9
src/sql/dtl/ob_dtl_channel_mem_manager.h
View File

@ -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();
}

110
src/storage/tx_storage/ob_tenant_freezer.cpp
View File

@ -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(

10
src/storage/tx_storage/ob_tenant_freezer.h
View File

@ -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_;

8
src/storage/tx_storage/ob_tenant_freezer_common.cpp
View File

@ -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_);

1
src/storage/tx_storage/ob_tenant_freezer_common.h
View File

@ -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.