@nxtedition/rocksdb 13.5.9 → 13.5.10

package/deps/rocksdb/rocksdb/tools/sst_dump_test.cc

@@ -15,6 +15,7 @@
 #include "rocksdb/convenience.h"
 #include "rocksdb/filter_policy.h"
 #include "rocksdb/sst_dump_tool.h"
+#include "rocksdb/utilities/object_registry.h"
 #include "table/block_based/block_based_table_factory.h"
 #include "table/sst_file_dumper.h"
 #include "table/table_builder.h"
@@ -346,6 +347,76 @@ TEST_F(SSTDumpToolTest, CompressedSizes) {
   }
 }
 
+namespace {
+using Compressor8A = test::CompressorCustomAlg<kCustomCompression8A>;
+class MyManager : public CompressionManager {
+ public:
+  static constexpr const char* kCompatibilityName = "SSTDumpToolTest:MyManager";
+  const char* Name() const override { return kCompatibilityName; }
+  const char* CompatibilityName() const override { return kCompatibilityName; }
+
+  bool SupportsCompressionType(CompressionType type) const override {
+    return type == kCustomCompression8A;
+  }
+
+  std::unique_ptr<Compressor> GetCompressor(const CompressionOptions& /*opts*/,
+                                            CompressionType type) override {
+    switch (static_cast<unsigned char>(type)) {
+      case kCustomCompression8A:
+        return std::make_unique<Compressor8A>();
+      default:
+        return nullptr;
+    }
+  }
+
+  std::shared_ptr<Decompressor> GetDecompressor() override {
+    return std::make_shared<test::DecompressorCustomAlg>();
+  }
+};
+}  // namespace
+
+TEST_F(SSTDumpToolTest, CompressionManager) {
+  if (!Compressor8A::Supported()) {
+    fprintf(stderr,
+            "Prerequisite compression library not supported. Skipping\n");
+    return;
+  }
+
+  // Registery in ObjectLibrary to check that sst_dump can use named
+  // CompressionManagers with dependency injection
+  auto& library = *ObjectLibrary::Default();
+  library.AddFactory<CompressionManager>(
+      MyManager::kCompatibilityName,
+      [](const std::string& /*uri*/, std::unique_ptr<CompressionManager>* guard,
+         std::string* /*errmsg*/) {
+        *guard = std::make_unique<MyManager>();
+        return guard->get();
+      });
+
+  Options opts;
+  opts.env = env();
+  BlockBasedTableOptions table_opts;
+  table_opts.filter_policy.reset(
+      ROCKSDB_NAMESPACE::NewBloomFilterPolicy(10, false));
+  opts.table_factory.reset(new BlockBasedTableFactory(table_opts));
+  std::string file_path = MakeFilePath("rocksdb_sst_test.sst");
+  createSST(opts, file_path, 10);
+
+  char* usage[5];
+  PopulateCommandArgs(file_path, "--command=recompress", usage);
+  snprintf(usage[3], kOptLength, "--compression_manager=%s",
+           MyManager::kCompatibilityName);
+  snprintf(usage[4], kOptLength, "--compression_types=kCustomCompression8A");
+
+  ROCKSDB_NAMESPACE::SSTDumpTool tool;
+  ASSERT_TRUE(!tool.Run(5, usage, opts));
+
+  cleanup(opts, file_path);
+  for (int i = 0; i < 5; i++) {
+    delete[] usage[i];
+  }
+}
+
 TEST_F(SSTDumpToolTest, MemEnv) {
   std::unique_ptr<Env> mem_env(NewMemEnv(env()));
   Options opts;

package/deps/rocksdb/rocksdb/tools/sst_dump_tool.cc

@@ -17,17 +17,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-static const std::vector<std::pair<CompressionType, const char*>>
-    kCompressions = {
-        {CompressionType::kNoCompression, "kNoCompression"},
-        {CompressionType::kSnappyCompression, "kSnappyCompression"},
-        {CompressionType::kZlibCompression, "kZlibCompression"},
-        {CompressionType::kBZip2Compression, "kBZip2Compression"},
-        {CompressionType::kLZ4Compression, "kLZ4Compression"},
-        {CompressionType::kLZ4HCCompression, "kLZ4HCCompression"},
-        {CompressionType::kXpressCompression, "kXpressCompression"},
-        {CompressionType::kZSTD, "kZSTD"}};
-
 namespace {
 
 void print_help(bool to_stderr) {
@@ -98,10 +87,15 @@ void print_help(bool to_stderr) {
       be used when trying different compression algorithms
 
     --compression_types=<comma-separated list of CompressionType members, e.g.,
-      kSnappyCompression>
+      kSnappyCompression or kCustomCompressionC4>
       Can be combined with --command=recompress to run recompression for this
       list of compression types
-      Supported compression types: %s
+      Supported built-in compression types: %s
+
+    --compression_manager=<compression manager string>
+      Used with --command=recompress to specify a compression manager to use
+      instead of the built-in compression manager, which may support a
+      different set of compression types.
 
     --parse_internal_key=<0xKEY>
       Convenience option to parse an internal key on the command line. Dumps the
@@ -178,7 +172,8 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
   std::string compression_level_to_str;
   size_t block_size = 0;
   size_t readahead_size = 2 * 1024 * 1024;
-  std::vector<std::pair<CompressionType, const char*>> compression_types;
+  std::vector<CompressionType> compression_types;
+  std::shared_ptr<CompressionManager> compression_manager;
   uint64_t total_num_files = 0;
   uint64_t total_num_data_blocks = 0;
   uint64_t total_data_block_size = 0;
@@ -244,19 +239,36 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
       std::istringstream iss(compression_types_csv);
       std::string compression_type;
       has_specified_compression_types = true;
+
       while (std::getline(iss, compression_type, ',')) {
-        auto iter = std::find_if(
-            kCompressions.begin(), kCompressions.end(),
-            [&compression_type](std::pair<CompressionType, const char*> curr) {
-              return curr.second == compression_type;
-            });
-        if (iter == kCompressions.end()) {
+        auto iter =
+            OptionsHelper::compression_type_string_map.find(compression_type);
+        if (iter == OptionsHelper::compression_type_string_map.end()) {
           fprintf(stderr, "%s is not a valid CompressionType\n",
                   compression_type.c_str());
           exit(1);
         }
-        compression_types.emplace_back(*iter);
+        compression_types.emplace_back(iter->second);
+      }
+    } else if (strncmp(argv[i], "--compression_manager=", 22) == 0) {
+      std::string compression_manager_str = argv[i] + 22;
+      ConfigOptions config_options;
+      config_options.ignore_unsupported_options = false;
+      Status s = CompressionManager::CreateFromString(
+          config_options, compression_manager_str, &compression_manager);
+      if (!s.ok()) {
+        fprintf(stderr, "Failed to create compression manager: %s\n",
+                s.ToString().c_str());
+        exit(1);
+      }
+      if (compression_manager == nullptr) {
+        fprintf(stderr, "No compression manager created: %s\n",
+                compression_manager_str.c_str());
+        exit(1);
       }
+      options.compression_manager = compression_manager;
+      printf("Using compression manager: %s\n",
+             compression_manager->GetId().c_str());
     } else if (strncmp(argv[i], "--parse_internal_key=", 21) == 0) {
       std::string in_key(argv[i] + 21);
       try {
@@ -450,9 +462,12 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
     }
 
     if (command == "recompress") {
+      // TODO: consider getting supported compressions from the compression
+      // manager
       st = dumper.ShowAllCompressionSizes(
           set_block_size ? block_size : 16384,
-          compression_types.empty() ? kCompressions : compression_types,
+          compression_types.empty() ? GetSupportedCompressions()
+                                    : compression_types,
           compress_level_from, compress_level_to, compression_max_dict_bytes,
           compression_zstd_max_train_bytes, compression_max_dict_buffer_bytes,
           !compression_use_zstd_finalize_dict);

package/deps/rocksdb/rocksdb/util/auto_tune_compressor.cc

@@ -0,0 +1,308 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+//
+
+#include "util/auto_tune_compressor.h"
+
+#include "options/options_helper.h"
+#include "rocksdb/advanced_compression.h"
+#include "test_util/sync_point.h"
+#include "util/random.h"
+#include "util/stop_watch.h"
+namespace ROCKSDB_NAMESPACE {
+const std::vector<std::vector<int>> CostAwareCompressor::kCompressionLevels{
+    {0},         // KSnappyCompression
+    {},          // kZlibCompression
+    {},          // kBZip2Compression
+    {1, 4, 9},   // kLZ4Compression
+    {1, 4, 9},   // klZ4HCCompression
+    {},          // kXpressCompression
+    {1, 15, 22}  // kZSTD
+};
+
+int CompressionRejectionProbabilityPredictor::Predict() const {
+  return pred_rejection_prob_percentage_;
+}
+
+size_t CompressionRejectionProbabilityPredictor::attempted_compression_count()
+    const {
+  return rejected_count_ + compressed_count_;
+}
+
+bool CompressionRejectionProbabilityPredictor::Record(
+    Slice uncompressed_block_data, std::string* compressed_output,
+    const CompressionOptions& opts) {
+  if (compressed_output->size() >
+      (static_cast<uint64_t>(opts.max_compressed_bytes_per_kb) *
+       uncompressed_block_data.size()) >>
+      10) {
+    rejected_count_++;
+  } else {
+    compressed_count_++;
+  }
+  auto attempted = attempted_compression_count();
+  if (attempted >= window_size_) {
+    pred_rejection_prob_percentage_ =
+        static_cast<int>(rejected_count_ * 100 / attempted);
+    compressed_count_ = 0;
+    rejected_count_ = 0;
+    assert(attempted_compression_count() == 0);
+  }
+  return true;
+}
+
+AutoSkipCompressorWrapper::AutoSkipCompressorWrapper(
+    std::unique_ptr<Compressor> compressor, const CompressionOptions& opts)
+    : CompressorWrapper::CompressorWrapper(std::move(compressor)),
+      opts_(opts) {}
+
+const char* AutoSkipCompressorWrapper::Name() const {
+  return "AutoSkipCompressorWrapper";
+}
+
+Status AutoSkipCompressorWrapper::CompressBlock(
+    Slice uncompressed_data, std::string* compressed_output,
+    CompressionType* out_compression_type, ManagedWorkingArea* wa) {
+  // Check if the managed working area is provided or owned by this object.
+  // If not, bypass auto-skip logic since the working area lacks a predictor to
+  // record or make necessary decisions to compress or bypass compression of the
+  // block
+  if (wa == nullptr || wa->owner() != this) {
+    return wrapped_->CompressBlock(uncompressed_data, compressed_output,
+                                   out_compression_type, wa);
+  }
+  bool exploration =
+      Random::GetTLSInstance()->PercentTrue(kExplorationPercentage);
+  TEST_SYNC_POINT_CALLBACK(
+      "AutoSkipCompressorWrapper::CompressBlock::exploitOrExplore",
+      &exploration);
+  auto autoskip_wa = static_cast<AutoSkipWorkingArea*>(wa->get());
+  if (exploration) {
+    return CompressBlockAndRecord(uncompressed_data, compressed_output,
+                                  out_compression_type, autoskip_wa);
+  } else {
+    auto predictor_ptr = autoskip_wa->predictor;
+    auto prediction = predictor_ptr->Predict();
+    if (prediction <= kProbabilityCutOff) {
+      // decide to compress
+      return CompressBlockAndRecord(uncompressed_data, compressed_output,
+                                    out_compression_type, autoskip_wa);
+    } else {
+      // decide to bypass compression
+      *out_compression_type = kNoCompression;
+      return Status::OK();
+    }
+  }
+  return Status::OK();
+}
+
+Compressor::ManagedWorkingArea AutoSkipCompressorWrapper::ObtainWorkingArea() {
+  auto wrap_wa = wrapped_->ObtainWorkingArea();
+  return ManagedWorkingArea(new AutoSkipWorkingArea(std::move(wrap_wa)), this);
+}
+void AutoSkipCompressorWrapper::ReleaseWorkingArea(WorkingArea* wa) {
+  delete static_cast<AutoSkipWorkingArea*>(wa);
+}
+
+Status AutoSkipCompressorWrapper::CompressBlockAndRecord(
+    Slice uncompressed_data, std::string* compressed_output,
+    CompressionType* out_compression_type, AutoSkipWorkingArea* wa) {
+  Status status = wrapped_->CompressBlock(uncompressed_data, compressed_output,
+                                          out_compression_type, &(wa->wrapped));
+  // determine if it was rejected or compressed
+  auto predictor_ptr = wa->predictor;
+  predictor_ptr->Record(uncompressed_data, compressed_output, opts_);
+  return status;
+}
+
+const char* AutoSkipCompressorManager::Name() const {
+  // should have returned "AutoSkipCompressorManager" but we currently have an
+  // error so for now returning name of the wrapped container
+  return wrapped_->Name();
+}
+
+std::unique_ptr<Compressor> AutoSkipCompressorManager::GetCompressorForSST(
+    const FilterBuildingContext& context, const CompressionOptions& opts,
+    CompressionType preferred) {
+  assert(GetSupportedCompressions().size() > 1);
+  assert(preferred != kNoCompression);
+  return std::make_unique<AutoSkipCompressorWrapper>(
+      wrapped_->GetCompressorForSST(context, opts, preferred), opts);
+}
+
+CostAwareCompressor::CostAwareCompressor(const CompressionOptions& opts)
+    : opts_(opts) {
+  // Creates compressor supporting all the compression types and levels as per
+  // the compression levels set in vector CompressionLevels
+  auto builtInManager = GetBuiltinV2CompressionManager();
+  const auto& compressions = GetSupportedCompressions();
+  for (size_t i = 0; i < kCompressionLevels.size(); i++) {
+    CompressionType type = static_cast<CompressionType>(i + 1);
+    if (type == kNoCompression) {
+      continue;
+    }
+    if (kCompressionLevels[type - 1].size() == 0) {
+      allcompressors_.emplace_back();
+      continue;
+    } else {
+      // if the compression type is not supported, then skip and remove
+      // compression levels from the supported compression level list
+      if (std::find(compressions.begin(), compressions.end(), type) ==
+          compressions.end()) {
+        allcompressors_.emplace_back();
+        continue;
+      }
+      std::vector<std::unique_ptr<Compressor>> compressors_diff_levels;
+      for (size_t j = 0; j < kCompressionLevels[type - 1].size(); j++) {
+        auto level = kCompressionLevels[type - 1][j];
+        CompressionOptions new_opts = opts;
+        new_opts.level = level;
+        compressors_diff_levels.push_back(
+            builtInManager->GetCompressor(new_opts, type));
+        allcompressors_index_.emplace_back(i, j);
+      }
+      allcompressors_.push_back(std::move(compressors_diff_levels));
+    }
+  }
+}
+
+const char* CostAwareCompressor::Name() const { return "CostAwareCompressor"; }
+size_t CostAwareCompressor::GetMaxSampleSizeIfWantDict(
+    CacheEntryRole block_type) const {
+  auto idx = allcompressors_index_.back();
+  return allcompressors_[idx.first][idx.second]->GetMaxSampleSizeIfWantDict(
+      block_type);
+}
+
+Slice CostAwareCompressor::GetSerializedDict() const {
+  auto idx = allcompressors_index_.back();
+  return allcompressors_[idx.first][idx.second]->GetSerializedDict();
+}
+
+CompressionType CostAwareCompressor::GetPreferredCompressionType() const {
+  return kZSTD;
+}
+std::unique_ptr<Compressor> CostAwareCompressor::MaybeCloneSpecialized(
+    CacheEntryRole block_type, DictSampleArgs&& dict_samples) {
+  // TODO: full dictionary compression support. Currently this just falls
+  // back on a non-multi compressor when asked to use a dictionary.
+  auto idx = allcompressors_index_.back();
+  return allcompressors_[idx.first][idx.second]->MaybeCloneSpecialized(
+      block_type, std::move(dict_samples));
+}
+Status CostAwareCompressor::CompressBlock(Slice uncompressed_data,
+                                          std::string* compressed_output,
+                                          CompressionType* out_compression_type,
+                                          ManagedWorkingArea* wa) {
+  // Check if the managed working area is provided or owned by this object.
+  // If not, bypass compressor logic since the working area lacks a predictor
+  if (allcompressors_.size() == 0) {
+    return Status::NotSupported("No compression type supported");
+  }
+  if (wa == nullptr || wa->owner() != this) {
+    // highest compression level of Zstd
+    size_t choosen_compression_type = 6;
+    size_t compression_level_ptr = 2;
+    return allcompressors_[choosen_compression_type][compression_level_ptr]
+        ->CompressBlock(uncompressed_data, compressed_output,
+                        out_compression_type, wa);
+  }
+  auto local_wa = static_cast<CostAwareWorkingArea*>(wa->get());
+  std::pair<size_t, size_t> choosen_index(6, 2);
+  size_t choosen_compression_type = choosen_index.first;
+  size_t compresion_level_ptr = choosen_index.second;
+  return CompressBlockAndRecord(choosen_compression_type, compresion_level_ptr,
+                                uncompressed_data, compressed_output,
+                                out_compression_type, local_wa);
+}
+
+Compressor::ManagedWorkingArea CostAwareCompressor::ObtainWorkingArea() {
+  auto wrap_wa = allcompressors_.back().back()->ObtainWorkingArea();
+  auto wa = new CostAwareWorkingArea(std::move(wrap_wa));
+  // Create cost predictors for each compression type and level
+  wa->cost_predictors_.reserve(allcompressors_.size());
+  for (size_t i = 0; i < allcompressors_.size(); i++) {
+    CompressionType type = static_cast<CompressionType>(i + 1);
+    if (allcompressors_[type - 1].size() == 0) {
+      wa->cost_predictors_.emplace_back();
+      continue;
+    } else {
+      std::vector<IOCPUCostPredictor*> predictors_diff_levels;
+      predictors_diff_levels.reserve(kCompressionLevels[type - 1].size());
+      for (size_t j = 0; j < kCompressionLevels[type - 1].size(); j++) {
+        predictors_diff_levels.emplace_back(new IOCPUCostPredictor(10));
+      }
+      wa->cost_predictors_.emplace_back(std::move(predictors_diff_levels));
+    }
+  }
+  return ManagedWorkingArea(wa, this);
+}
+void CostAwareCompressor::ReleaseWorkingArea(WorkingArea* wa) {
+  // remove all created cost predictors
+  for (auto& prdictors_diff_levels :
+       static_cast<CostAwareWorkingArea*>(wa)->cost_predictors_) {
+    for (auto& predictor : prdictors_diff_levels) {
+      delete predictor;
+    }
+  }
+  delete static_cast<CostAwareWorkingArea*>(wa);
+}
+
+Status CostAwareCompressor::CompressBlockAndRecord(
+    size_t choosen_compression_type, size_t compression_level_ptr,
+    Slice uncompressed_data, std::string* compressed_output,
+    CompressionType* out_compression_type, CostAwareWorkingArea* wa) {
+  assert(choosen_compression_type < allcompressors_.size());
+  assert(compression_level_ptr <
+         allcompressors_[choosen_compression_type].size());
+  assert(choosen_compression_type < wa->cost_predictors_.size());
+  assert(compression_level_ptr <
+         wa->cost_predictors_[choosen_compression_type].size());
+  StopWatchNano<> timer(Env::Default()->GetSystemClock().get(), true);
+  Status status =
+      allcompressors_[choosen_compression_type][compression_level_ptr]
+          ->CompressBlock(uncompressed_data, compressed_output,
+                          out_compression_type, &(wa->wrapped_));
+  std::pair<size_t, size_t> measured_data(timer.ElapsedMicros(),
+                                          compressed_output->size());
+  auto predictor =
+      wa->cost_predictors_[choosen_compression_type][compression_level_ptr];
+  auto output_length = measured_data.second;
+  auto cpu_time = measured_data.first;
+  predictor->CPUPredictor.Record(cpu_time);
+  predictor->IOPredictor.Record(output_length);
+  TEST_SYNC_POINT_CALLBACK(
+      "CostAwareCompressor::CompressBlockAndRecord::GetPredictor",
+      wa->cost_predictors_[choosen_compression_type][compression_level_ptr]);
+  return status;
+}
+
+std::shared_ptr<CompressionManagerWrapper> CreateAutoSkipCompressionManager(
+    std::shared_ptr<CompressionManager> wrapped) {
+  return std::make_shared<AutoSkipCompressorManager>(
+      wrapped == nullptr ? GetBuiltinV2CompressionManager() : wrapped);
+}
+const char* CostAwareCompressorManager::Name() const {
+  // should have returned "CostAwareCompressorManager" but we currently have an
+  // error so for now returning name of the wrapped container
+  return wrapped_->Name();
+}
+
+std::unique_ptr<Compressor> CostAwareCompressorManager::GetCompressorForSST(
+    const FilterBuildingContext& context, const CompressionOptions& opts,
+    CompressionType preferred) {
+  assert(GetSupportedCompressions().size() > 1);
+  (void)context;
+  (void)preferred;
+  return std::make_unique<CostAwareCompressor>(opts);
+}
+
+std::shared_ptr<CompressionManagerWrapper> CreateCostAwareCompressionManager(
+    std::shared_ptr<CompressionManager> wrapped) {
+  return std::make_shared<CostAwareCompressorManager>(
+      wrapped == nullptr ? GetBuiltinV2CompressionManager() : wrapped);
+}
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/auto_tune_compressor.h

@@ -0,0 +1,189 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+//
+// Defines auto skip compressor wrapper which intelligently decides bypassing
+// compression based on past data
+// Defines CostAwareCompressor which currently tries to predict the cpu and io
+// cost of the compression
+
+#pragma once
+#include <memory>
+
+#include "rocksdb/advanced_compression.h"
+
+namespace ROCKSDB_NAMESPACE {
+// Auto Skip Compression Components
+// Predict rejection probability using a moving window approach
+class CompressionRejectionProbabilityPredictor {
+ public:
+  explicit CompressionRejectionProbabilityPredictor(int window_size)
+      : pred_rejection_prob_percentage_(0),
+        rejected_count_(0),
+        compressed_count_(0),
+        window_size_(window_size) {}
+  int Predict() const;
+  bool Record(Slice uncompressed_block_data, std::string* compressed_output,
+              const CompressionOptions& opts);
+  size_t attempted_compression_count() const;
+
+ protected:
+  int pred_rejection_prob_percentage_;
+  size_t rejected_count_;
+  size_t compressed_count_;
+  size_t window_size_;
+};
+
+class AutoSkipWorkingArea : public Compressor::WorkingArea {
+ public:
+  explicit AutoSkipWorkingArea(Compressor::ManagedWorkingArea&& wa)
+      : wrapped(std::move(wa)),
+        predictor(
+            std::make_shared<CompressionRejectionProbabilityPredictor>(10)) {}
+  ~AutoSkipWorkingArea() {}
+  AutoSkipWorkingArea(const AutoSkipWorkingArea&) = delete;
+  AutoSkipWorkingArea& operator=(const AutoSkipWorkingArea&) = delete;
+  AutoSkipWorkingArea(AutoSkipWorkingArea&& other) noexcept
+      : wrapped(std::move(other.wrapped)),
+        predictor(std::move(other.predictor)) {}
+
+  AutoSkipWorkingArea& operator=(AutoSkipWorkingArea&& other) noexcept {
+    if (this != &other) {
+      wrapped = std::move(other.wrapped);
+      predictor = std::move(other.predictor);
+    }
+    return *this;
+  }
+  Compressor::ManagedWorkingArea wrapped;
+  std::shared_ptr<CompressionRejectionProbabilityPredictor> predictor;
+};
+class AutoSkipCompressorWrapper : public CompressorWrapper {
+ public:
+  const char* Name() const override;
+  explicit AutoSkipCompressorWrapper(std::unique_ptr<Compressor> compressor,
+                                     const CompressionOptions& opts);
+
+  Status CompressBlock(Slice uncompressed_data, std::string* compressed_output,
+                       CompressionType* out_compression_type,
+                       ManagedWorkingArea* wa) override;
+  ManagedWorkingArea ObtainWorkingArea() override;
+  void ReleaseWorkingArea(WorkingArea* wa) override;
+
+ private:
+  Status CompressBlockAndRecord(Slice uncompressed_data,
+                                std::string* compressed_output,
+                                CompressionType* out_compression_type,
+                                AutoSkipWorkingArea* wa);
+  static constexpr int kExplorationPercentage = 10;
+  static constexpr int kProbabilityCutOff = 50;
+  const CompressionOptions opts_;
+};
+
+class AutoSkipCompressorManager : public CompressionManagerWrapper {
+  using CompressionManagerWrapper::CompressionManagerWrapper;
+  const char* Name() const override;
+  std::unique_ptr<Compressor> GetCompressorForSST(
+      const FilterBuildingContext& context, const CompressionOptions& opts,
+      CompressionType preferred) override;
+};
+// Cost Aware Components
+template <typename T>
+class WindowAveragePredictor {
+ public:
+  explicit WindowAveragePredictor(int window_size)
+      : sum_(0), prediction_(0), count_(0), kWindowSize(window_size) {}
+  T Predict() { return prediction_; }
+  bool Record(T data) {
+    sum_ += data;
+    count_++;
+    if (count_ >= kWindowSize) {
+      prediction_ = sum_ / count_;
+      sum_ = 0;
+      count_ = 0;
+    }
+    return true;
+  }
+  void SetPrediction(T prediction) { prediction_ = prediction; }
+
+ private:
+  T sum_;
+  T prediction_;
+  int count_;
+  const int kWindowSize;
+};
+
+using IOCostPredictor = WindowAveragePredictor<size_t>;
+using CPUUtilPredictor = WindowAveragePredictor<uint64_t>;
+
+struct IOCPUCostPredictor {
+  explicit IOCPUCostPredictor(int window_size)
+      : IOPredictor(window_size), CPUPredictor(window_size) {}
+  IOCostPredictor IOPredictor;
+  CPUUtilPredictor CPUPredictor;
+};
+class CostAwareWorkingArea : public Compressor::WorkingArea {
+ public:
+  explicit CostAwareWorkingArea(Compressor::ManagedWorkingArea&& wa)
+      : wrapped_(std::move(wa)) {}
+  ~CostAwareWorkingArea() {}
+  CostAwareWorkingArea(const CostAwareWorkingArea&) = delete;
+  CostAwareWorkingArea& operator=(const CostAwareWorkingArea&) = delete;
+  CostAwareWorkingArea(CostAwareWorkingArea&& other) noexcept
+      : wrapped_(std::move(other.wrapped_)) {}
+
+  CostAwareWorkingArea& operator=(CostAwareWorkingArea&& other) noexcept {
+    if (this != &other) {
+      wrapped_ = std::move(other.wrapped_);
+      cost_predictors_ = std::move(other.cost_predictors_);
+    }
+    return *this;
+  }
+  Compressor::ManagedWorkingArea wrapped_;
+  std::vector<std::vector<IOCPUCostPredictor*>> cost_predictors_;
+};
+
+class CostAwareCompressor : public Compressor {
+ public:
+  explicit CostAwareCompressor(const CompressionOptions& opts);
+  const char* Name() const override;
+  size_t GetMaxSampleSizeIfWantDict(CacheEntryRole block_type) const override;
+  Slice GetSerializedDict() const override;
+  CompressionType GetPreferredCompressionType() const override;
+  ManagedWorkingArea ObtainWorkingArea() override;
+  std::unique_ptr<Compressor> MaybeCloneSpecialized(
+      CacheEntryRole block_type, DictSampleArgs&& dict_samples) override;
+
+  Status CompressBlock(Slice uncompressed_data, std::string* compressed_output,
+                       CompressionType* out_compression_type,
+                       ManagedWorkingArea* wa) override;
+  void ReleaseWorkingArea(WorkingArea* wa) override;
+
+ private:
+  Status CompressBlockAndRecord(size_t choosen_compression_type,
+                                size_t compresion_level_ptr,
+                                Slice uncompressed_data,
+                                std::string* compressed_output,
+                                CompressionType* out_compression_type,
+                                CostAwareWorkingArea* wa);
+  static constexpr int kExplorationPercentage = 10;
+  static constexpr int kProbabilityCutOff = 50;
+  // This is the vector containing the list of compression levels that
+  // CostAwareCompressor will use create compressor and predicts the cost
+  // The vector contains list of compression level for compression algorithm in
+  // the order defined by enum CompressionType
+  static const std::vector<std::vector<int>> kCompressionLevels;
+  const CompressionOptions opts_;
+  std::vector<std::vector<std::unique_ptr<Compressor>>> allcompressors_;
+  std::vector<std::pair<size_t, size_t>> allcompressors_index_;
+};
+
+class CostAwareCompressorManager : public CompressionManagerWrapper {
+  using CompressionManagerWrapper::CompressionManagerWrapper;
+  const char* Name() const override;
+  std::unique_ptr<Compressor> GetCompressorForSST(
+      const FilterBuildingContext& context, const CompressionOptions& opts,
+      CompressionType preferred) override;
+};
+
+}  // namespace ROCKSDB_NAMESPACE