Mixed compressor adding RandomCompressorManager to db_stress_test (facebook#13691)

Summary:
**Summary:**
This pull request configures RocksDB to optionally utilize this customized compressor (RandomCompressor) in the db stress test. It randomly selects the compression algorithm among the blocks.

Pull Request resolved: facebook#13691

Test Plan: Testing was performed by verifying the stdout output from both RandomCompressor.

Reviewed By: hx235

Differential Revision: D76624220

Pulled By: shubhajeet

fbshipit-source-id: d9c458eeee930b25e8a87a77dc29f0647836310e

Author: Sujit Maharjan

db/db_test2.cc

@@ -1936,9 +1936,9 @@ TEST_F(DBTest2, RoundRobinManager) {
   }
 }
 
-TEST_F(DBTest2, SimpleMixedCompressionManager) {
+TEST_F(DBTest2, RandomMixedCompressionManager) {
   if (ZSTD_Supported()) {
-    auto mgr = std::make_shared<SimpleMixedCompressionManager>(
+    auto mgr = std::make_shared<RandomMixedCompressionManager>(
         GetDefaultBuiltinCompressionManager());
     // Currently mixedmanager only supports with preffered compression manager
     // zstd

db_stress_tool/db_stress_test_base.cc

@@ -3412,27 +3412,32 @@ void StressTest::Open(SharedState* shared, bool reopen) {
     InitializeOptionsFromFlags(cache_, filter_policy_, options_);
   }
   InitializeOptionsGeneral(cache_, filter_policy_, sqfc_factory_, options_);
-  if (strcasecmp(FLAGS_compression_manager.c_str(), "none")) {
+  if (!strcasecmp(FLAGS_compression_manager.c_str(), "mixed") ||
+      !strcasecmp(FLAGS_compression_manager.c_str(), "randommixed")) {
+    // Currently limited to ZSTD compression. Table property compression_name
+    // needs to set to zstd for now even when there can be more than one
+    // algorithm in the table under your compressor.
+    if (!ZSTD_Supported()) {
+      fprintf(stderr,
+              "ZSTD compression not supported thus mixed compression cannot be "
+              "used\n");
+      exit(1);
+    }
     if (!strcasecmp(FLAGS_compression_manager.c_str(), "mixed")) {
-      // Currently limited to ZSTD compression. Table property compression_name
-      // needs to set to zstd for now even when there can be more than one
-      // algorithm in the table under your compressor.
-      if (!ZSTD_Supported()) {
-        fprintf(
-            stderr,
-            "ZSTD compression not supported thus mixed compression cannot be "
-            "used\n");
-        exit(1);
-      }
       auto mgr = std::make_shared<RoundRobinManager>(
           GetDefaultBuiltinCompressionManager());
       options_.compression_manager = mgr;
-      options_.compression = kZSTD;
-      options_.bottommost_compression = kZSTD;
-    } else if (!strcasecmp(FLAGS_compression_manager.c_str(), "autoskip")) {
-      options_.compression_manager = CreateAutoSkipCompressionManager(
+    } else if (!strcasecmp(FLAGS_compression_manager.c_str(), "randommixed")) {
+      auto mgr = std::make_shared<RandomMixedCompressionManager>(
           GetDefaultBuiltinCompressionManager());
+      options_.compression_manager = mgr;
     }
+    options_.compression = kZSTD;
+    options_.bottommost_compression = kZSTD;
+
+  } else if (!strcasecmp(FLAGS_compression_manager.c_str(), "autoskip")) {
+    options_.compression_manager =
+        CreateAutoSkipCompressionManager(GetDefaultBuiltinCompressionManager());
   } else if (!strcasecmp(FLAGS_compression_manager.c_str(), "none")) {
     // Nothing to do using default compression manager
   } else {

tools/db_crashtest.py

@@ -349,7 +349,9 @@
     "memtable_avg_op_scan_flush_trigger": lambda: random.choice([0, 2, 20, 200]),
     "ingest_wbwi_one_in": lambda: random.choice([0, 0, 100, 500]),
     "universal_reduce_file_locking": lambda: random.randint(0, 1),
-    "compression_manager": lambda: random.choice(["mixed", "none", "autoskip"]),
+    "compression_manager": lambda: random.choice(
+        ["mixed"] * 1 + ["none"] * 2 + ["autoskip"] * 2 + ["randommixed"] * 2
+    ),
 }
 
 _TEST_DIR_ENV_VAR = "TEST_TMPDIR"
@@ -1000,7 +1002,10 @@ def finalize_and_sanitize(src_params):
             dest_params["exclude_wal_from_write_fault_injection"] = 1
             dest_params["metadata_write_fault_one_in"] = 0
     # Disabling block align if mixed manager is neing used
-    if dest_params.get("compression_manager") == "mixed":
+    if (
+        dest_params.get("compression_manager") == "mixed"
+        or dest_params.get("compression_manager") == "randommixed"
+    ):
         if dest_params.get("block_align") == 1:
             dest_params["block_align"] = 0
         dest_params["compression_type"] = "zstd"

util/simple_mixed_compressor.cc

@@ -55,8 +55,7 @@ std::unique_ptr<Compressor> MultiCompressorWrapper::MaybeCloneSpecialized(
                                                     std::move(dict_samples));
 }
 
-// SimpleMixedCompressor implementation
-Status SimpleMixedCompressor::CompressBlock(
+Status RandomMixedCompressor::CompressBlock(
     Slice uncompressed_data, std::string* compressed_output,
     CompressionType* out_compression_type, ManagedWorkingArea* wa) {
   auto selected =
@@ -66,18 +65,17 @@ Status SimpleMixedCompressor::CompressBlock(
                                    out_compression_type, wa);
 }
 
-// SimpleMixedCompressionManager implementation
-const char* SimpleMixedCompressionManager::Name() const {
+const char* RandomMixedCompressionManager::Name() const {
   return wrapped_->Name();
-  // return "SimpleMixedCompressionManager";
+  // return "RandomMixedCompressionManager";
 }
 
-std::unique_ptr<Compressor> SimpleMixedCompressionManager::GetCompressorForSST(
+std::unique_ptr<Compressor> RandomMixedCompressionManager::GetCompressorForSST(
     const FilterBuildingContext& context, const CompressionOptions& opts,
     CompressionType preferred) {
   assert(preferred == kZSTD);
   (void)context;
-  return std::make_unique<SimpleMixedCompressor>(opts, preferred);
+  return std::make_unique<RandomMixedCompressor>(opts, preferred);
 }
 
 // RoundRobinCompressor implementation

util/simple_mixed_compressor.h

@@ -33,14 +33,14 @@ class MultiCompressorWrapper : public Compressor {
   std::vector<std::unique_ptr<Compressor>> compressors_;
 };
 
-struct SimpleMixedCompressor : public MultiCompressorWrapper {
+struct RandomMixedCompressor : public MultiCompressorWrapper {
   using MultiCompressorWrapper::MultiCompressorWrapper;
   Status CompressBlock(Slice uncompressed_data, std::string* compressed_output,
                        CompressionType* out_compression_type,
                        ManagedWorkingArea* wa) override;
 };
 
-class SimpleMixedCompressionManager : public CompressionManagerWrapper {
+class RandomMixedCompressionManager : public CompressionManagerWrapper {
   using CompressionManagerWrapper::CompressionManagerWrapper;
   const char* Name() const override;
   std::unique_ptr<Compressor> GetCompressorForSST(