configurable to memory of hidden sys

src/observer/omt/ob_tenant_node_balancer.cpp

@@ -384,6 +384,26 @@ int ObTenantNodeBalancer::check_new_tenant(const ObUnitInfoGetter::ObTenantConfi
   return ret;
 }
 
+int ObTenantNodeBalancer::refresh_hidden_sys_memory()
+{
+  int ret = OB_SUCCESS;
+  int64_t sys_tenant_memory = 0;
+  int64_t allowed_mem_limit = 0;
+  ObTenant *tenant = nullptr;
+  if (OB_FAIL(omt_->get_tenant(OB_SYS_TENANT_ID, tenant))) {
+    LOG_WARN("get sys tenant failed", K(ret));
+  } else if (OB_ISNULL(tenant) || !tenant->is_hidden()) {
+    // do nothing
+  } else if (OB_FAIL(ObUnitResource::get_sys_tenant_default_memory(sys_tenant_memory))) {
+    LOG_WARN("get hidden sys tenant default memory failed", K(ret));
+  } else if (OB_FAIL(omt_->update_tenant_memory(OB_SYS_TENANT_ID, sys_tenant_memory, allowed_mem_limit))) {
+    LOG_WARN("update hidden sys tenant memory failed", K(ret));
+  } else {
+    LOG_INFO("update hidden sys tenant memory succeed ", K(allowed_mem_limit));
+  }
+  return ret;
+}
+
 void ObTenantNodeBalancer::periodically_check_tenant()
 {
   int ret = OB_SUCCESS;
@@ -527,6 +547,8 @@ int ObTenantNodeBalancer::refresh_tenant(TenantUnits &units)
     } else if (FALSE_IT(omt_->set_synced())) {
     } else if (OB_FAIL(check_del_tenants(local_units, units))) {
       LOG_WARN("check delete tenant fail", K(ret));
+    } else if (OB_FAIL(refresh_hidden_sys_memory())) {
+      LOG_WARN("refresh hidden sys memory failed", K(ret));
     }
   }
 

src/observer/omt/ob_tenant_node_balancer.h

@@ -81,6 +81,7 @@ private:
   int check_new_tenants(share::TenantUnits &units);
   int check_new_tenant(const share::ObUnitInfoGetter::ObTenantConfig &unit, const int64_t abs_timeout_us = INT64_MAX);
   int check_del_tenants(const share::TenantUnits &local_units, share::TenantUnits &units);
+  int refresh_hidden_sys_memory();
   void periodically_check_tenant();
   int fetch_effective_tenants(const share::TenantUnits &old_tenants, share::TenantUnits &new_tenants);
   int refresh_tenant(share::TenantUnits &units);

src/share/config/ob_config_helper.cpp

@@ -350,6 +350,16 @@ bool ObConfigMemoryLimitChecker::check(const ObConfigItem &t) const
   return is_valid;
 }
 
+bool ObConfigTenantMemoryChecker::check(const ObConfigItem &t) const
+{
+  bool is_valid = false;
+  int64_t value = ObConfigCapacityParser::get(t.str(), is_valid);
+  if (is_valid) {
+    is_valid = 0 == value || (value >= ObUnitResource::UNIT_MIN_MEMORY);
+  }
+  return is_valid;
+}
+
 bool ObConfigQueryRateLimitChecker::check(const ObConfigItem &t) const
 {
   bool is_valid = false;

src/share/config/ob_config_helper.h

@@ -345,6 +345,15 @@ private:
   DISALLOW_COPY_AND_ASSIGN(ObConfigMemoryLimitChecker);
 };
 
+class ObConfigTenantMemoryChecker
+  : public ObConfigChecker
+{
+public:
+  ObConfigTenantMemoryChecker() {}
+  virtual ~ObConfigTenantMemoryChecker() {};
+  bool check(const ObConfigItem &t) const;
+};
+
 class ObConfigUpgradeStageChecker : public ObConfigChecker
 {
 public:

src/share/parameter/ob_parameter_seed.ipp

@@ -282,6 +282,10 @@ DEF_DBL(server_cpu_quota_max, OB_CLUSTER_PARAMETER, "1", "[1,16]",
         "the number of maximal vCPUs allocated to the server tenant"
         "(a special internal tenant that exists on every observer). Range: [1, 16]",
         ObParameterAttr(Section::TENANT, Source::DEFAULT, EditLevel::STATIC_EFFECTIVE));
+DEF_CAP_WITH_CHECKER(_hidden_sys_tenant_memory, OB_CLUSTER_PARAMETER, "0M",
+        common::ObConfigTenantMemoryChecker, "[0M,)",
+        "the size of the memory reserved for hidden sys tenant, 0M means follow the adjusting value.",
+        ObParameterAttr(Section::TENANT, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
 DEF_DBL(location_cache_cpu_quota, OB_CLUSTER_PARAMETER, "5", "[0,10]",
         "the number of vCPUs allocated for the requests regarding location "
         "info of the core tables. Range: [0,10] in integer",

src/share/unit/ob_unit_resource.cpp

@@ -689,6 +689,7 @@ int ObUnitResource::get_sys_tenant_default_memory(int64_t &memory_size)
   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;
   const int64_t system_memory = GMEMCONF.get_reserved_server_memory();
   const int64_t server_memory_limit = GMEMCONF.get_server_memory_limit();
   const int64_t server_avail_memory = server_memory_limit - system_memory;
@@ -705,22 +706,35 @@ int ObUnitResource::get_sys_tenant_default_memory(int64_t &memory_size)
     LOG_ERROR("server available memory is little than __min_full_resource_pool_memory, can not create sys tenant. "
         "try adjust config '__min_full_resource_pool_memory', 'memory_limit' or 'system_memory'.",
         KR(ret), K(__min_full_resource_pool_memory), K(server_avail_memory), K(system_memory), K(server_memory_limit));
+  } else if (OB_UNLIKELY(server_avail_memory < sys_tenant_memory)) {
+    ret = OB_INVALID_CONFIG;
+    LOG_ERROR("server available memory is little than sys_tenant_memory, can not create sys tenant. "
+        "try adjust config 'sys_tenant_memory', 'memory_limit' or 'system_memory'.",
+        KR(ret), K(sys_tenant_memory), K(server_avail_memory), K(system_memory), K(server_memory_limit));
+  } else if (OB_UNLIKELY(0 != sys_tenant_memory && sys_tenant_memory < __min_full_resource_pool_memory)) {
+    ret = OB_INVALID_CONFIG;
+    LOG_ERROR("sys_tenant_memory is little than __min_full_resource_pool_memory, can not create sys tenant. "
+        "try adjust config 'sys_tenant_memory' or '__min_full_resource_pool_memory'.",
+        KR(ret), K(sys_tenant_memory), K(__min_full_resource_pool_memory));
   } else {
-    // SYS tenant MEMORY is auto computed by server_avail_memory
+    if (0 == sys_tenant_memory) {
-    const int64_t sys_mem_based_on_svr_avail_mem = server_avail_memory * sys_tenant_default_memory_percentage / 100;
+      // SYS tenant MEMORY is auto computed by server_avail_memory
-    int64_t sys_mem = min(sys_mem_based_on_svr_avail_mem, sys_tenant_default_memory_max);
+      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 restricted by UNIT_MIN_MEMORY
+      // SYS tenant MEMORY is restricted by UNIT_MIN_MEMORY
-    sys_mem = max(sys_mem, UNIT_MIN_MEMORY);
+      sys_mem = max(sys_mem, UNIT_MIN_MEMORY);
 
-    // SYS tenant MEMORY is restricted by __min_full_resource_pool_memory
+      // SYS tenant MEMORY is restricted by __min_full_resource_pool_memory
-    sys_mem = max(sys_mem, __min_full_resource_pool_memory);
+      sys_mem = max(sys_mem, __min_full_resource_pool_memory);
-
-    memory_size = sys_mem;
 
+      memory_size = sys_mem;
+    } else {
+      memory_size = sys_tenant_memory;
+    }
     LOG_INFO("get_sys_tenant_default_memory",
-        "sys_tenant_default_memory_G", sys_mem/GB,
+        "sys_tenant_default_memory_G", memory_size/GB,
-        "sys_mem_based_on_server_avail_mem_G", sys_mem_based_on_svr_avail_mem/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,
@@ -729,7 +743,6 @@ int ObUnitResource::get_sys_tenant_default_memory(int64_t &memory_size)
         "server_memory_limit_G", server_memory_limit/GB,
         "system_memory_G", system_memory/GB);
   }
-
   return ret;
 }
 

tools/deploy/mysql_test/test_suite/inner_table/r/mysql/all_virtual_sys_parameter_stat.result

@@ -273,6 +273,7 @@ _force_hash_groupby_dump
 _force_hash_join_spill
 _force_skip_encoding_partition_id
 _hash_area_size
+_hidden_sys_tenant_memory
 _ignore_system_memory_over_limit_error
 _io_callback_thread_count
 _large_query_io_percentage