Add API for getting blob cache usage (#341)

* add get blob cache usage
* add get and set blob cache capacity
Signed-off-by: Connor1996 <zbk602423539@gmail.com>

librocksdb_sys/build.rs

@@ -111,7 +111,6 @@ fn build_rocksdb() -> Build {
         .register_dep("SNAPPY")
         .define("WITH_SNAPPY", "ON")
         .build_target("rocksdb")
-        .very_verbose(true)
         .build();
     let build_dir = format!("{}/build", dst.display());
     let mut build = Build::new();

librocksdb_sys/crocksdb/c.cc

@@ -5075,6 +5075,15 @@ ctitandb_options_t* ctitandb_options_copy(ctitandb_options_t* src) {
   return new ctitandb_options_t{src->rep};
 }
 
+ctitandb_options_t* ctitandb_get_titan_options_cf(
+    const crocksdb_t* db,
+    crocksdb_column_family_handle_t* column_family) {
+  ctitandb_options_t* options = new ctitandb_options_t;
+   TitanDB* titan_db = reinterpret_cast<TitanDB*>(db->rep);
+  options->rep = titan_db->GetTitanOptions(column_family->rep);
+  return options;
+}
+
 const char* ctitandb_options_dirname(ctitandb_options_t* opts) {
   return opts->rep.dirname.c_str();
 }
@@ -5172,6 +5181,30 @@ void ctitandb_options_set_blob_cache(ctitandb_options_t* options,
   }
 }
 
+size_t ctitandb_options_get_blob_cache_usage(ctitandb_options_t *opt) {
+  if (opt && opt->rep.blob_cache != nullptr) {
+    return opt->rep.blob_cache->GetUsage();
+  }
+  return 0;
+}
+
+void ctitandb_options_set_blob_cache_capacity(ctitandb_options_t* opt, size_t capacity, char **errptr) {
+  Status s;
+  if (opt && opt->rep.blob_cache != nullptr) {
+    return opt->rep.blob_cache->SetCapacity(capacity);
+  } else {
+    s = Status::InvalidArgument("Blob cache was disabled.");
+  }
+  SaveError(errptr, s);
+}
+
+size_t ctitandb_options_get_blob_cache_capacity(ctitandb_options_t* opt) {
+  if (opt && opt->rep.blob_cache != nullptr) {
+    return opt->rep.blob_cache->GetCapacity();
+  }
+  return 0;
+}
+
 void ctitandb_options_set_discardable_ratio(ctitandb_options_t* options,
                                             double ratio) {
   options->rep.blob_file_discardable_ratio = ratio;

librocksdb_sys/crocksdb/crocksdb/c.h

@@ -2011,6 +2011,9 @@ extern C_ROCKSDB_LIBRARY_API void ctitandb_options_destroy(ctitandb_options_t*);
 
 extern C_ROCKSDB_LIBRARY_API ctitandb_options_t* ctitandb_options_copy(
     ctitandb_options_t*);
+   
+extern C_ROCKSDB_LIBRARY_API ctitandb_options_t* ctitandb_get_titan_options_cf(
+    const crocksdb_t* db, crocksdb_column_family_handle_t* column_family);
 
 extern C_ROCKSDB_LIBRARY_API const char* ctitandb_options_dirname(
     ctitandb_options_t*);
@@ -2066,6 +2069,15 @@ extern C_ROCKSDB_LIBRARY_API void ctitandb_options_set_purge_obsolete_files_peri
 extern C_ROCKSDB_LIBRARY_API void ctitandb_options_set_blob_cache(
     ctitandb_options_t* options, crocksdb_cache_t* cache);
 
+extern C_ROCKSDB_LIBRARY_API size_t ctitandb_options_get_blob_cache_usage(
+    ctitandb_options_t *opt);
+
+extern C_ROCKSDB_LIBRARY_API void ctitandb_options_set_blob_cache_capacity(
+  ctitandb_options_t* opt, size_t capacity, char **errptr);
+  
+extern C_ROCKSDB_LIBRARY_API size_t ctitandb_options_get_blob_cache_capacity(
+  ctitandb_options_t* opt);
+
 extern C_ROCKSDB_LIBRARY_API void ctitandb_options_set_discardable_ratio(
     ctitandb_options_t* options, double ratio);
 

librocksdb_sys/libtitan_sys/build.rs

@@ -37,7 +37,6 @@ fn main() {
         .register_dep("SNAPPY")
         .define("WITH_SNAPPY", "ON")
         .build_target("titan")
-        .very_verbose(true)
         .build();
     println!("cargo:rustc-link-search=native={}/build", dst.display());
     println!("cargo:rustc-link-lib=static=titan");

librocksdb_sys/src/lib.rs

@@ -1886,6 +1886,10 @@ extern "C" {
     pub fn ctitandb_options_create() -> *mut DBTitanDBOptions;
     pub fn ctitandb_options_destroy(opts: *mut DBTitanDBOptions);
     pub fn ctitandb_options_copy(opts: *mut DBTitanDBOptions) -> *mut DBTitanDBOptions;
+    pub fn ctitandb_get_titan_options_cf(
+        db: *mut DBInstance,
+        cf: *mut DBCFHandle,
+    ) -> *mut DBTitanDBOptions;
     pub fn ctitandb_options_dirname(opts: *mut DBTitanDBOptions) -> *const c_char;
     pub fn ctitandb_options_set_dirname(opts: *mut DBTitanDBOptions, name: *const c_char);
     pub fn ctitandb_options_min_blob_size(opts: *mut DBTitanDBOptions) -> u64;
@@ -1918,6 +1922,14 @@ extern "C" {
     pub fn ctitandb_options_set_min_gc_batch_size(opts: *mut DBTitanDBOptions, size: u64);
     pub fn ctitandb_options_set_max_gc_batch_size(opts: *mut DBTitanDBOptions, size: u64);
     pub fn ctitandb_options_set_blob_cache(opts: *mut DBTitanDBOptions, cache: *mut DBCache);
+    pub fn ctitandb_options_get_blob_cache_usage(options: *const DBTitanDBOptions) -> usize;
+    pub fn ctitandb_options_set_blob_cache_capacity(
+        options: *const DBTitanDBOptions,
+        capacity: usize,
+        err: *mut *mut c_char,
+    );
+    pub fn ctitandb_options_get_blob_cache_capacity(options: *const DBTitanDBOptions) -> usize;
+
     pub fn ctitandb_options_set_discardable_ratio(opts: *mut DBTitanDBOptions, ratio: f64);
     pub fn ctitandb_options_set_sample_ratio(opts: *mut DBTitanDBOptions, ratio: f64);
     pub fn ctitandb_options_set_merge_small_file_threshold(opts: *mut DBTitanDBOptions, size: u64);

src/rocksdb.rs

@@ -15,7 +15,7 @@
 use crocksdb_ffi::{
     self, DBBackupEngine, DBCFHandle, DBCache, DBCompressionType, DBEnv, DBInstance,
     DBPinnableSlice, DBSequentialFile, DBStatisticsHistogramType, DBStatisticsTickerType,
-    DBWriteBatch,
+    DBTitanDBOptions, DBWriteBatch,
 };
 use libc::{self, c_char, c_int, c_void, size_t};
 use librocksdb_sys::DBMemoryAllocator;
@@ -1410,14 +1410,24 @@ impl DB {
         let cf = self.cf_handle("default").unwrap();
         unsafe {
             let inner = crocksdb_ffi::crocksdb_get_options_cf(self.inner, cf.inner);
-            ColumnFamilyOptions::from_raw(inner)
+            let titan_inner = if self.is_titan() {
+                crocksdb_ffi::ctitandb_get_titan_options_cf(self.inner, cf.inner)
+            } else {
+                ptr::null_mut::<DBTitanDBOptions>()
+            };
+            ColumnFamilyOptions::from_raw(inner, titan_inner)
         }
     }
 
     pub fn get_options_cf(&self, cf: &CFHandle) -> ColumnFamilyOptions {
         unsafe {
             let inner = crocksdb_ffi::crocksdb_get_options_cf(self.inner, cf.inner);
-            ColumnFamilyOptions::from_raw(inner)
+            let titan_inner = if self.is_titan() {
+                crocksdb_ffi::ctitandb_get_titan_options_cf(self.inner, cf.inner)
+            } else {
+                ptr::null_mut::<DBTitanDBOptions>()
+            };
+            ColumnFamilyOptions::from_raw(inner, titan_inner)
         }
     }
 
@@ -1563,6 +1573,14 @@ impl DB {
         self.get_options_cf(cf).get_block_cache_usage()
     }
 
+    pub fn get_blob_cache_usage(&self) -> u64 {
+        self.get_options().get_blob_cache_usage()
+    }
+
+    pub fn get_blob_cache_usage_cf(&self, cf: &CFHandle) -> u64 {
+        self.get_options_cf(cf).get_blob_cache_usage()
+    }
+
     pub fn get_properties_of_all_tables(&self) -> Result<TablePropertiesCollection, String> {
         unsafe {
             let props = ffi_try!(crocksdb_get_properties_of_all_tables(self.inner));

src/rocksdb_options.rs

@@ -34,7 +34,6 @@ use std::ffi::{CStr, CString};
 use std::mem;
 use std::path::Path;
 use std::ptr;
-use std::ptr::null;
 use std::sync::Arc;
 use table_filter::{destroy_table_filter, table_filter, TableFilter};
 use table_properties_collector_factory::{
@@ -1146,14 +1145,17 @@ impl ColumnFamilyOptions {
         ColumnFamilyOptions::default()
     }
 
-    pub unsafe fn from_raw(inner: *mut Options) -> ColumnFamilyOptions {
+    pub unsafe fn from_raw(
+        inner: *mut Options,
+        titan_inner: *mut DBTitanDBOptions,
+    ) -> ColumnFamilyOptions {
         assert!(
             !inner.is_null(),
             "could not new rocksdb options with null inner"
         );
         ColumnFamilyOptions {
             inner,
-            titan_inner: ptr::null_mut::<DBTitanDBOptions>(),
+            titan_inner,
             env: None,
             filter: None,
         }
@@ -1543,6 +1545,10 @@ impl ColumnFamilyOptions {
         unsafe { crocksdb_ffi::crocksdb_options_get_block_cache_usage(self.inner) as u64 }
     }
 
+    pub fn get_blob_cache_usage(&self) -> u64 {
+        unsafe { crocksdb_ffi::ctitandb_options_get_blob_cache_usage(self.titan_inner) as u64 }
+    }
+
     pub fn set_block_cache_capacity(&self, capacity: u64) -> Result<(), String> {
         unsafe {
             ffi_try!(crocksdb_options_set_block_cache_capacity(
@@ -1557,6 +1563,20 @@ impl ColumnFamilyOptions {
         unsafe { crocksdb_ffi::crocksdb_options_get_block_cache_capacity(self.inner) as u64 }
     }
 
+    pub fn set_blob_cache_capacity(&self, capacity: u64) -> Result<(), String> {
+        unsafe {
+            ffi_try!(ctitandb_options_set_blob_cache_capacity(
+                self.titan_inner,
+                capacity as usize
+            ));
+            Ok(())
+        }
+    }
+
+    pub fn get_blob_cache_capacity(&self) -> u64 {
+        unsafe { crocksdb_ffi::ctitandb_options_get_blob_cache_capacity(self.titan_inner) as u64 }
+    }
+
     pub fn set_fifo_compaction_options(&mut self, fifo_opts: FifoCompactionOptions) {
         unsafe {
             crocksdb_ffi::crocksdb_options_set_fifo_compaction_options(self.inner, fifo_opts.inner);
@@ -1653,7 +1673,7 @@ impl CColumnFamilyDescriptor {
         unsafe {
             let raw_cf_options =
                 crocksdb_ffi::crocksdb_options_from_column_family_descriptor(self.inner);
-            ColumnFamilyOptions::from_raw(raw_cf_options)
+            ColumnFamilyOptions::from_raw(raw_cf_options, ptr::null_mut())
         }
     }
 }

tests/cases/test_titan.rs

@@ -277,3 +277,67 @@ fn test_titan_delete_files_in_ranges() {
     iter.seek(SeekKey::Start);
     assert!(!iter.valid());
 }
+
+#[test]
+fn test_get_blob_cache_usage() {
+    let path = TempDir::new("_rust_rocksdb_set_blob_cache").expect("");
+    let tdb_path = path.path().join("titandb");
+    let mut tdb_opts = TitanDBOptions::new();
+    tdb_opts.set_dirname(tdb_path.to_str().unwrap());
+    tdb_opts.set_min_blob_size(0);
+    tdb_opts.set_blob_cache(16 * 1024 * 1024, -1, false, 0.0);
+
+    let mut opts = DBOptions::new();
+    opts.create_if_missing(true);
+    opts.set_titandb_options(&tdb_opts);
+    let mut cf_opts = ColumnFamilyOptions::new();
+    cf_opts.set_titandb_options(&tdb_opts);
+    assert_eq!(cf_opts.get_blob_cache_usage(), 0);
+
+    let db = DB::open_cf(
+        opts,
+        path.path().to_str().unwrap(),
+        vec![("default", cf_opts)],
+    )
+    .unwrap();
+
+    for i in 0..200 {
+        db.put(format!("k_{}", i).as_bytes(), b"v").unwrap();
+    }
+    db.flush(true).unwrap();
+    for i in 0..200 {
+        db.get(format!("k_{}", i).as_bytes()).unwrap();
+    }
+
+    assert!(db.get_options().get_blob_cache_usage() > 0);
+}
+
+#[test]
+fn test_blob_cache_capacity() {
+    let path = TempDir::new("_rust_rocksdb_set_and_get_blob_cache_capacity").expect("");
+    let tdb_path = path.path().join("titandb");
+    let mut tdb_opts = TitanDBOptions::new();
+    tdb_opts.set_dirname(tdb_path.to_str().unwrap());
+    tdb_opts.set_min_blob_size(0);
+    tdb_opts.set_blob_cache(16 * 1024 * 1024, -1, false, 0.0);
+
+    let mut opts = DBOptions::new();
+    opts.create_if_missing(true);
+    opts.set_titandb_options(&tdb_opts);
+    let mut cf_opts = ColumnFamilyOptions::new();
+    cf_opts.set_titandb_options(&tdb_opts);
+
+    let db = DB::open_cf(
+        opts,
+        path.path().to_str().unwrap(),
+        vec![("default", cf_opts)],
+    )
+    .unwrap();
+
+    assert_eq!(db.get_options().get_blob_cache_capacity(), 16 * 1024 * 1024);
+
+    let opt = db.get_options();
+    opt.set_blob_cache_capacity(32 * 1024 * 1024).unwrap();
+
+    assert_eq!(db.get_options().get_blob_cache_capacity(), 32 * 1024 * 1024);
+}