opt tenant cpu usage estimate for adaptive compaction

src/storage/blocksstable/ob_logic_macro_id.cpp

@@ -138,6 +138,10 @@ void ObLogicMacroBlockId::reset() {
   column_group_idx_ = 0;
 }
 
-OB_SERIALIZE_MEMBER(ObLogicMacroBlockId,  data_seq_, logic_version_, tablet_id_, info_);
+OB_SERIALIZE_MEMBER(ObLogicMacroBlockId,
+                    data_seq_, //FARM COMPAT WHITELIST: Type not match
+                    logic_version_,
+                    tablet_id_,
+                    info_);
 } // blocksstable
 } // oceanbase

src/storage/compaction/ob_tenant_tablet_scheduler.cpp

@@ -1483,20 +1483,17 @@ bool ObTenantTabletScheduler::get_enable_adaptive_compaction()
 {
   int ret = OB_SUCCESS;
   bool enable_adaptive_compaction = enable_adaptive_compaction_;
-  ObTenantSysStat cur_sys_stat;
+  if (!enable_adaptive_compaction || !enable_adaptive_merge_schedule_) {
-  if (!enable_adaptive_compaction) {
     // do nothing
 #ifdef ENABLE_DEBUG_LOG
   } else if (GCONF.enable_crazy_medium_compaction) {
     enable_adaptive_compaction = true;
     LOG_DEBUG("set crazy medium, set enable_adaptive_compaction = true");
 #endif
-  } else if (OB_FAIL(MTL(ObTenantTabletStatMgr *)->get_sys_stat(cur_sys_stat))) {
+  } else if (MTL(ObTenantTabletStatMgr *)->is_high_tenant_cpu_load()) {
-    LOG_WARN("failed to get tenant sys stat", K(ret), K(cur_sys_stat));
-  } else if (cur_sys_stat.is_full_cpu_usage()) {
     enable_adaptive_compaction = false;
     if (REACH_TENANT_TIME_INTERVAL(PRINT_LOG_INVERVAL)) {
-      FLOG_INFO("disable adaptive compaction due to the high load CPU", K(ret), K(cur_sys_stat));
+      FLOG_INFO("disable adaptive compaction due to the high load CPU", K(ret));
     }
   }
   return enable_adaptive_compaction;

src/storage/ob_tenant_tablet_stat_mgr.cpp

@@ -249,8 +249,7 @@ bool ObTabletStatAnalyzer::has_slow_query() const
 
 /************************************* ObTenantSysStat *************************************/
 ObTenantSysStat::ObTenantSysStat()
-  : cpu_usage_percentage_(0),
+  : min_cpu_cnt_(0),
-    min_cpu_cnt_(0),
     max_cpu_cnt_(0),
     memory_hold_(0),
     memory_limit_(0)
@@ -259,7 +258,6 @@ ObTenantSysStat::ObTenantSysStat()
 
 void ObTenantSysStat::reset()
 {
-  cpu_usage_percentage_ = 0;
   min_cpu_cnt_ = 0;
   max_cpu_cnt_ = 0;
   memory_hold_ = 0;
@@ -277,15 +275,18 @@ bool ObTenantSysStat::is_small_tenant() const
   return bret;
 }
 
-bool ObTenantSysStat::is_full_cpu_usage() const
+int ObTenantSysStat::refresh(const uint64_t tenant_id)
 {
-  bool bret = false;
+  int ret = OB_SUCCESS;
-  if (is_small_tenant()) {
+
-    bret = 75 <= cpu_usage_percentage_;
+  if (!REACH_TENANT_TIME_INTERVAL(300_s)) {
+  } else if (OB_FAIL(GCTX.omt_->get_tenant_cpu(tenant_id, min_cpu_cnt_, max_cpu_cnt_))) {
+    LOG_WARN("failed to get tenant cpu count", K(ret));
   } else {
-    bret = 85 <= cpu_usage_percentage_;
+    memory_hold_ = lib::get_tenant_memory_hold(tenant_id);
+    memory_limit_ = lib::get_tenant_memory_limit(tenant_id);
   }
-  return bret;
+  return ret;
 }
 
 
@@ -583,6 +584,7 @@ ObTenantTabletStatMgr::ObTenantTabletStatMgr()
     bucket_lock_(),
     report_queue_(),
     load_shedder_(),
+    sys_stat_(),
     report_cursor_(0),
     pending_cursor_(0),
     report_tg_id_(0),
@@ -619,7 +621,7 @@ int ObTenantTabletStatMgr::init(const int64_t tenant_id)
   } else if (OB_FAIL(TG_SCHEDULE(report_tg_id_, report_stat_task_, TABLET_STAT_PROCESS_INTERVAL, repeat))) {
     LOG_WARN("failed to schedule tablet stat update task", K(ret));
   } else {
-    load_shedder_.refresh_sys_load();
+    refresh_sys_stat();
     is_inited_ = true;
   }
   if (!is_inited_) {
@@ -672,6 +674,7 @@ void ObTenantTabletStatMgr::reset()
   }
   bucket_lock_.destroy();
   load_shedder_.reset();
+  sys_stat_.reset();
   FLOG_INFO("ObTenantTabletStatMgr destroyed!");
 }
 
@@ -821,37 +824,18 @@ int ObTenantTabletStatMgr::get_tablet_analyzer(
     ObTabletStatAnalyzer &analyzer)
 {
   int ret = OB_SUCCESS;
-  ObTenantSysStat sys_stat;
 
   if (OB_FAIL(get_latest_tablet_stat(ls_id, tablet_id, analyzer.tablet_stat_))) {
     if (OB_HASH_NOT_EXIST != ret) {
       LOG_WARN("failed to get latest tablet stat", K(ret), K(ls_id), K(tablet_id));
     }
-  } else if (OB_FAIL(get_sys_stat(sys_stat))) {
-    LOG_WARN("failed to get sys stat", K(ret));
   } else {
-    analyzer.is_small_tenant_ = sys_stat.is_small_tenant();
+    analyzer.is_small_tenant_ = sys_stat_.is_small_tenant();
     analyzer.boost_factor_ = analyzer.is_small_tenant_ ? 2 : 1;
   }
   return ret;
 }
 
-int ObTenantTabletStatMgr::get_sys_stat(ObTenantSysStat &sys_stat)
-{
-  int ret = OB_SUCCESS;
-
-  if (OB_FAIL(GCTX.omt_->get_tenant_cpu_usage(MTL_ID(), sys_stat.cpu_usage_percentage_))) {
-    LOG_WARN("failed to get tenant cpu usage", K(ret), K(sys_stat));
-  } else if (OB_FAIL(GCTX.omt_->get_tenant_cpu(MTL_ID(), sys_stat.min_cpu_cnt_, sys_stat.max_cpu_cnt_))) {
-    LOG_WARN("failed to get tenant cpu count", K(ret), K(sys_stat));
-  } else {
-    sys_stat.memory_hold_ = lib::get_tenant_memory_hold(MTL_ID());
-    sys_stat.memory_limit_ = lib::get_tenant_memory_limit(MTL_ID());
-    sys_stat.cpu_usage_percentage_ *= 100 * 100;
-  }
-  return ret;
-}
-
 int ObTenantTabletStatMgr::update_tablet_stream(const ObTabletStat &report_stat)
 {
   int ret = OB_SUCCESS;
@@ -959,10 +943,16 @@ void ObTenantTabletStatMgr::refresh_all(const int64_t step)
   }
 }
 
+void ObTenantTabletStatMgr::refresh_sys_stat()
+{
+  (void) sys_stat_.refresh(MTL_ID());
+  load_shedder_.refresh_sys_load();
+}
+
 void ObTenantTabletStatMgr::TabletStatUpdater::runTimerTask()
 {
   mgr_.process_stats();
-  mgr_.refresh_sys_load();
+  mgr_.refresh_sys_stat();
 
   int64_t interval_step = 0;
   if (CHECK_SCHEDULE_TIME_INTERVAL(CHECK_INTERVAL, interval_step)) {

src/storage/ob_tenant_tablet_stat_mgr.h

@@ -139,12 +139,10 @@ public:
   ~ObTenantSysStat() = default;
   void reset();
   bool is_small_tenant() const;
-  bool is_full_cpu_usage() const;
+  int refresh(const uint64_t tenant_id);
-  TO_STRING_KV(K_(cpu_usage_percentage), K_(min_cpu_cnt), K_(max_cpu_cnt), K_(memory_hold), K_(memory_limit));
+  TO_STRING_KV(K_(min_cpu_cnt), K_(max_cpu_cnt), K_(memory_hold), K_(memory_limit));
 
 public:
-  static constexpr double EPS = 1e-9;
-  double cpu_usage_percentage_;
   double min_cpu_cnt_;
   double max_cpu_cnt_;
   int64_t memory_hold_;
@@ -377,11 +375,11 @@ public:
   int clear_tablet_stat(
       const share::ObLSID &ls_id,
       const common::ObTabletID &tablet_id);
-  int get_sys_stat(ObTenantSysStat &sys_stat);
   void process_stats();
   void refresh_all(const int64_t step);
+  bool is_high_tenant_cpu_load() const { return get_load_shedding_factor() >= ObTenantSysLoadShedder::DEFAULT_LOAD_SHEDDING_FACTOR; }
   int64_t get_load_shedding_factor() const { return load_shedder_.get_load_shedding_factor(); }
-  void refresh_sys_load() { load_shedder_.refresh_sys_load(); }
+  void refresh_sys_stat();
 private:
   class TabletStatUpdater : public common::ObTimerTask
   {
@@ -421,6 +419,7 @@ private:
   common::ObBucketLock bucket_lock_;
   ObTabletStat report_queue_[DEFAULT_MAX_PENDING_CNT]; // 12 * 8 * 40000 bytes
   ObTenantSysLoadShedder load_shedder_;
+  ObTenantSysStat sys_stat_;
   uint64_t report_cursor_;
   uint64_t pending_cursor_;
   int report_tg_id_;