feat:Automated fast/slow command separation, help me

Author: brother-jin

conf/pika.conf

@@ -33,6 +33,19 @@ thread-pool-size : 12
 # When set to no, they are not separated.
 slow-cmd-pool : no
 
+# Enable thread pool borrowing mechanism, which allows threads to help each other when one pool is busy
+# and another is idle. This can improve resource utilization and reduce command latency under uneven load.
+# [yes | no] - The default value is yes.
+threadpool-borrow-enable : yes
+
+# The queue length threshold (as a percentage of max queue size) at which a thread pool is considered busy
+# and may borrow threads from another pool. The value range is [1-99], default is 80.
+threadpool-borrow-threshold-percent : 80
+
+# The queue length threshold (as a percentage of max queue size) at which a thread pool is considered idle
+# and may lend threads to another pool. The value range is [1-99], default is 20.
+threadpool-idle-threshold-percent : 20
+
 # Size of the low level thread pool, The threads within this pool
 # are dedicated to handling slow user requests.
 slow-cmd-thread-pool-size : 1

include/pika_conf.h

@@ -168,6 +168,18 @@ class PikaConf : public pstd::BaseConf {
     std::shared_lock l(rwlock_);
     return slow_cmd_pool_;
   }
+  bool threadpool_borrow_enable() {
+    std::shared_lock l(rwlock_);
+    return threadpool_borrow_enable_;
+  }
+  int threadpool_borrow_threshold_percent() {
+    std::shared_lock l(rwlock_);
+    return threadpool_borrow_threshold_percent_;
+  }
+  int threadpool_idle_threshold_percent() {
+    std::shared_lock l(rwlock_);
+    return threadpool_idle_threshold_percent_;
+  }
   std::string server_id() {
     std::shared_lock l(rwlock_);
     return server_id_;
@@ -942,6 +954,11 @@ class PikaConf : public pstd::BaseConf {
   std::string bgsave_prefix_;
   std::string pidfile_;
   std::atomic<bool> slow_cmd_pool_;
+  
+  // Thread pool task borrowing configuration
+  bool threadpool_borrow_enable_ = true;
+  int threadpool_borrow_threshold_percent_ = 80;
+  int threadpool_idle_threshold_percent_ = 20;
 
   std::string compression_;
   std::string compression_per_level_;

src/pika_conf.cc

@@ -76,6 +76,20 @@ int PikaConf::Load() {
   GetConfStr("slow-cmd-pool", &slowcmdpool);
   slow_cmd_pool_.store(slowcmdpool == "yes" ? true : false);
 
+  std::string threadpool_borrow;
+  GetConfStr("threadpool-borrow-enable", &threadpool_borrow);
+  threadpool_borrow_enable_ = threadpool_borrow == "yes" ? true : false;
+
+  GetConfInt("threadpool-borrow-threshold-percent", &threadpool_borrow_threshold_percent_);
+  if (threadpool_borrow_threshold_percent_ <= 0 || threadpool_borrow_threshold_percent_ >= 100) {
+    threadpool_borrow_threshold_percent_ = 80;
+  }
+
+  GetConfInt("threadpool-idle-threshold-percent", &threadpool_idle_threshold_percent_);
+  if (threadpool_idle_threshold_percent_ <= 0 || threadpool_idle_threshold_percent_ >= 100) {
+    threadpool_idle_threshold_percent_ = 20;
+  }
+
   int binlog_writer_num = 1;
   GetConfInt("binlog-writer-num", &binlog_writer_num);
   if (binlog_writer_num <= 0 || binlog_writer_num > 24) {

src/pika_server.cc

@@ -770,15 +770,66 @@ void PikaServer::SetFirstMetaSync(bool v) {
 }
 
 void PikaServer::ScheduleClientPool(net::TaskFunc func, void* arg, bool is_slow_cmd, bool is_admin_cmd) {
-  if (is_slow_cmd && g_pika_conf->slow_cmd_pool()) {
-    pika_slow_cmd_thread_pool_->Schedule(func, arg);
-    return;
-  }
+  // Admin commands always go to admin thread pool
   if (is_admin_cmd) {
     pika_admin_cmd_thread_pool_->Schedule(func, arg);
     return;
   }
-  pika_client_processor_->SchedulePool(func, arg);
+
+  // Check if thread pool borrowing is enabled
+  bool borrow_enable = g_pika_conf->threadpool_borrow_enable();
+  bool slow_cmd_pool_enable = g_pika_conf->slow_cmd_pool();
+  
+  if (!borrow_enable || !slow_cmd_pool_enable) {
+    // Original logic: direct routing without borrowing
+    if (is_slow_cmd && slow_cmd_pool_enable) {
+      pika_slow_cmd_thread_pool_->Schedule(func, arg);
+      return;
+    }
+    pika_client_processor_->SchedulePool(func, arg);
+    return;
+  }
+
+  // Borrowing is enabled, check queue status and decide
+  size_t slow_queue_size = SlowCmdThreadPoolCurQueueSize();
+  size_t slow_max_queue = SlowCmdThreadPoolMaxQueueSize();
+  size_t fast_queue_size = ClientProcessorThreadPoolCurQueueSize();
+  size_t fast_max_queue = ClientProcessorThreadPoolMaxQueueSize();
+
+  int borrow_threshold_percent = g_pika_conf->threadpool_borrow_threshold_percent();
+  int idle_threshold_percent = g_pika_conf->threadpool_idle_threshold_percent();
+
+  // Calculate thresholds
+  size_t slow_borrow_threshold = slow_max_queue * borrow_threshold_percent / 100;
+  size_t fast_borrow_threshold = fast_max_queue * borrow_threshold_percent / 100;
+  size_t slow_idle_threshold = slow_max_queue * idle_threshold_percent / 100;
+  size_t fast_idle_threshold = fast_max_queue * idle_threshold_percent / 100;
+
+  if (is_slow_cmd) {
+    // This is a slow command
+    if (slow_queue_size >= slow_borrow_threshold && fast_queue_size <= fast_idle_threshold) {
+      // Slow pool is busy and fast pool is idle, borrow from fast pool
+      pika_client_processor_->SchedulePool(func, arg);
+      LOG(INFO) << "Slow cmd borrows fast pool (slow_queue: " << slow_queue_size 
+                << "/" << slow_max_queue << ", fast_queue: " << fast_queue_size 
+                << "/" << fast_max_queue << ")";
+    } else {
+      // Normal case: use slow pool
+      pika_slow_cmd_thread_pool_->Schedule(func, arg);
+    }
+  } else {
+    // This is a fast command
+    if (fast_queue_size >= fast_borrow_threshold && slow_queue_size <= slow_idle_threshold) {
+      // Fast pool is busy and slow pool is idle, borrow from slow pool
+      pika_slow_cmd_thread_pool_->Schedule(func, arg);
+      LOG(INFO) << "Fast cmd borrows slow pool (fast_queue: " << fast_queue_size 
+                << "/" << fast_max_queue << ", slow_queue: " << slow_queue_size 
+                << "/" << slow_max_queue << ")";
+    } else {
+      // Normal case: use fast pool
+      pika_client_processor_->SchedulePool(func, arg);
+    }
+  }
 }
 
 size_t PikaServer::ClientProcessorThreadPoolCurQueueSize() {

tools/pika_migrate/conf/pika.conf

@@ -132,7 +132,7 @@ masterauth :
 # The [password of user], which is empty by default.
 # [NOTICE] If this user password is the same as admin password (including both being empty),
 # the value of this parameter will be ignored and all users are considered as administrators,
-# in this scenario, users are not subject to the restrictions imposed by the userblacklist.
+# in this scenario, users are not subject to the restrictions imposed by the userb lacklist.
 # PS: "admin password" refers to value of the parameter above: requirepass.
 # userpass :
 
@@ -147,6 +147,7 @@ masterauth :
 # If set to 'classic', Pika will create multiple DBs whose number is the value of configure item "databases".
 instance-mode : classic
 
+
 # The number of databases when Pika runs in classic mode.
 # The default database id is DB 0. You can select a different one on
 # a per-connection by using SELECT. The db id range is [0, 'databases' value -1].