default system_memory and hidden_sys_tenant_memory

src/share/config/ob_server_config.cpp

@@ -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 (memory_limit < (1 << 30) ) {
-  if (0 == system_memory) {
+    // The memory_limit should not be less than 1G for arbitration mode
-    int64_t memory_limit_g = memory_limit >> 30;
+    ret = OB_INVALID_CONFIG;
-    if (memory_limit_g < 1) {
-      // memory_limit should not be less than 1G for 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 (is_arbitration_mode) {
-      // keep system_memory = 0 for arbitration mode
+    // do nothing
-    } else if (memory_limit_g < 4) {
+  } else if (0 == system_memory) {
-      // memory_limit should not be less than 4G for non arbitration mode
+    system_memory = get_capacity_default_memory(SYSTEM_MEMORY, memory_limit);
-      is_valid_config = false;
+    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 (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;

src/share/config/ob_server_config.h

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

src/share/unit/ob_unit_resource.cpp

@@ -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
+      // SYS tenant MEMORY is auto computed by memory_limit
-      const int64_t sys_mem_based_on_svr_avail_mem = server_avail_memory * sys_tenant_default_memory_percentage / 100;
+      memory_size = GMEMCONF.get_capacity_default_memory(ObServerMemoryConfig::HIDDEN_SYS_MEMORY,
-      int64_t sys_mem = min(sys_mem_based_on_svr_avail_mem, sys_tenant_default_memory_max);
+                                                         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 = max(memory_size, __min_full_resource_pool_memory);
-
-      memory_size = sys_mem;
     } 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,

src/share/unit/ob_unit_resource.h

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