Add GetTitanOptions() and other options related changes (#32)

Summary:
* Add `GetTitanOptions()` and `GetTitanDBOptions()` API.
* Fix `SetOptions()` fail when `blob_run_mode` is not set.
* Update info log around printing options.

Test Plan:
Updated test.
Signed-off-by: Yi Wu <yiwu@pingcap.com>

include/titan/db.h

@@ -127,11 +127,19 @@ class TitanDB : public StackableDB {
   using rocksdb::StackableDB::GetOptions;
   Options GetOptions(ColumnFamilyHandle* column_family) const override = 0;
 
+  virtual TitanOptions GetTitanOptions(
+      ColumnFamilyHandle* column_family) const = 0;
+  virtual TitanOptions GetTitanOptions() const {
+    return GetTitanOptions(DefaultColumnFamily());
+  }
+
   using rocksdb::StackableDB::SetOptions;
   Status SetOptions(ColumnFamilyHandle* column_family,
                     const std::unordered_map<std::string, std::string>&
                         new_options) override = 0;
 
+  virtual TitanDBOptions GetTitanDBOptions() const = 0;
+
   struct Properties {
     //  "rocksdb.titandb.live-blob-size" - returns total blob value size
     //      referenced by LSM tree.

include/titan/options.h

@@ -121,7 +121,8 @@ struct TitanCFOptions : public ColumnFamilyOptions {
   TitanCFOptions() = default;
   explicit TitanCFOptions(const ColumnFamilyOptions& options)
       : ColumnFamilyOptions(options) {}
-  explicit TitanCFOptions(const ImmutableTitanCFOptions&,
+  explicit TitanCFOptions(const ColumnFamilyOptions&,
+                          const ImmutableTitanCFOptions&,
                           const MutableTitanCFOptions&);
 
   TitanCFOptions& operator=(const ColumnFamilyOptions& options) {
@@ -129,8 +130,6 @@ struct TitanCFOptions : public ColumnFamilyOptions {
     return *this;
   }
 
-  std::string ToString() const;
-
   void Dump(Logger* logger) const;
 };
 

src/db_impl.cc

@@ -200,6 +200,10 @@ Status TitanDBImpl::Open(const std::vector<TitanCFDescriptor>& descs,
       // While we need to preserve original table_factory for GetOptions.
       auto& base_table_factory = base_descs[i].options.table_factory;
       assert(base_table_factory != nullptr);
+      immutable_cf_options_.emplace(cf_id,
+                                    ImmutableTitanCFOptions(descs[i].options));
+      mutable_cf_options_.emplace(cf_id,
+                                  MutableTitanCFOptions(descs[i].options));
       base_table_factory_[cf_id] = base_table_factory;
       titan_table_factory_[cf_id] = std::make_shared<TitanTableFactory>(
           db_options_, descs[i].options, blob_manager_, &mutex_, vset_.get(),
@@ -328,6 +332,10 @@ Status TitanDBImpl::CreateColumnFamilies(
       for (size_t i = 0; i < descs.size(); i++) {
         uint32_t cf_id = (*handles)[i]->GetID();
         column_families.emplace(cf_id, descs[i].options);
+        immutable_cf_options_.emplace(
+            cf_id, ImmutableTitanCFOptions(descs[i].options));
+        mutable_cf_options_.emplace(cf_id,
+                                    MutableTitanCFOptions(descs[i].options));
         base_table_factory_[cf_id] = base_table_factory[i];
         titan_table_factory_[cf_id] = titan_table_factory[i];
       }
@@ -597,9 +605,19 @@ Status TitanDBImpl::SetOptions(
   auto opts = new_options;
   auto p = opts.find("blob_run_mode");
   bool set_blob_run_mode = (p != opts.end());
-  std::string blob_run_mode_string;
+  TitanBlobRunMode mode = TitanBlobRunMode::kNormal;
   if (set_blob_run_mode) {
-    blob_run_mode_string = p->second;
+    const std::string& blob_run_mode_string = p->second;
+    auto pm = blob_run_mode_string_map.find(blob_run_mode_string);
+    if (pm == blob_run_mode_string_map.end()) {
+      return Status::InvalidArgument("No blob_run_mode defined for " +
+                                     blob_run_mode_string);
+    } else {
+      mode = pm->second;
+      ROCKS_LOG_INFO(db_options_.info_log, "[%s] Set blob_run_mode: %s",
+                     column_family->GetName().c_str(),
+                     blob_run_mode_string.c_str());
+    }
     opts.erase(p);
   }
   if (opts.size() > 0) {
@@ -608,23 +626,42 @@ Status TitanDBImpl::SetOptions(
       return s;
     }
   }
-  TitanBlobRunMode mode = TitanBlobRunMode::kNormal;
-  auto pm = blob_run_mode_string_map.find(blob_run_mode_string);
-  if (pm == blob_run_mode_string_map.end()) {
-    return Status::InvalidArgument("No blob_run_mode defined for " +
-                                   blob_run_mode_string);
-  } else {
-    mode = pm->second;
-    ROCKS_LOG_INFO(db_options_.info_log, "[%s] Set blob_run_mode: %s",
-                   column_family->GetName().c_str(),
-                   blob_run_mode_string.c_str());
+  // Make sure base db's SetOptions sucesss before setting blob_run_mode.
+  if (set_blob_run_mode) {
+    uint32_t cf_id = column_family->GetID();
+    {
+      MutexLock l(&mutex_);
+      auto& table_factory = titan_table_factory_[cf_id];
+      table_factory->SetBlobRunMode(mode);
+      mutable_cf_options_[cf_id].blob_run_mode = mode;
+    }
   }
+  return Status::OK();
+}
+
+TitanOptions TitanDBImpl::GetTitanOptions(
+    ColumnFamilyHandle* column_family) const {
+  assert(column_family != nullptr);
+  Options base_options = GetOptions(column_family);
+  TitanOptions titan_options;
+  *static_cast<TitanDBOptions*>(&titan_options) = db_options_;
+  *static_cast<DBOptions*>(&titan_options) =
+      static_cast<DBOptions>(base_options);
+  uint32_t cf_id = column_family->GetID();
   {
     MutexLock l(&mutex_);
-    auto& table_factory = titan_table_factory_[column_family->GetID()];
-    table_factory->SetBlobRunMode(mode);
+    *static_cast<TitanCFOptions*>(&titan_options) = TitanCFOptions(
+        static_cast<ColumnFamilyOptions>(base_options),
+        immutable_cf_options_.at(cf_id), mutable_cf_options_.at(cf_id));
   }
-  return Status::OK();
+  return titan_options;
+}
+
+TitanDBOptions TitanDBImpl::GetTitanDBOptions() const {
+  // Titan db_options_ is not mutable after DB open.
+  TitanDBOptions result = db_options_;
+  *static_cast<DBOptions*>(&result) = db_impl_->GetDBOptions();
+  return result;
 }
 
 bool TitanDBImpl::GetProperty(ColumnFamilyHandle* column_family,

src/db_impl.h

@@ -74,6 +74,13 @@ class TitanDBImpl : public TitanDB {
       ColumnFamilyHandle* column_family,
       const std::unordered_map<std::string, std::string>& new_options) override;
 
+  using TitanDB::GetTitanOptions;
+  TitanOptions GetTitanOptions(
+      ColumnFamilyHandle* column_family) const override;
+
+  using TitanDB::GetTitanDBOptions;
+  TitanDBOptions GetTitanDBOptions() const override;
+
   using TitanDB::GetProperty;
   bool GetProperty(ColumnFamilyHandle* column_family, const Slice& property,
                    std::string* value) override;
@@ -169,8 +176,17 @@ class TitanDBImpl : public TitanDB {
   // is not null.
   std::unique_ptr<TitanStats> stats_;
 
+  // Guarded by mutex_.
+  std::unordered_map<uint32_t, ImmutableTitanCFOptions> immutable_cf_options_;
+
+  // Guarded by mutex_.
+  std::unordered_map<uint32_t, MutableTitanCFOptions> mutable_cf_options_;
+
+  // Guarded by mutex_.
   std::unordered_map<uint32_t, std::shared_ptr<TableFactory>>
       base_table_factory_;
+
+  // Guarded by mutex_.
   std::unordered_map<uint32_t, std::shared_ptr<TitanTableFactory>>
       titan_table_factory_;
 

src/options.cc

@@ -14,17 +14,23 @@ namespace rocksdb {
 namespace titandb {
 
 void TitanDBOptions::Dump(Logger* logger) const {
-  ROCKS_LOG_HEADER(logger, "TitanDBOptions.dirname                : %s",
+  ROCKS_LOG_HEADER(logger, "TitanDBOptions.dirname                    : %s",
                    dirname.c_str());
-  ROCKS_LOG_HEADER(logger, "TitanDBOptions.disable_background_gc  : %d",
-                   static_cast<int>(disable_background_gc));
-  ROCKS_LOG_HEADER(logger, "TitanDBOptions.max_background_gc      : %" PRIi32,
+  ROCKS_LOG_HEADER(logger, "TitanDBOptions.disable_background_gc      : %d",
                    static_cast<int>(disable_background_gc));
+  ROCKS_LOG_HEADER(logger,
+                   "TitanDBOptions.max_background_gc          : %" PRIi32,
+                   max_background_gc);
+  ROCKS_LOG_HEADER(logger,
+                   "TitanDBOptions.purge_obsolete_files_period: %" PRIu32,
+                   purge_obsolete_files_period);
 }
 
-TitanCFOptions::TitanCFOptions(const ImmutableTitanCFOptions& immutable_opts,
+TitanCFOptions::TitanCFOptions(const ColumnFamilyOptions& cf_opts,
+                               const ImmutableTitanCFOptions& immutable_opts,
                                const MutableTitanCFOptions& mutable_opts)
-    : min_blob_size(immutable_opts.min_blob_size),
+    : ColumnFamilyOptions(cf_opts),
+      min_blob_size(immutable_opts.min_blob_size),
       blob_file_compression(immutable_opts.blob_file_compression),
       blob_file_target_size(immutable_opts.blob_file_target_size),
       blob_cache(immutable_opts.blob_cache),
@@ -35,24 +41,6 @@ TitanCFOptions::TitanCFOptions(const ImmutableTitanCFOptions& immutable_opts,
       merge_small_file_threshold(immutable_opts.merge_small_file_threshold),
       blob_run_mode(mutable_opts.blob_run_mode) {}
 
-std::string TitanCFOptions::ToString() const {
-  char buf[256];
-  std::string str;
-  std::string res = "[titandb]\n";
-  snprintf(buf, sizeof(buf), "min_blob_size = %" PRIu64 "\n", min_blob_size);
-  res += buf;
-  GetStringFromCompressionType(&str, blob_file_compression);
-  snprintf(buf, sizeof(buf), "blob_file_compression = %s\n", str.c_str());
-  res += buf;
-  snprintf(buf, sizeof(buf), "blob_file_target_size = %" PRIu64 "\n",
-           blob_file_target_size);
-  res += buf;
-  snprintf(buf, sizeof(buf), "blob_run_mode = %s\n",
-           blob_run_mode_to_string[blob_run_mode].c_str());
-  res += buf;
-  return res;
-}
-
 void TitanCFOptions::Dump(Logger* logger) const {
   ROCKS_LOG_HEADER(logger,
                    "TitanCFOptions.min_blob_size                : %" PRIu64,

src/table_factory.cc

@@ -20,11 +20,8 @@ TableBuilder* TitanTableFactory::NewTableBuilder(
     WritableFileWriter* file) const {
   std::unique_ptr<TableBuilder> base_builder(
       base_factory_->NewTableBuilder(options, column_family_id, file));
-  TitanCFOptions cf_options;
-  {
-    MutexLock l(&mutex_);
-    cf_options = TitanCFOptions(immutable_cf_options_, mutable_cf_options_);
-  }
+  TitanCFOptions cf_options = cf_options_;
+  cf_options.blob_run_mode = blob_run_mode_.load();
   std::weak_ptr<BlobStorage> blob_storage;
   {
     MutexLock l(db_mutex_);
@@ -36,9 +33,9 @@ TableBuilder* TitanTableFactory::NewTableBuilder(
 }
 
 std::string TitanTableFactory::GetPrintableTableOptions() const {
-  MutexLock l(&mutex_);
-  return base_factory_->GetPrintableTableOptions() +
-         TitanCFOptions(immutable_cf_options_, mutable_cf_options_).ToString();
+  assert(blob_run_mode_to_string.count(blob_run_mode_.load()) > 0);
+  return base_factory_->GetPrintableTableOptions() + "  blob_run_mode: " +
+         blob_run_mode_to_string.at(blob_run_mode_.load());
 }
 
 }  // namespace titandb

src/table_factory.h

 #pragma once
 
+#include <atomic>
+
 #include "blob_file_manager.h"
 #include "rocksdb/table.h"
 #include "titan/options.h"
@@ -16,8 +18,8 @@ class TitanTableFactory : public TableFactory {
                     std::shared_ptr<BlobFileManager> blob_manager,
                     port::Mutex* db_mutex, VersionSet* vset, TitanStats* stats)
       : db_options_(db_options),
-        immutable_cf_options_(cf_options),
-        mutable_cf_options_(cf_options),
+        cf_options_(cf_options),
+        blob_run_mode_(cf_options.blob_run_mode),
         base_factory_(cf_options.table_factory),
         blob_manager_(blob_manager),
         db_mutex_(db_mutex),
@@ -52,21 +54,16 @@ class TitanTableFactory : public TableFactory {
 
   void* GetOptions() override { return base_factory_->GetOptions(); }
 
-  void SetBlobRunMode(TitanBlobRunMode mode) {
-    MutexLock l(&mutex_);
-    mutable_cf_options_.blob_run_mode = mode;
-  }
+  void SetBlobRunMode(TitanBlobRunMode mode) { blob_run_mode_.store(mode); }
 
   bool IsDeleteRangeSupported() const override {
     return base_factory_->IsDeleteRangeSupported();
   }
 
  private:
-  mutable port::Mutex mutex_;
-
-  TitanDBOptions db_options_;
-  ImmutableTitanCFOptions immutable_cf_options_;
-  MutableTitanCFOptions mutable_cf_options_;
+  const TitanDBOptions db_options_;
+  const TitanCFOptions cf_options_;
+  std::atomic<TitanBlobRunMode> blob_run_mode_;
   std::shared_ptr<TableFactory> base_factory_;
   std::shared_ptr<BlobFileManager> blob_manager_;
   port::Mutex* db_mutex_;

src/titan_db_test.cc

@@ -613,15 +613,40 @@ TEST_F(TitanDBTest, BlobFileCorruptionErrorHandling) {
 }
 #endif  // !NDEBUG
 
-TEST_F(TitanDBTest, Options) {
+TEST_F(TitanDBTest, SetOptions) {
+  options_.write_buffer_size = 42000000;
+  options_.min_blob_size = 123;
+  options_.blob_run_mode = TitanBlobRunMode::kReadOnly;
   Open();
 
+  TitanOptions titan_options = db_->GetTitanOptions();
+  ASSERT_EQ(42000000, titan_options.write_buffer_size);
+  ASSERT_EQ(123, titan_options.min_blob_size);
+  ASSERT_EQ(TitanBlobRunMode::kReadOnly, titan_options.blob_run_mode);
+
   std::unordered_map<std::string, std::string> opts;
+
+  // Set titan options.
   opts["blob_run_mode"] = "kReadOnly";
   ASSERT_OK(db_->SetOptions(opts));
+  titan_options = db_->GetTitanOptions();
+  ASSERT_EQ(TitanBlobRunMode::kReadOnly, titan_options.blob_run_mode);
+  opts.clear();
 
+  // Set column family options.
   opts["disable_auto_compactions"] = "true";
   ASSERT_OK(db_->SetOptions(opts));
+  titan_options = db_->GetTitanOptions();
+  ASSERT_TRUE(titan_options.disable_auto_compactions);
+  opts.clear();
+
+  // Set DB options.
+  opts["max_background_jobs"] = "15";
+  ASSERT_OK(db_->SetDBOptions(opts));
+  titan_options = db_->GetTitanOptions();
+  ASSERT_EQ(15, titan_options.max_background_jobs);
+  TitanDBOptions titan_db_options = db_->GetTitanDBOptions();
+  ASSERT_EQ(15, titan_db_options.max_background_jobs);
 }
 
 TEST_F(TitanDBTest, BlobRunModeBasic) {