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

default system_memory and hidden_sys_tenant_memory

Browse Source
This commit is contained in:
obdev
2023-05-08 03:12:02 +00:00
committed by ob-robot
parent 755ebe4fd8
commit 49bf773c92
4 changed files with 48 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
src/share/config/ob_server_config.cpp
View File

@ -216,6 +216,31 @@ ObServerMemoryConfig &ObServerMemoryConfig::get_instance()
return memory_config;
}
int64_t ObServerMemoryConfig::get_capacity_default_memory(CapacityType type, int64_t memory_limit)
{
// According to different memory_limit, the kernel can provide adaptive memory_size for default capacity.
// For example, memory_limit = 16G, adaptive system_memory and hidden_sys_memory are 6G and 2G.
static const int64_t memory_limit_array[] = {4LL<<30, 8LL<<30, 14LL<<30, 28LL<<30, 48LL<<30, 56LL<<30, 65LL<<30, 96LL<<30, 128LL<<30};
static const int64_t system_memory_array[] = {2LL<<30, 3LL<<30, 6LL<<30, 10LL<<30, 12LL<<30, 13LL<<30, 15LL<<30, 18LL<<30, 20LL<<30};
static const int64_t hidden_sys_memory_array[] = {1LL<<30, 2LL<<30, 2LL<<30, 2LL<<30, 4LL<<30, 4LL<<30, 6LL<<30, 7LL<<30, 8LL<<30};
int64_t memory_size = 0;
for (int i = ARRAYSIZEOF(memory_limit_array) - 1; i >= 0; --i) {
if (memory_limit_array[i] <= memory_limit) {
switch (type) {
case SYSTEM_MEMORY:
memory_size = system_memory_array[i];
break;
case HIDDEN_SYS_MEMORY:
memory_size = hidden_sys_memory_array[i];
break;
}
break;
}
}
return memory_size;
}
int ObServerMemoryConfig::reload_config(const ObServerConfig& server_config)
{
int ret = OB_SUCCESS;
@ -225,34 +250,22 @@ int ObServerMemoryConfig::reload_config(const ObServerConfig& server_config)
memory_limit = get_phy_mem_size() * server_config.memory_limit_percentage / 100;
}
int64_t system_memory = server_config.system_memory;
bool is_valid_config = true;
if (0 == system_memory) {
int64_t memory_limit_g = memory_limit >> 30;
if (memory_limit_g < 1) {
// memory_limit should not be less than 1G for arbitration mode
is_valid_config = false;
if (memory_limit < (1 << 30) ) {
// The memory_limit should not be less than 1G for arbitration mode
ret = OB_INVALID_CONFIG;
LOG_ERROR("memory_limit with unexpected value", K(ret), K(memory_limit), "phy mem", get_phy_mem_size());
} else if (is_arbitration_mode) {
// do nothing
} else if (0 == system_memory) {
system_memory = get_capacity_default_memory(SYSTEM_MEMORY, memory_limit);
if (0 == system_memory) {
ret = OB_INVALID_CONFIG;
LOG_ERROR("memory_limit with unexpected value", K(ret), K(memory_limit), "phy mem", get_phy_mem_size());
} else if (is_arbitration_mode) {
// keep system_memory = 0 for arbitration mode
} else if (memory_limit_g < 4) {
// memory_limit should not be less than 4G for non arbitration mode
is_valid_config = false;
LOG_ERROR("memory_limit with unexpected value", K(ret), K(memory_limit), "phy mem", get_phy_mem_size());
} else if (memory_limit_g <= 8) {
system_memory = 2LL << 30;
} else if (memory_limit_g <= 16) {
system_memory = 3LL << 30;
} else if (memory_limit_g <= 32) {
system_memory = 5LL << 30;
} else if (memory_limit_g <= 48) {
system_memory = 7LL << 30;
} else if (memory_limit_g <= 64) {
system_memory = 10LL << 30;
} else {
system_memory = int64_t(15 + 3 * (sqrt(memory_limit_g) - 8)) << 30;
}
}
if (!is_valid_config) {
if (OB_FAIL(ret)) {
// do nothing
} else if (memory_limit > system_memory) {
memory_limit_ = memory_limit;
system_memory_ = system_memory;

5
src/share/config/ob_server_config.h
View File

@ -144,10 +144,15 @@ private:
class ObServerMemoryConfig
{
public:
enum CapacityType {
SYSTEM_MEMORY,
HIDDEN_SYS_MEMORY,
};
friend class unittest::ObSimpleClusterTestBase;
ObServerMemoryConfig();
static ObServerMemoryConfig &get_instance();
int reload_config(const ObServerConfig& server_config);
int64_t get_capacity_default_memory(CapacityType type, int64_t memory_limit);
int64_t get_server_memory_limit() { return memory_limit_; }
int64_t get_reserved_server_memory() { return system_memory_; }
int64_t get_server_memory_avail() { return memory_limit_ - system_memory_; }

16
src/share/unit/ob_unit_resource.cpp
View File

@ -685,8 +685,6 @@ int ObUnitResource::gen_sys_tenant_default_unit_resource()
int ObUnitResource::get_sys_tenant_default_memory(int64_t &memory_size)
{
int ret = OB_SUCCESS;
const int64_t sys_tenant_default_memory_percentage = SYS_TENANT_DEFAULT_MEMORY_PERCENTAGE;
const int64_t sys_tenant_default_memory_max = SYS_TENANT_DEFAULT_MEMORY_MAX;
const int64_t unit_min_memory = UNIT_MIN_MEMORY;
const int64_t __min_full_resource_pool_memory = GCONF.__min_full_resource_pool_memory;
const int64_t sys_tenant_memory = GCONF._hidden_sys_tenant_memory;
@ -718,17 +716,15 @@ int ObUnitResource::get_sys_tenant_default_memory(int64_t &memory_size)
KR(ret), K(sys_tenant_memory), K(__min_full_resource_pool_memory));
} else {
if (0 == sys_tenant_memory) {
// SYS tenant MEMORY is auto computed by server_avail_memory
const int64_t sys_mem_based_on_svr_avail_mem = server_avail_memory * sys_tenant_default_memory_percentage / 100;
int64_t sys_mem = min(sys_mem_based_on_svr_avail_mem, sys_tenant_default_memory_max);
// SYS tenant MEMORY is auto computed by memory_limit
memory_size = GMEMCONF.get_capacity_default_memory(ObServerMemoryConfig::HIDDEN_SYS_MEMORY,
server_memory_limit);
// SYS tenant MEMORY is restricted by UNIT_MIN_MEMORY
sys_mem = max(sys_mem, UNIT_MIN_MEMORY);
memory_size = max(memory_size, UNIT_MIN_MEMORY);
// SYS tenant MEMORY is restricted by __min_full_resource_pool_memory
sys_mem = max(sys_mem, __min_full_resource_pool_memory);
memory_size = sys_mem;
memory_size = max(memory_size, __min_full_resource_pool_memory);
} else {
memory_size = sys_tenant_memory;
}
@ -736,8 +732,6 @@ int ObUnitResource::get_sys_tenant_default_memory(int64_t &memory_size)
"sys_tenant_default_memory_G", memory_size/GB,
"sys_tenant_memory_G", sys_tenant_memory/GB,
"server_avail_memory_G", server_avail_memory/GB,
K(sys_tenant_default_memory_percentage),
"sys_tenant_default_memory_max_G", sys_tenant_default_memory_max/GB,
"unit_min_memory_G", unit_min_memory/GB,
"__min_full_resource_pool_memory_G", __min_full_resource_pool_memory/GB,
"server_memory_limit_G", server_memory_limit/GB,

7
src/share/unit/ob_unit_resource.h
View File

@ -70,13 +70,6 @@ public:
static const int64_t META_TENANT_SAFE_MIN_MEMORY = 1 * GB;
static const int64_t UNIT_SAFE_MIN_MEMORY = 2 * META_TENANT_SAFE_MIN_MEMORY;
// SYS tenant MEMORY configurations
//
// SYS tenant default memory upper limit
static const int64_t SYS_TENANT_DEFAULT_MEMORY_MAX = 16L * GB;
// SYS tenant default memory percentage of server available memory
static const int64_t SYS_TENANT_DEFAULT_MEMORY_PERCENTAGE = 25;
////////////////////////// LOG DISK ////////////////////////////
// Unit LOG DISK SIZE is limited by LS replica. Every LS replica need 512M.
//