change: incremental-compact改为progressive-compact

Author: chenbt-hz

conf/pika.conf

@@ -677,9 +677,9 @@ wash-data: true
 
 # Pika automatic compact compact strategy, a complement to rocksdb compact.
 # Trigger the compact background task periodically according to `compact-interval`
-# Can choose `full-compact`, `obd-compact` or `incremental-compact`.
+# Can choose `full-compact`, `obd-compact` or `progressive-compact`.
 # obd-compact https://github.com/OpenAtomFoundation/pika/issues/2255
-# incremental-compact: incremental compact using CompactFiles, processes a small number of oldest SST files each time
+# progressive-compact: progressive compact using CompactFiles, processes a small number of oldest SST files each time
 compaction-strategy : obd-compact
 
 # For OBD_Compact 
@@ -711,19 +711,19 @@ dont-compact-sst-created-in-seconds : 20
 best-delete-min-ratio : 10
 
 # ============================================
-# For incremental-compact (when compaction-strategy = incremental-compact)
+# For progressive-compact (when compaction-strategy = progressive-compact)
 # ============================================
 # Execution interval in seconds
-incremental-compact-interval : 60
+progressive-compact-interval : 60
 
 # Maximum number of files to compact per run
-incremental-compact-max-files : 1
+progressive-compact-max-files : 1
 
 # Maximum execution time per run in milliseconds
-incremental-compact-max-time-ms : 1000
+progressive-compact-max-time-ms : 1000
 
 # Compression rate threshold (%), continue processing if rate is below this value
-incremental-compact-min-rate : 70
+progressive-compact-min-rate : 70
 
 # Minimum file age in seconds to be considered for compaction
-incremental-compact-min-file-age : 60
+progressive-compact-min-file-age : 60

include/pika_conf.h

@@ -34,7 +34,7 @@ class PikaConf : public pstd::BaseConf {
     NONE,
     FullCompact,
     OldestOrBestDeleteRatioSstCompact,
-    IncrementalCompact
+    ProgressiveCompact
   };
   PikaConf(const std::string& path);
   ~PikaConf() override = default;
@@ -148,25 +148,25 @@ class PikaConf : public pstd::BaseConf {
     std::shared_lock l(rwlock_);
     return compaction_strategy_;
   }
-  int incremental_compact_interval() {
+  int progressive_compact_interval() {
     std::shared_lock l(rwlock_);
-    return incremental_compact_interval_;
+    return progressive_compact_interval_;
   }
-  int incremental_compact_max_files() {
+  int progressive_compact_max_files() {
     std::shared_lock l(rwlock_);
-    return incremental_compact_max_files_;
+    return progressive_compact_max_files_;
   }
-  int incremental_compact_max_time_ms() {
+  int progressive_compact_max_time_ms() {
     std::shared_lock l(rwlock_);
-    return incremental_compact_max_time_ms_;
+    return progressive_compact_max_time_ms_;
   }
-  int incremental_compact_min_rate() {
+  int progressive_compact_min_rate() {
     std::shared_lock l(rwlock_);
-    return incremental_compact_min_rate_;
+    return progressive_compact_min_rate_;
   }
-  int incremental_compact_min_file_age() {
+  int progressive_compact_min_file_age() {
     std::shared_lock l(rwlock_);
-    return incremental_compact_min_file_age_;
+    return progressive_compact_min_file_age_;
   }
   bool disable_auto_compactions() {
     std::shared_lock l(rwlock_);
@@ -751,8 +751,8 @@ class PikaConf : public pstd::BaseConf {
       compaction_strategy_ = FullCompact;
     } else if (value == "obd-compact") {
       compaction_strategy_ = OldestOrBestDeleteRatioSstCompact;
-    } else if (value == "incremental-compact") {
-      compaction_strategy_ = IncrementalCompact;
+    } else if (value == "progressive-compact") {
+      compaction_strategy_ = ProgressiveCompact;
     } else {
       compaction_strategy_ = NONE;
     }
@@ -762,30 +762,30 @@ class PikaConf : public pstd::BaseConf {
     TryPushDiffCommands("disable_auto_compactions", value);
     disable_auto_compactions_ = value == "true";
   }
-  void SetIncrementalCompactInterval(const int value) {
+  void SetProgressiveCompactInterval(const int value) {
     std::lock_guard l(rwlock_);
-    TryPushDiffCommands("incremental-compact-interval", std::to_string(value));
-    incremental_compact_interval_ = value;
+    TryPushDiffCommands("progressive-compact-interval", std::to_string(value));
+    progressive_compact_interval_ = value;
   }
-  void SetIncrementalCompactMaxFiles(const int value) {
+  void SetProgressiveCompactMaxFiles(const int value) {
     std::lock_guard l(rwlock_);
-    TryPushDiffCommands("incremental-compact-max-files", std::to_string(value));
-    incremental_compact_max_files_ = value;
+    TryPushDiffCommands("progressive-compact-max-files", std::to_string(value));
+    progressive_compact_max_files_ = value;
   }
-  void SetIncrementalCompactMaxTimeMs(const int value) {
+  void SetProgressiveCompactMaxTimeMs(const int value) {
     std::lock_guard l(rwlock_);
-    TryPushDiffCommands("incremental-compact-max-time-ms", std::to_string(value));
-    incremental_compact_max_time_ms_ = value;
+    TryPushDiffCommands("progressive-compact-max-time-ms", std::to_string(value));
+    progressive_compact_max_time_ms_ = value;
   }
-  void SetIncrementalCompactMinRate(const int value) {
+  void SetProgressiveCompactMinRate(const int value) {
     std::lock_guard l(rwlock_);
-    TryPushDiffCommands("incremental-compact-min-rate", std::to_string(value));
-    incremental_compact_min_rate_ = value;
+    TryPushDiffCommands("progressive-compact-min-rate", std::to_string(value));
+    progressive_compact_min_rate_ = value;
   }
-  void SetIncrementalCompactMinFileAge(const int value) {
+  void SetProgressiveCompactMinFileAge(const int value) {
     std::lock_guard l(rwlock_);
-    TryPushDiffCommands("incremental-compact-min-file-age", std::to_string(value));
-    incremental_compact_min_file_age_ = value;
+    TryPushDiffCommands("progressive-compact-min-file-age", std::to_string(value));
+    progressive_compact_min_file_age_ = value;
   }
   void SetMaxSubcompactions(const int& value) {
     std::lock_guard l(rwlock_);
@@ -1099,12 +1099,12 @@ class PikaConf : public pstd::BaseConf {
   int best_delete_min_ratio_;
   CompactionStrategy compaction_strategy_;
 
-  // for incremental-compact
-  int incremental_compact_interval_ = 60;
-  int incremental_compact_max_files_ = 1;
-  int incremental_compact_max_time_ms_ = 1000;
-  int incremental_compact_min_rate_ = 70;
-  int incremental_compact_min_file_age_ = 60;
+  // for progressive-compact
+  int progressive_compact_interval_ = 60;
+  int progressive_compact_max_files_ = 1;
+  int progressive_compact_max_time_ms_ = 1000;
+  int progressive_compact_min_rate_ = 70;
+  int progressive_compact_min_file_age_ = 60;
 
   int64_t resume_check_interval_ = 60; // seconds
   int64_t least_free_disk_to_resume_ = 268435456; // 256 MB

include/pika_db.h

@@ -133,7 +133,7 @@ class DB : public std::enable_shared_from_this<DB>, public pstd::noncopyable {
   void Compact(const storage::DataType& type);
   void CompactRange(const storage::DataType& type, const std::string& start, const std::string& end);
   void LongestNotCompactionSstCompact(const storage::DataType& type);
-  void IncrementalCompact(const storage::DataType& type);
+  void ProgressiveCompact(const storage::DataType& type);
 
   void SetCompactRangeOptions(const bool is_canceled);
 

include/pika_server.h

@@ -60,7 +60,7 @@ enum TaskType {
   kBgSave,
   kCompactRangeAll,
   kCompactOldestOrBestDeleteRatioSst,
-  kIncrementalCompact,
+  kProgressiveCompact,
 };
 
 struct TaskArg {
@@ -551,7 +551,7 @@ class PikaServer : public pstd::noncopyable {
    */
   bool have_scheduled_crontask_ = false;
   struct timeval last_check_compact_time_;
-  struct timeval last_incremental_compact_time_ = {0, 0};
+  struct timeval last_progressive_compact_time_ = {0, 0};
 
   /*
    * ResumeDB used

src/pika_admin.cc

@@ -2012,30 +2012,30 @@ void ConfigCmd::ConfigGet(std::string& ret) {
     EncodeString(&config_body, "disable_auto_compactions");
     EncodeString(&config_body, g_pika_conf->disable_auto_compactions() ? "true" : "false");
   }
-  if (pstd::stringmatch(pattern.data(), "incremental-compact-interval", 1) != 0) {
+  if (pstd::stringmatch(pattern.data(), "progressive-compact-interval", 1) != 0) {
     elements += 2;
-    EncodeString(&config_body, "incremental-compact-interval");
-    EncodeNumber(&config_body, g_pika_conf->incremental_compact_interval());
+    EncodeString(&config_body, "progressive-compact-interval");
+    EncodeNumber(&config_body, g_pika_conf->progressive_compact_interval());
   }
-  if (pstd::stringmatch(pattern.data(), "incremental-compact-max-files", 1) != 0) {
+  if (pstd::stringmatch(pattern.data(), "progressive-compact-max-files", 1) != 0) {
     elements += 2;
-    EncodeString(&config_body, "incremental-compact-max-files");
-    EncodeNumber(&config_body, g_pika_conf->incremental_compact_max_files());
+    EncodeString(&config_body, "progressive-compact-max-files");
+    EncodeNumber(&config_body, g_pika_conf->progressive_compact_max_files());
   }
-  if (pstd::stringmatch(pattern.data(), "incremental-compact-max-time-ms", 1) != 0) {
+  if (pstd::stringmatch(pattern.data(), "progressive-compact-max-time-ms", 1) != 0) {
     elements += 2;
-    EncodeString(&config_body, "incremental-compact-max-time-ms");
-    EncodeNumber(&config_body, g_pika_conf->incremental_compact_max_time_ms());
+    EncodeString(&config_body, "progressive-compact-max-time-ms");
+    EncodeNumber(&config_body, g_pika_conf->progressive_compact_max_time_ms());
   }
-  if (pstd::stringmatch(pattern.data(), "incremental-compact-min-rate", 1) != 0) {
+  if (pstd::stringmatch(pattern.data(), "progressive-compact-min-rate", 1) != 0) {
     elements += 2;
-    EncodeString(&config_body, "incremental-compact-min-rate");
-    EncodeNumber(&config_body, g_pika_conf->incremental_compact_min_rate());
+    EncodeString(&config_body, "progressive-compact-min-rate");
+    EncodeNumber(&config_body, g_pika_conf->progressive_compact_min_rate());
   }
-  if (pstd::stringmatch(pattern.data(), "incremental-compact-min-file-age", 1) != 0) {
+  if (pstd::stringmatch(pattern.data(), "progressive-compact-min-file-age", 1) != 0) {
     elements += 2;
-    EncodeString(&config_body, "incremental-compact-min-file-age");
-    EncodeNumber(&config_body, g_pika_conf->incremental_compact_min_file_age());
+    EncodeString(&config_body, "progressive-compact-min-file-age");
+    EncodeNumber(&config_body, g_pika_conf->progressive_compact_min_file_age());
   }
   if (pstd::stringmatch(pattern.data(), "compaction-strategy", 1) != 0) {
     elements += 2;
@@ -2048,8 +2048,8 @@ void ConfigCmd::ConfigGet(std::string& ret) {
       case PikaConf::OldestOrBestDeleteRatioSstCompact:
         cs = "obd-compact";
         break;
-      case PikaConf::IncrementalCompact:
-        cs = "incremental-compact";
+      case PikaConf::ProgressiveCompact:
+        cs = "progressive-compact";
         break;
       default:
         cs = "none";
@@ -2390,11 +2390,11 @@ void ConfigCmd::ConfigSet(std::shared_ptr<DB> db) {
         "compact-cron",
         "compact-interval",
         "disable_auto_compactions",
-        "incremental-compact-interval",
-        "incremental-compact-max-files",
-        "incremental-compact-max-time-ms",
-        "incremental-compact-min-rate",
-        "incremental-compact-min-file-age",
+        "progressive-compact-interval",
+        "progressive-compact-max-files",
+        "progressive-compact-max-time-ms",
+        "progressive-compact-min-rate",
+        "progressive-compact-min-file-age",
         "compaction-strategy",
         "slave-priority",
         "sync-window-size",
@@ -2614,44 +2614,44 @@ void ConfigCmd::ConfigSet(std::shared_ptr<DB> db) {
     }
     g_pika_conf->SetDisableAutoCompaction(value);
     res_.AppendStringRaw("+OK\r\n");
-  } else if (set_item == "incremental-compact-interval") {
+  } else if (set_item == "progressive-compact-interval") {
     if (pstd::string2int(value.data(), value.size(), &ival) == 0 || ival <= 0) {
-      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'incremental-compact-interval'\r\n");
+      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'progressive-compact-interval'\r\n");
       return;
     }
-    g_pika_conf->SetIncrementalCompactInterval(static_cast<int>(ival));
+    g_pika_conf->SetProgressiveCompactInterval(static_cast<int>(ival));
     res_.AppendStringRaw("+OK\r\n");
-  } else if (set_item == "incremental-compact-max-files") {
+  } else if (set_item == "progressive-compact-max-files") {
     if (pstd::string2int(value.data(), value.size(), &ival) == 0 || ival <= 0) {
-      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'incremental-compact-max-files'\r\n");
+      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'progressive-compact-max-files'\r\n");
       return;
     }
-    g_pika_conf->SetIncrementalCompactMaxFiles(static_cast<int>(ival));
+    g_pika_conf->SetProgressiveCompactMaxFiles(static_cast<int>(ival));
     res_.AppendStringRaw("+OK\r\n");
-  } else if (set_item == "incremental-compact-max-time-ms") {
+  } else if (set_item == "progressive-compact-max-time-ms") {
     if (pstd::string2int(value.data(), value.size(), &ival) == 0 || ival <= 0) {
-      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'incremental-compact-max-time-ms'\r\n");
+      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'progressive-compact-max-time-ms'\r\n");
       return;
     }
-    g_pika_conf->SetIncrementalCompactMaxTimeMs(static_cast<int>(ival));
+    g_pika_conf->SetProgressiveCompactMaxTimeMs(static_cast<int>(ival));
     res_.AppendStringRaw("+OK\r\n");
-  } else if (set_item == "incremental-compact-min-rate") {
+  } else if (set_item == "progressive-compact-min-rate") {
     if (pstd::string2int(value.data(), value.size(), &ival) == 0 || ival <= 0 || ival > 100) {
-      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'incremental-compact-min-rate'\r\n");
+      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'progressive-compact-min-rate'\r\n");
       return;
     }
-    g_pika_conf->SetIncrementalCompactMinRate(static_cast<int>(ival));
+    g_pika_conf->SetProgressiveCompactMinRate(static_cast<int>(ival));
     res_.AppendStringRaw("+OK\r\n");
-  } else if (set_item == "incremental-compact-min-file-age") {
+  } else if (set_item == "progressive-compact-min-file-age") {
     if (pstd::string2int(value.data(), value.size(), &ival) == 0 || ival < 0) {
-      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'incremental-compact-min-file-age'\r\n");
+      res_.AppendStringRaw("-ERR Invalid argument \'" + value + "\' for CONFIG SET 'progressive-compact-min-file-age'\r\n");
       return;
     }
-    g_pika_conf->SetIncrementalCompactMinFileAge(static_cast<int>(ival));
+    g_pika_conf->SetProgressiveCompactMinFileAge(static_cast<int>(ival));
     res_.AppendStringRaw("+OK\r\n");
   } else if (set_item == "compaction-strategy") {
     if (value != "full-compact" && value != "obd-compact" &&
-        value != "incremental-compact" && value != "none") {
+        value != "progressive-compact" && value != "none") {
       res_.AppendStringRaw("-ERR Invalid argument \'" + value +
                            "\' for CONFIG SET 'compaction-strategy'\r\n");
       return;

src/pika_conf.cc

@@ -341,32 +341,32 @@ int PikaConf::Load() {
     compaction_strategy_ = FullCompact;
   } else if (cs_ == "obd-compact") {
     compaction_strategy_ = OldestOrBestDeleteRatioSstCompact;
-  } else if (cs_ == "incremental-compact") {
-    compaction_strategy_ = IncrementalCompact;
+  } else if (cs_ == "progressive-compact") {
+    compaction_strategy_ = ProgressiveCompact;
   } else {
     compaction_strategy_ = NONE;
   }
 
-  // for incremental-compact
-  GetConfInt("incremental-compact-interval", &incremental_compact_interval_);
-  if (incremental_compact_interval_ <= 0) {
-    incremental_compact_interval_ = 60;
+  // for progressive-compact
+  GetConfInt("progressive-compact-interval", &progressive_compact_interval_);
+  if (progressive_compact_interval_ <= 0) {
+    progressive_compact_interval_ = 60;
   }
-  GetConfInt("incremental-compact-max-files", &incremental_compact_max_files_);
-  if (incremental_compact_max_files_ <= 0) {
-    incremental_compact_max_files_ = 1;
+  GetConfInt("progressive-compact-max-files", &progressive_compact_max_files_);
+  if (progressive_compact_max_files_ <= 0) {
+    progressive_compact_max_files_ = 1;
   }
-  GetConfInt("incremental-compact-max-time-ms", &incremental_compact_max_time_ms_);
-  if (incremental_compact_max_time_ms_ <= 0) {
-    incremental_compact_max_time_ms_ = 1000;
+  GetConfInt("progressive-compact-max-time-ms", &progressive_compact_max_time_ms_);
+  if (progressive_compact_max_time_ms_ <= 0) {
+    progressive_compact_max_time_ms_ = 1000;
   }
-  GetConfInt("incremental-compact-min-rate", &incremental_compact_min_rate_);
-  if (incremental_compact_min_rate_ <= 0 || incremental_compact_min_rate_ > 100) {
-    incremental_compact_min_rate_ = 70;
+  GetConfInt("progressive-compact-min-rate", &progressive_compact_min_rate_);
+  if (progressive_compact_min_rate_ <= 0 || progressive_compact_min_rate_ > 100) {
+    progressive_compact_min_rate_ = 70;
   }
-  GetConfInt("incremental-compact-min-file-age", &incremental_compact_min_file_age_);
-  if (incremental_compact_min_file_age_ < 0) {
-    incremental_compact_min_file_age_ = 60;
+  GetConfInt("progressive-compact-min-file-age", &progressive_compact_min_file_age_);
+  if (progressive_compact_min_file_age_ < 0) {
+    progressive_compact_min_file_age_ = 60;
   }
 
   // least-free-disk-resume-size
@@ -916,17 +916,17 @@ int PikaConf::ConfigRewrite() {
     cs_ = "full-compact";
   } else if (compaction_strategy_ == OldestOrBestDeleteRatioSstCompact) {
     cs_ = "obd-compact";
-  } else if (compaction_strategy_ == IncrementalCompact) {
-    cs_ = "incremental-compact";
+  } else if (compaction_strategy_ == ProgressiveCompact) {
+    cs_ = "progressive-compact";
   }
   SetConfStr("compaction-strategy", cs_);
 
-  // for incremental-compact config update
-  SetConfInt("incremental-compact-interval", incremental_compact_interval_);
-  SetConfInt("incremental-compact-max-files", incremental_compact_max_files_);
-  SetConfInt("incremental-compact-max-time-ms", incremental_compact_max_time_ms_);
-  SetConfInt("incremental-compact-min-rate", incremental_compact_min_rate_);
-  SetConfInt("incremental-compact-min-file-age", incremental_compact_min_file_age_);
+  // for progressive-compact config update
+  SetConfInt("progressive-compact-interval", progressive_compact_interval_);
+  SetConfInt("progressive-compact-max-files", progressive_compact_max_files_);
+  SetConfInt("progressive-compact-max-time-ms", progressive_compact_max_time_ms_);
+  SetConfInt("progressive-compact-min-rate", progressive_compact_min_rate_);
+  SetConfInt("progressive-compact-min-file-age", progressive_compact_min_file_age_);
 
   SetConfStr("disable_auto_compactions", disable_auto_compactions_ ? "true" : "false");
   SetConfStr("cache-type", scachetype);