Rename to number of compaction sorted runs

db/db_compaction_test.cc

@@ -5857,16 +5857,16 @@ TEST_F(DBCompactionTest, CompactionStatsTest) {
   DestroyAndReopen(options);
 
   // Verify that the internal statistics for num_running_compactions and
-  // num_running_compaction_input_iterators start and end at valid states
+  // num_running_compaction_sorted_runs start and end at valid states
   uint64_t num_running_compactions = 0;
   ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kNumRunningCompactions,
                                   &num_running_compactions));
   ASSERT_EQ(num_running_compactions, 0);
-  uint64_t num_running_compaction_input_iterators = 0;
+  uint64_t num_running_compaction_sorted_runs = 0;
   ASSERT_TRUE(
-      db_->GetIntProperty(DB::Properties::kNumRunningCompactionInputIterators,
-                          &num_running_compaction_input_iterators));
-  ASSERT_EQ(num_running_compaction_input_iterators, 0);
+      db_->GetIntProperty(DB::Properties::kNumRunningCompactionSortedRuns,
+                          &num_running_compaction_sorted_runs));
+  ASSERT_EQ(num_running_compaction_sorted_runs, 0);
 
   for (int i = 0; i < 32; i++) {
     for (int j = 0; j < 5000; j++) {
@@ -5882,14 +5882,14 @@ TEST_F(DBCompactionTest, CompactionStatsTest) {
 
   VerifyCompactionStats(*cfd, *collector);
   // There should be no more running compactions, and thus no more input
-  // iterators
+  // sorted runs
   ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kNumRunningCompactions,
                                   &num_running_compactions));
   ASSERT_EQ(num_running_compactions, 0);
   ASSERT_TRUE(
-      db_->GetIntProperty(DB::Properties::kNumRunningCompactionInputIterators,
-                          &num_running_compaction_input_iterators));
-  ASSERT_EQ(num_running_compaction_input_iterators, 0);
+      db_->GetIntProperty(DB::Properties::kNumRunningCompactionSortedRuns,
+                          &num_running_compaction_sorted_runs));
+  ASSERT_EQ(num_running_compaction_sorted_runs, 0);
 }
 
 TEST_F(DBCompactionTest, SubcompactionEvent) {

db/db_impl/db_impl.cc

@@ -216,7 +216,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
       bg_bottom_compaction_scheduled_(0),
       bg_compaction_scheduled_(0),
       num_running_compactions_(0),
-      num_running_compaction_input_iterators_(0),
+      num_running_compaction_sorted_runs_(0),
       bg_flush_scheduled_(0),
       num_running_flushes_(0),
       bg_purge_scheduled_(0),

db/db_impl/db_impl.h

@@ -2414,7 +2414,7 @@ class DBImpl : public DB {
                               LogBuffer* log_buffer,
                               PrepickedCompaction* prepicked_compaction,
                               Env::Priority thread_pri,
-                              int& num_compaction_iterators_added);
+                              int& num_compaction_sorted_runs_added);
   Status BackgroundFlush(bool* madeProgress, JobContext* job_context,
                          LogBuffer* log_buffer, FlushReason* reason,
                          bool* flush_rescheduled_to_retain_udt,
@@ -2424,7 +2424,7 @@ class DBImpl : public DB {
                                const std::vector<CompactionInputFiles>& inputs,
                                bool* sfm_bookkeeping, LogBuffer* log_buffer);
 
-  size_t GetNumberCompactionInputIterators(Compaction* c);
+  size_t GetNumberCompactionSortedRuns(Compaction* c);
 
   // Request compaction tasks token from compaction thread limiter.
   // It always succeeds if force = true or limiter is disable.
@@ -2959,9 +2959,9 @@ class DBImpl : public DB {
   // stores the number of compactions are currently running
   int num_running_compactions_;
 
-  // stores the number of input iterators required for currently running
+  // stores the number of sorted runs being processed by currently running
   // compactions
-  int num_running_compaction_input_iterators_;
+  int num_running_compaction_sorted_runs_;
 
   // number of background memtable flush jobs, submitted to the HIGH pool
   int bg_flush_scheduled_;

db/db_impl/db_impl_compaction_flush.cc

@@ -61,7 +61,7 @@ bool DBImpl::EnoughRoomForCompaction(
   return enough_room;
 }
 
-size_t DBImpl::GetNumberCompactionInputIterators(Compaction* c) {
+size_t DBImpl::GetNumberCompactionSortedRuns(Compaction* c) {
   assert(c);
   if (c->IsTrivialMove() || c->deletion_compaction()) {
     return 0;
@@ -3435,12 +3435,12 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
            (bg_thread_pri == Env::Priority::LOW && bg_compaction_scheduled_));
 
     // BackgroundCompaction will update the
-    // num_running_compaction_input_iterators_ total and later we will subtract
+    // num_running_compaction_sorted_runs_ total and later we will subtract
     // what was added
-    int num_compaction_input_iterators_added = 0;
+    int num_compaction_sorted_runs_added = 0;
     Status s = BackgroundCompaction(&made_progress, &job_context, &log_buffer,
                                     prepicked_compaction, bg_thread_pri,
-                                    num_compaction_input_iterators_added);
+                                    num_compaction_sorted_runs_added);
     TEST_SYNC_POINT("BackgroundCallCompaction:1");
     if (s.IsBusy()) {
       bg_cv_.SignalAll();  // In case a waiter can proceed despite the error
@@ -3505,11 +3505,10 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
 
     assert(num_running_compactions_ > 0);
     num_running_compactions_--;
-    assert(num_running_compaction_input_iterators_ >= 0);
-    assert(num_running_compaction_input_iterators_ >=
-           num_compaction_input_iterators_added);
-    num_running_compaction_input_iterators_ -=
-        num_compaction_input_iterators_added;
+    assert(num_running_compaction_sorted_runs_ >= 0);
+    assert(num_running_compaction_sorted_runs_ >=
+           num_compaction_sorted_runs_added);
+    num_running_compaction_sorted_runs_ -= num_compaction_sorted_runs_added;
 
     if (bg_thread_pri == Env::Priority::LOW) {
       bg_compaction_scheduled_--;
@@ -3554,7 +3553,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                                     LogBuffer* log_buffer,
                                     PrepickedCompaction* prepicked_compaction,
                                     Env::Priority thread_pri,
-                                    int& num_compaction_input_iterators_added) {
+                                    int& num_compaction_sorted_runs_added) {
   ManualCompactionState* manual_compaction =
       prepicked_compaction == nullptr
           ? nullptr
@@ -3748,12 +3747,12 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
             num_files += each_level.files.size();
           }
           RecordInHistogram(stats_, NUM_FILES_IN_SINGLE_COMPACTION, num_files);
-          num_compaction_input_iterators_added =
-              static_cast<int>(GetNumberCompactionInputIterators(c.get()));
-          assert(num_compaction_input_iterators_added >= 0);
-          assert(num_running_compaction_input_iterators_ >= 0);
-          num_running_compaction_input_iterators_ +=
-              num_compaction_input_iterators_added;
+          num_compaction_sorted_runs_added =
+              static_cast<int>(GetNumberCompactionSortedRuns(c.get()));
+          assert(num_compaction_sorted_runs_added >= 0);
+          assert(num_running_compaction_sorted_runs_ >= 0);
+          num_running_compaction_sorted_runs_ +=
+              num_compaction_sorted_runs_added;
 
           // There are three things that can change compaction score:
           // 1) When flush or compaction finish. This case is covered by

db/internal_stats.cc

@@ -301,8 +301,8 @@ static const std::string aggregated_table_properties =
 static const std::string aggregated_table_properties_at_level =
     aggregated_table_properties + "-at-level";
 static const std::string num_running_compactions = "num-running-compactions";
-static const std::string num_running_compaction_input_iterators =
-    "num-running-compaction-input-iterators";
+static const std::string num_running_compaction_sorted_runs =
+    "num-running-compaction-sorted-runs";
 static const std::string num_running_flushes = "num-running-flushes";
 static const std::string actual_delayed_write_rate =
     "actual-delayed-write-rate";
@@ -353,8 +353,8 @@ const std::string DB::Properties::kCompactionPending =
     rocksdb_prefix + compaction_pending;
 const std::string DB::Properties::kNumRunningCompactions =
     rocksdb_prefix + num_running_compactions;
-const std::string DB::Properties::kNumRunningCompactionInputIterators =
-    rocksdb_prefix + num_running_compaction_input_iterators;
+const std::string DB::Properties::kNumRunningCompactionSortedRuns =
+    rocksdb_prefix + num_running_compaction_sorted_runs;
 const std::string DB::Properties::kNumRunningFlushes =
     rocksdb_prefix + num_running_flushes;
 const std::string DB::Properties::kBackgroundErrors =
@@ -584,10 +584,9 @@ const UnorderedMap<std::string, DBPropertyInfo>
         {DB::Properties::kNumRunningCompactions,
          {false, nullptr, &InternalStats::HandleNumRunningCompactions, nullptr,
           nullptr}},
-        {DB::Properties::kNumRunningCompactionInputIterators,
-         {false, nullptr,
-          &InternalStats::HandleNumRunningCompactionInputIterators, nullptr,
-          nullptr}},
+        {DB::Properties::kNumRunningCompactionSortedRuns,
+         {false, nullptr, &InternalStats::HandleNumRunningCompactionSortedRuns,
+          nullptr, nullptr}},
         {DB::Properties::kActualDelayedWriteRate,
          {false, nullptr, &InternalStats::HandleActualDelayedWriteRate, nullptr,
           nullptr}},
@@ -1273,9 +1272,10 @@ bool InternalStats::HandleNumRunningCompactions(uint64_t* value, DBImpl* db,
   return true;
 }
 
-bool InternalStats::HandleNumRunningCompactionInputIterators(
-    uint64_t* value, DBImpl* db, Version* /*version*/) {
-  *value = db->num_running_compaction_input_iterators_;
+bool InternalStats::HandleNumRunningCompactionSortedRuns(uint64_t* value,
+                                                         DBImpl* db,
+                                                         Version* /*version*/) {
+  *value = db->num_running_compaction_sorted_runs_;
   return true;
 }
 

db/internal_stats.h

@@ -847,8 +847,8 @@ class InternalStats {
   bool HandleCompactionPending(uint64_t* value, DBImpl* db, Version* version);
   bool HandleNumRunningCompactions(uint64_t* value, DBImpl* db,
                                    Version* version);
-  bool HandleNumRunningCompactionInputIterators(uint64_t* value, DBImpl* db,
-                                                Version* version);
+  bool HandleNumRunningCompactionSortedRuns(uint64_t* value, DBImpl* db,
+                                            Version* version);
   bool HandleBackgroundErrors(uint64_t* value, DBImpl* db, Version* version);
   bool HandleCurSizeActiveMemTable(uint64_t* value, DBImpl* db,
                                    Version* version);

include/rocksdb/db.h

@@ -1210,9 +1210,9 @@ class DB {
     //      running compactions.
     static const std::string kNumRunningCompactions;
 
-    //  "rocksdb.num-running-compaction-input-iterators" - returns the number of
-    //  input iterators required for currently running compactions.
-    static const std::string kNumRunningCompactionInputIterators;
+    //  "rocksdb.num-running-compaction-sorted-runs" - returns the number of
+    //  sorted runs being processed by currently running compactions.
+    static const std::string kNumRunningCompactionSortedRuns;
 
     //  "rocksdb.background-errors" - returns accumulated number of background
     //      errors.