*: add wrapper for IOStatsContext (#253)

* *: add wrapper for IOStatsContext

* *: format

* *: test more fields

* *: remove allocate_nanos because darwin doesn't use it

librocksdb_sys/crocksdb/c.cc

@@ -36,6 +36,7 @@
 #include "rocksdb/utilities/debug.h"
 #include "rocksdb/utilities/options_util.h"
 #include "rocksdb/write_batch.h"
+#include "rocksdb/iostats_context.h"
 
 #include "db/column_family.h"
 #include "table/sst_file_writer_collectors.h"
@@ -150,6 +151,7 @@ using rocksdb::CompactionOptions;
 using rocksdb::CompactionReason;
 using rocksdb::PerfLevel;
 using rocksdb::PerfContext;
+using rocksdb::IOStatsContext;
 using rocksdb::BottommostLevelCompaction;
 using rocksdb::LDBTool;
 
@@ -4791,6 +4793,60 @@ uint64_t crocksdb_perf_context_env_new_logger_nanos(crocksdb_perf_context_t* ctx
   return ctx->rep.env_new_logger_nanos;
 }
 
+// IOStatsContext
+
+struct crocksdb_iostats_context_t {
+  IOStatsContext rep;
+};
+
+crocksdb_iostats_context_t* crocksdb_get_iostats_context(void) {
+  return reinterpret_cast<crocksdb_iostats_context_t*>(rocksdb::get_iostats_context());
+}
+
+void crocksdb_iostats_context_reset(crocksdb_iostats_context_t* ctx) {
+  ctx->rep.Reset();
+}
+
+uint64_t crocksdb_iostats_context_bytes_written(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.bytes_written;
+}
+
+uint64_t crocksdb_iostats_context_bytes_read(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.bytes_read;
+}
+
+uint64_t crocksdb_iostats_context_open_nanos(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.open_nanos;
+}
+
+uint64_t crocksdb_iostats_context_allocate_nanos(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.allocate_nanos;
+}
+
+uint64_t crocksdb_iostats_context_write_nanos(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.write_nanos;
+}
+
+uint64_t crocksdb_iostats_context_read_nanos(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.read_nanos;
+}
+
+uint64_t crocksdb_iostats_context_range_sync_nanos(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.range_sync_nanos;
+}
+
+uint64_t crocksdb_iostats_context_fsync_nanos(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.fsync_nanos;
+}
+
+uint64_t crocksdb_iostats_context_prepare_write_nanos(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.prepare_write_nanos;
+}
+
+uint64_t crocksdb_iostats_context_logger_nanos(crocksdb_iostats_context_t* ctx) {
+  return ctx->rep.logger_nanos;
+}
+
 void crocksdb_run_ldb_tool(int argc, char** argv) {
   LDBTool().Run(argc, argv);
 }

librocksdb_sys/crocksdb/crocksdb/c.h

@@ -139,6 +139,7 @@ typedef struct crocksdb_level_meta_data_t crocksdb_level_meta_data_t;
 typedef struct crocksdb_sst_file_meta_data_t crocksdb_sst_file_meta_data_t;
 typedef struct crocksdb_compaction_options_t crocksdb_compaction_options_t;
 typedef struct crocksdb_perf_context_t crocksdb_perf_context_t;
+typedef struct crocksdb_iostats_context_t crocksdb_iostats_context_t;
 typedef struct crocksdb_writestallinfo_t crocksdb_writestallinfo_t;
 typedef struct crocksdb_writestallcondition_t crocksdb_writestallcondition_t;
 
@@ -1895,6 +1896,33 @@ extern C_ROCKSDB_LIBRARY_API uint64_t
 crocksdb_perf_context_env_unlock_file_nanos(crocksdb_perf_context_t*);
 extern C_ROCKSDB_LIBRARY_API uint64_t
 crocksdb_perf_context_env_new_logger_nanos(crocksdb_perf_context_t*);
+
+// IOStatsContext
+extern C_ROCKSDB_LIBRARY_API crocksdb_iostats_context_t*
+crocksdb_get_iostats_context(void);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_iostats_context_reset(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_bytes_written(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_bytes_read(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_open_nanos(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_allocate_nanos(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_write_nanos(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_read_nanos(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_range_sync_nanos(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_fsync_nanos(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_prepare_write_nanos(crocksdb_iostats_context_t*);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_iostats_context_logger_nanos(crocksdb_iostats_context_t*);
+
 extern C_ROCKSDB_LIBRARY_API void
 crocksdb_run_ldb_tool(int argc, char** argv);
 

librocksdb_sys/src/lib.rs

@@ -69,6 +69,7 @@ pub enum DBLevelMetaData {}
 pub enum DBSstFileMetaData {}
 pub enum DBCompactionOptions {}
 pub enum DBPerfContext {}
+pub enum DBIOStatsContext {}
 pub enum DBWriteStallInfo {}
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -1738,6 +1739,20 @@ extern "C" {
     pub fn crocksdb_perf_context_env_lock_file_nanos(ctx: *mut DBPerfContext) -> u64;
     pub fn crocksdb_perf_context_env_unlock_file_nanos(ctx: *mut DBPerfContext) -> u64;
     pub fn crocksdb_perf_context_env_new_logger_nanos(ctx: *mut DBPerfContext) -> u64;
+
+    pub fn crocksdb_get_iostats_context() -> *mut DBIOStatsContext;
+    pub fn crocksdb_iostats_context_reset(ctx: *mut DBIOStatsContext);
+    pub fn crocksdb_iostats_context_bytes_written(ctx: *mut DBIOStatsContext) -> u64;
+    pub fn crocksdb_iostats_context_bytes_read(ctx: *mut DBIOStatsContext) -> u64;
+    pub fn crocksdb_iostats_context_open_nanos(ctx: *mut DBIOStatsContext) -> u64;
+    pub fn crocksdb_iostats_context_allocate_nanos(ctx: *mut DBIOStatsContext) -> u64;
+    pub fn crocksdb_iostats_context_write_nanos(ctx: *mut DBIOStatsContext) -> u64;
+    pub fn crocksdb_iostats_context_read_nanos(ctx: *mut DBIOStatsContext) -> u64;
+    pub fn crocksdb_iostats_context_range_sync_nanos(ctx: *mut DBIOStatsContext) -> u64;
+    pub fn crocksdb_iostats_context_fsync_nanos(ctx: *mut DBIOStatsContext) -> u64;
+    pub fn crocksdb_iostats_context_prepare_write_nanos(ctx: *mut DBIOStatsContext) -> u64;
+    pub fn crocksdb_iostats_context_logger_nanos(ctx: *mut DBIOStatsContext) -> u64;
+
     pub fn crocksdb_run_ldb_tool(argc: c_int, argv: *const *const c_char);
 }
 

src/lib.rs

@@ -31,7 +31,7 @@ pub use librocksdb_sys::{
 };
 pub use merge_operator::MergeOperands;
 pub use metadata::{ColumnFamilyMetaData, LevelMetaData, SstFileMetaData};
-pub use perf_context::{get_perf_level, set_perf_level, PerfContext, PerfLevel};
+pub use perf_context::{get_perf_level, set_perf_level, IOStatsContext, PerfContext, PerfLevel};
 pub use rocksdb::{
     load_latest_options, run_ldb_tool, set_external_sst_file_global_seq_no, BackupEngine, CFHandle,
     DBIterator, DBVector, Env, ExternalSstFileInfo, Kv, Range, SeekKey, SequentialFile,

src/perf_context.rs

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crocksdb_ffi::{self, DBPerfContext};
+use crocksdb_ffi::{self, DBIOStatsContext, DBPerfContext};
 
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum PerfLevel {
@@ -336,6 +336,64 @@ impl PerfContext {
     }
 }
 
+pub struct IOStatsContext {
+    inner: *mut DBIOStatsContext,
+}
+
+impl IOStatsContext {
+    pub fn get() -> IOStatsContext {
+        unsafe {
+            IOStatsContext {
+                inner: crocksdb_ffi::crocksdb_get_iostats_context(),
+            }
+        }
+    }
+
+    pub fn reset(&mut self) {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_reset(self.inner) }
+    }
+
+    pub fn bytes_written(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_bytes_written(self.inner) }
+    }
+
+    pub fn bytes_read(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_bytes_read(self.inner) }
+    }
+
+    pub fn open_nanos(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_open_nanos(self.inner) }
+    }
+
+    pub fn allocate_nanos(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_allocate_nanos(self.inner) }
+    }
+
+    pub fn write_nanos(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_write_nanos(self.inner) }
+    }
+
+    pub fn read_nanos(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_read_nanos(self.inner) }
+    }
+
+    pub fn range_sync_nanos(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_range_sync_nanos(self.inner) }
+    }
+
+    pub fn fsync_nanos(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_fsync_nanos(self.inner) }
+    }
+
+    pub fn prepare_write_nanos(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_prepare_write_nanos(self.inner) }
+    }
+
+    pub fn logger_nanos(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_iostats_context_logger_nanos(self.inner) }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -343,7 +401,7 @@ mod test {
     use tempdir::TempDir;
 
     use rocksdb::{SeekKey, Writable, DB};
-    use rocksdb_options::DBOptions;
+    use rocksdb_options::{DBOptions, WriteOptions};
 
     #[test]
     fn test_perf_context() {
@@ -389,4 +447,46 @@ mod test {
         assert_eq!(ctx.internal_delete_skipped_count(), n / 2);
         assert_ne!(ctx.seek_internal_seek_time(), 0);
     }
+
+    #[test]
+    fn test_iostats_context() {
+        let temp_dir = TempDir::new("test_iostats_context").unwrap();
+        let mut opts = DBOptions::new();
+        opts.create_if_missing(true);
+        let db = DB::open(opts, temp_dir.path().to_str().unwrap()).unwrap();
+
+        set_perf_level(PerfLevel::EnableTime);
+        let mut ctx = IOStatsContext::get();
+
+        ctx.reset();
+        assert_eq!(ctx.bytes_written(), 0);
+        assert_eq!(ctx.bytes_read(), 0);
+        assert_eq!(ctx.open_nanos(), 0);
+        assert_eq!(ctx.allocate_nanos(), 0);
+        assert_eq!(ctx.write_nanos(), 0);
+        assert_eq!(ctx.read_nanos(), 0);
+        assert_eq!(ctx.range_sync_nanos(), 0);
+        assert_eq!(ctx.fsync_nanos(), 0);
+        assert_eq!(ctx.prepare_write_nanos(), 0);
+        assert_eq!(ctx.logger_nanos(), 0);
+
+        let mut wopts = WriteOptions::new();
+        wopts.set_sync(true);
+        let n = 10;
+        for i in 0..n {
+            let k = &[i as u8];
+            db.put_opt(k, k, &wopts).unwrap();
+            db.flush(true).unwrap();
+            assert_eq!(db.get(k).unwrap().unwrap(), k);
+        }
+
+        assert!(ctx.bytes_written() > 0);
+        assert!(ctx.bytes_read() > 0);
+        assert!(ctx.open_nanos() > 0);
+        assert!(ctx.write_nanos() > 0);
+        assert!(ctx.read_nanos() > 0);
+        assert!(ctx.fsync_nanos() > 0);
+        assert!(ctx.prepare_write_nanos() > 0);
+        assert!(ctx.logger_nanos() > 0);
+    }
 }