Partial cleanup of CompactionJob

Summary:
Logging, dealing with key prefix batches and updating stats
moved from CompactionJob::Run() into separate functions.

Test Plan: make all && make check

Reviewers: sdong, rven, yhchiang, igor

Reviewed By: igor

Subscribers: dhruba, leveldb

Differential Revision: https://reviews.facebook.net/D41919

db/compaction_job.cc

@@ -307,51 +307,121 @@ Status CompactionJob::Run() {
   TEST_SYNC_POINT("CompactionJob::Run():Start");
   log_buffer_->FlushBufferToLog();
   ColumnFamilyData* cfd = compact_->compaction->column_family_data();
-
   auto* compaction = compact_->compaction;
-  // Let's check if anything will get logged. Don't prepare all the info if
-  // we're not logging
-  if (db_options_.info_log_level <= InfoLogLevel::INFO_LEVEL) {
-    Compaction::InputLevelSummaryBuffer inputs_summary;
-    Log(InfoLogLevel::INFO_LEVEL, db_options_.info_log,
-        "[%s] [JOB %d] Compacting %s, score %.2f", cfd->GetName().c_str(),
-        job_id_, compaction->InputLevelSummary(&inputs_summary),
-        compaction->score());
-    char scratch[2345];
-    compact_->compaction->Summary(scratch, sizeof(scratch));
-    Log(InfoLogLevel::INFO_LEVEL, db_options_.info_log,
-        "[%s] Compaction start summary: %s\n", cfd->GetName().c_str(), scratch);
-    // build event logger report
-    auto stream = event_logger_->Log();
-    stream << "job" << job_id_ << "event"
-           << "compaction_started";
-    for (size_t i = 0; i < compaction->num_input_levels(); ++i) {
-      stream << ("files_L" + ToString(compaction->level(i)));
-      stream.StartArray();
-      for (auto f : *compaction->inputs(i)) {
-        stream << f->fd.GetNumber();
-      }
-      stream.EndArray();
-    }
-    stream << "score" << compaction->score() << "input_data_size"
-           << compaction->CalculateTotalInputSize();
-  }
+  LogCompaction(cfd, compaction);
 
   const uint64_t start_micros = env_->NowMicros();
   std::unique_ptr<Iterator> input(
       versions_->MakeInputIterator(compact_->compaction));
   input->SeekToFirst();
 
-  Status status;
-  ParsedInternalKey ikey;
   std::unique_ptr<CompactionFilterV2> compaction_filter_from_factory_v2 =
       compact_->compaction->CreateCompactionFilterV2();
   auto compaction_filter_v2 = compaction_filter_from_factory_v2.get();
 
+  Status status;
   int64_t imm_micros = 0;  // Micros spent doing imm_ compactions
   if (!compaction_filter_v2) {
     status = ProcessKeyValueCompaction(&imm_micros, input.get(), false);
   } else {
+    status = ProcessPrefixBatches(cfd, &imm_micros, input.get(),
+        compaction_filter_v2);
+  }  // checking for compaction filter v2
+
+  if (status.ok() &&
+      (shutting_down_->load(std::memory_order_acquire) || cfd->IsDropped())) {
+    status = Status::ShutdownInProgress(
+        "Database shutdown or Column family drop during compaction");
+  }
+  if (status.ok() && compact_->builder != nullptr) {
+    status = FinishCompactionOutputFile(input.get());
+  }
+  if (status.ok()) {
+    status = input->status();
+  }
+  input.reset();
+
+  if (output_directory_ && !db_options_.disableDataSync) {
+    output_directory_->Fsync();
+  }
+
+  compaction_stats_.micros = env_->NowMicros() - start_micros - imm_micros;
+  MeasureTime(stats_, COMPACTION_TIME, compaction_stats_.micros);
+  UpdateCompactionStats();
+
+  RecordCompactionIOStats();
+
+  LogFlush(db_options_.info_log);
+  TEST_SYNC_POINT("CompactionJob::Run():End");
+  return status;
+}
+
+void CompactionJob::Install(Status* status,
+                            const MutableCFOptions& mutable_cf_options,
+                            InstrumentedMutex* db_mutex) {
+  AutoThreadOperationStageUpdater stage_updater(
+      ThreadStatus::STAGE_COMPACTION_INSTALL);
+  db_mutex->AssertHeld();
+  ColumnFamilyData* cfd = compact_->compaction->column_family_data();
+  cfd->internal_stats()->AddCompactionStats(
+      compact_->compaction->output_level(), compaction_stats_);
+
+  if (status->ok()) {
+    *status = InstallCompactionResults(db_mutex, mutable_cf_options);
+  }
+  VersionStorageInfo::LevelSummaryStorage tmp;
+  auto vstorage = cfd->current()->storage_info();
+  const auto& stats = compaction_stats_;
+  LogToBuffer(
+      log_buffer_,
+      "[%s] compacted to: %s, MB/sec: %.1f rd, %.1f wr, level %d, "
+      "files in(%d, %d) out(%d) "
+      "MB in(%.1f, %.1f) out(%.1f), read-write-amplify(%.1f) "
+      "write-amplify(%.1f) %s, records in: %d, records dropped: %d\n",
+      cfd->GetName().c_str(), vstorage->LevelSummary(&tmp),
+      (stats.bytes_read_non_output_levels + stats.bytes_read_output_level) /
+          static_cast<double>(stats.micros),
+      stats.bytes_written / static_cast<double>(stats.micros),
+      compact_->compaction->output_level(),
+      stats.num_input_files_in_non_output_levels,
+      stats.num_input_files_in_output_level,
+      stats.num_output_files,
+      stats.bytes_read_non_output_levels / 1048576.0,
+      stats.bytes_read_output_level / 1048576.0,
+      stats.bytes_written / 1048576.0,
+      (stats.bytes_written + stats.bytes_read_output_level +
+       stats.bytes_read_non_output_levels) /
+          static_cast<double>(stats.bytes_read_non_output_levels),
+      stats.bytes_written /
+          static_cast<double>(stats.bytes_read_non_output_levels),
+      status->ToString().c_str(), stats.num_input_records,
+      stats.num_dropped_records);
+
+  UpdateCompactionJobStats(stats);
+
+  auto stream = event_logger_->LogToBuffer(log_buffer_);
+  stream << "job" << job_id_ << "event"
+         << "compaction_finished"
+         << "output_level" << compact_->compaction->output_level()
+         << "num_output_files" << compact_->outputs.size()
+         << "total_output_size" << compact_->total_bytes
+         << "num_input_records" << compact_->num_input_records
+         << "num_output_records" << compact_->num_output_records;
+  stream << "lsm_state";
+  stream.StartArray();
+  for (int level = 0; level < vstorage->num_levels(); ++level) {
+    stream << vstorage->NumLevelFiles(level);
+  }
+  stream.EndArray();
+
+  CleanupCompaction(*status);
+}
+
+Status CompactionJob::ProcessPrefixBatches(
+    ColumnFamilyData* cfd,
+    int64_t* imm_micros,
+    Iterator* input,
+    CompactionFilterV2* compaction_filter_v2) {
   // temp_backup_input always point to the start of the current buffer
   // temp_backup_input = backup_input;
   // iterate through input,
@@ -359,6 +429,8 @@ Status CompactionJob::Run() {
   // 2) send value_buffer to compaction filter and alternate the values;
   // 3) merge value_buffer with ineligible_value_buffer;
   // 4) run the modified "compaction" using the old for loop.
+  ParsedInternalKey ikey;
+  Status status;
   bool prefix_initialized = false;
   shared_ptr<Iterator> backup_input(
       versions_->MakeInputIterator(compact_->compaction));
@@ -369,8 +441,8 @@ Status CompactionJob::Run() {
          !cfd->IsDropped()) {
     // FLUSH preempts compaction
     // TODO(icanadi) this currently only checks if flush is necessary on
-      // compacting column family. we should also check if flush is necessary
-      // on other column families, too
+    // compacting column family. we should also check if flush is necessary on
+    // other column families, too
 
     imm_micros += yield_callback_();
 
@@ -424,7 +496,7 @@ Status CompactionJob::Run() {
 
     // Done buffering for the current prefix. Spit it out to disk
     // Now just iterate through all the kv-pairs
-      status = ProcessKeyValueCompaction(&imm_micros, input.get(), true);
+    status = ProcessKeyValueCompaction(imm_micros, input, true);
 
     if (!status.ok()) {
       break;
@@ -451,7 +523,7 @@ Status CompactionJob::Run() {
       }
       compact_->MergeKeyValueSliceBuffer(&cfd->internal_comparator());
 
-        status = ProcessKeyValueCompaction(&imm_micros, input.get(), true);
+      status = ProcessKeyValueCompaction(imm_micros, input, true);
       if (!status.ok()) {
         break;
       }
@@ -468,117 +540,12 @@ Status CompactionJob::Run() {
       total_filter_time += time;
     }
     compact_->MergeKeyValueSliceBuffer(&cfd->internal_comparator());
-      status = ProcessKeyValueCompaction(&imm_micros, input.get(), true);
+    status = ProcessKeyValueCompaction(imm_micros, input, true);
   }
   RecordTick(stats_, FILTER_OPERATION_TOTAL_TIME, total_filter_time);
-  }  // checking for compaction filter v2
-
-  if (status.ok() &&
-      (shutting_down_->load(std::memory_order_acquire) || cfd->IsDropped())) {
-    status = Status::ShutdownInProgress(
-        "Database shutdown or Column family drop during compaction");
-  }
-  if (status.ok() && compact_->builder != nullptr) {
-    status = FinishCompactionOutputFile(input.get());
-  }
-  if (status.ok()) {
-    status = input->status();
-  }
-  input.reset();
-
-  if (output_directory_ && !db_options_.disableDataSync) {
-    output_directory_->Fsync();
-  }
-
-  compaction_stats_.micros = env_->NowMicros() - start_micros - imm_micros;
-  MeasureTime(stats_, COMPACTION_TIME, compaction_stats_.micros);
-
-  size_t num_output_files = compact_->outputs.size();
-  if (compact_->builder != nullptr) {
-    // An error occurred so ignore the last output.
-    assert(num_output_files > 0);
-    --num_output_files;
-  }
-  compaction_stats_.num_output_files = static_cast<int>(num_output_files);
-
-  UpdateCompactionInputStats();
-
-  for (size_t i = 0; i < num_output_files; i++) {
-    compaction_stats_.bytes_written += compact_->outputs[i].file_size;
-  }
-  if (compact_->num_input_records > compact_->num_output_records) {
-    compaction_stats_.num_dropped_records +=
-        compact_->num_input_records - compact_->num_output_records;
-  }
-
-  RecordCompactionIOStats();
-
-  LogFlush(db_options_.info_log);
-  TEST_SYNC_POINT("CompactionJob::Run():End");
   return status;
 }
 
-void CompactionJob::Install(Status* status,
-                            const MutableCFOptions& mutable_cf_options,
-                            InstrumentedMutex* db_mutex) {
-  AutoThreadOperationStageUpdater stage_updater(
-      ThreadStatus::STAGE_COMPACTION_INSTALL);
-  db_mutex->AssertHeld();
-  ColumnFamilyData* cfd = compact_->compaction->column_family_data();
-  cfd->internal_stats()->AddCompactionStats(
-      compact_->compaction->output_level(), compaction_stats_);
-
-  if (status->ok()) {
-    *status = InstallCompactionResults(db_mutex, mutable_cf_options);
-  }
-  VersionStorageInfo::LevelSummaryStorage tmp;
-  auto vstorage = cfd->current()->storage_info();
-  const auto& stats = compaction_stats_;
-  LogToBuffer(
-      log_buffer_,
-      "[%s] compacted to: %s, MB/sec: %.1f rd, %.1f wr, level %d, "
-      "files in(%d, %d) out(%d) "
-      "MB in(%.1f, %.1f) out(%.1f), read-write-amplify(%.1f) "
-      "write-amplify(%.1f) %s, records in: %d, records dropped: %d\n",
-      cfd->GetName().c_str(), vstorage->LevelSummary(&tmp),
-      (stats.bytes_read_non_output_levels + stats.bytes_read_output_level) /
-          static_cast<double>(stats.micros),
-      stats.bytes_written / static_cast<double>(stats.micros),
-      compact_->compaction->output_level(),
-      stats.num_input_files_in_non_output_levels,
-      stats.num_input_files_in_output_level,
-      stats.num_output_files,
-      stats.bytes_read_non_output_levels / 1048576.0,
-      stats.bytes_read_output_level / 1048576.0,
-      stats.bytes_written / 1048576.0,
-      (stats.bytes_written + stats.bytes_read_output_level +
-       stats.bytes_read_non_output_levels) /
-          static_cast<double>(stats.bytes_read_non_output_levels),
-      stats.bytes_written /
-          static_cast<double>(stats.bytes_read_non_output_levels),
-      status->ToString().c_str(), stats.num_input_records,
-      stats.num_dropped_records);
-
-  UpdateCompactionJobStats(stats);
-
-  auto stream = event_logger_->LogToBuffer(log_buffer_);
-  stream << "job" << job_id_ << "event"
-         << "compaction_finished"
-         << "output_level" << compact_->compaction->output_level()
-         << "num_output_files" << compact_->outputs.size()
-         << "total_output_size" << compact_->total_bytes
-         << "num_input_records" << compact_->num_input_records
-         << "num_output_records" << compact_->num_output_records;
-  stream << "lsm_state";
-  stream.StartArray();
-  for (int level = 0; level < vstorage->num_levels(); ++level) {
-    stream << vstorage->NumLevelFiles(level);
-  }
-  stream.EndArray();
-
-  CleanupCompaction(*status);
-}
-
 Status CompactionJob::ProcessKeyValueCompaction(int64_t* imm_micros,
                                                 Iterator* input,
                                                 bool is_compaction_v2) {
@@ -627,8 +594,8 @@ Status CompactionJob::ProcessKeyValueCompaction(int64_t* imm_micros,
     }
     // FLUSH preempts compaction
     // TODO(icanadi) this currently only checks if flush is necessary on
-    // compacting column family. we should also check if flush is necessary on
-    // other column families, too
+    // compacting column family. we should also check if flush is necessary
+    // on other column families, too
     (*imm_micros) += yield_callback_();
 
     Slice key;
@@ -1244,7 +1211,15 @@ void CopyPrefix(
 
 #endif  // !ROCKSDB_LITE
 
-void CompactionJob::UpdateCompactionInputStats() {
+void CompactionJob::UpdateCompactionStats() {
+  size_t num_output_files = compact_->outputs.size();
+  if (compact_->builder != nullptr) {
+    // An error occurred so ignore the last output.
+    assert(num_output_files > 0);
+    --num_output_files;
+  }
+  compaction_stats_.num_output_files = static_cast<int>(num_output_files);
+
   Compaction* compaction = compact_->compaction;
   compaction_stats_.num_input_files_in_non_output_levels = 0;
   compaction_stats_.num_input_files_in_output_level = 0;
@@ -1264,6 +1239,14 @@ void CompactionJob::UpdateCompactionInputStats() {
           input_level);
     }
   }
+
+  for (size_t i = 0; i < num_output_files; i++) {
+    compaction_stats_.bytes_written += compact_->outputs[i].file_size;
+  }
+  if (compact_->num_input_records > compact_->num_output_records) {
+    compaction_stats_.num_dropped_records +=
+        compact_->num_input_records - compact_->num_output_records;
+  }
 }
 
 void CompactionJob::UpdateCompactionInputStatsHelper(
@@ -1318,4 +1301,35 @@ void CompactionJob::UpdateCompactionJobStats(
 #endif  // !ROCKSDB_LITE
 }
 
+void CompactionJob::LogCompaction(
+    ColumnFamilyData* cfd, Compaction* compaction) {
+  // Let's check if anything will get logged. Don't prepare all the info if
+  // we're not logging
+  if (db_options_.info_log_level <= InfoLogLevel::INFO_LEVEL) {
+    Compaction::InputLevelSummaryBuffer inputs_summary;
+    Log(InfoLogLevel::INFO_LEVEL, db_options_.info_log,
+        "[%s] [JOB %d] Compacting %s, score %.2f", cfd->GetName().c_str(),
+        job_id_, compaction->InputLevelSummary(&inputs_summary),
+        compaction->score());
+    char scratch[2345];
+    compaction->Summary(scratch, sizeof(scratch));
+    Log(InfoLogLevel::INFO_LEVEL, db_options_.info_log,
+        "[%s] Compaction start summary: %s\n", cfd->GetName().c_str(), scratch);
+    // build event logger report
+    auto stream = event_logger_->Log();
+    stream << "job" << job_id_ << "event"
+           << "compaction_started";
+    for (size_t i = 0; i < compaction->num_input_levels(); ++i) {
+      stream << ("files_L" + ToString(compaction->level(i)));
+      stream.StartArray();
+      for (auto f : *compaction->inputs(i)) {
+        stream << f->fd.GetNumber();
+      }
+      stream.EndArray();
+    }
+    stream << "score" << compaction->score() << "input_data_size"
+           << compaction->CalculateTotalInputSize();
+  }
+}
+
 }  // namespace rocksdb

db/compaction_job.h

@@ -83,6 +83,12 @@ class CompactionJob {
   // update the thread status for starting a compaction.
   void ReportStartedCompaction(Compaction* compaction);
   void AllocateCompactionOutputFileNumbers();
+  // Processes batches of keys with the same prefixes. This is used for
+  // CompactionFilterV2.
+  Status ProcessPrefixBatches(ColumnFamilyData* cfd,
+                              int64_t* imm_micros,
+                              Iterator* input,
+                              CompactionFilterV2* compaction_filter_v2);
   // Call compaction filter if is_compaction_v2 is not true. Then iterate
   // through input and compact the kv-pairs
   Status ProcessKeyValueCompaction(int64_t* imm_micros, Iterator* input,
@@ -105,10 +111,12 @@ class CompactionJob {
                          int64_t* key_drop_newer_entry,
                          int64_t* key_drop_obsolete);
 
-  void UpdateCompactionInputStats();
+  void UpdateCompactionStats();
   void UpdateCompactionInputStatsHelper(
       int* num_files, uint64_t* bytes_read, int input_level);
 
+  void LogCompaction(ColumnFamilyData* cfd, Compaction* compaction);
+
   int job_id_;
 
   // CompactionJob state