Add rust bindings for HybridMode cachelib

Summary:
Cachelib has [`HybridMode`](https://staticdocs.internalfb.com/cachelib/docs/Cache_Library_User_Guides/HybridCache) where you can make use of DRAM as the primary cache and NVM flash storage as the secondary layer of cache. In Source Control, we rely heavily on caching yet do not take advantage of the disk space available on all our hosts.

This diff adds the necessary Cxx bindings to make the HybridMode cache availble for rust clients.

Differential Revision: D71834889

fbshipit-source-id: 76fb33acbabb1ad35ab28e4953928c3e5f4e76a4

Author: RajivTS

cachelib/rust/src/cachelib.cpp

@@ -47,6 +47,11 @@ std::unique_ptr<LruAllocator> make_shm_lru_allocator(
 std::unique_ptr<LruAllocatorConfig> make_lru_allocator_config() {
   return std::make_unique<LruAllocatorConfig>();
 }
+
+std::unique_ptr<NvmCacheConfig> make_nvm_cache_config() {
+  return std::make_unique<NvmCacheConfig>();
+}
+
 std::shared_ptr<facebook::cachelib::RebalanceStrategy>
 make_hits_per_slab_rebalancer(double diff_ratio,
                               unsigned int min_retained_slabs,
@@ -130,6 +135,25 @@ void set_base_address(LruAllocatorConfig& config, size_t addr) {
   config.slabMemoryBaseAddr = (void*)addr;
 }
 
+void enable_nvm_cache(LruAllocatorConfig& config, NvmCacheConfig& nvmConfig) {
+  config.enableNvmCache(nvmConfig);
+}
+
+void set_block_size(NvmCacheConfig& config, uint64_t blockSize) {
+  config.navyConfig.setBlockSize(blockSize);
+}
+
+void set_simple_file(NvmCacheConfig& config,
+                     const std::string& fileName,
+                     uint64_t fileSize,
+                     bool truncateFile) {
+  config.navyConfig.setSimpleFile(fileName, fileSize, truncateFile);
+}
+
+void set_region_size(NvmCacheConfig& config, uint32_t regionSize) {
+  config.navyConfig.blockCache().setRegionSize(regionSize);
+}
+
 int8_t add_pool(const LruAllocator& cache,
                 folly::StringPiece name,
                 size_t size) {

cachelib/rust/src/cachelib.h

@@ -29,6 +29,7 @@ namespace cachelib {
 using LruAllocator = facebook::cachelib::LruAllocator;
 using LruAllocatorConfig = LruAllocator::Config;
 using LruItemHandle = LruAllocator::WriteHandle;
+using NvmCacheConfig = LruAllocator::NvmCacheConfig;
 
 std::unique_ptr<facebook::cachelib::CacheAdmin> make_cacheadmin(
     LruAllocator& cache, const std::string& oncall);
@@ -38,8 +39,12 @@ std::unique_ptr<LruAllocator> make_shm_lru_allocator(
     std::unique_ptr<LruAllocatorConfig> config);
 std::unique_ptr<LruAllocatorConfig> make_lru_allocator_config();
 
+std::unique_ptr<NvmCacheConfig> make_nvm_cache_config();
+
 bool enable_container_memory_monitor(LruAllocatorConfig& config);
 
+void enable_nvm_cache(LruAllocatorConfig& config, NvmCacheConfig& nvmConfig);
+
 std::shared_ptr<facebook::cachelib::RebalanceStrategy>
 make_hits_per_slab_rebalancer(double diff_ratio,
                               unsigned int min_retained_slabs,
@@ -84,6 +89,15 @@ void enable_cache_persistence(LruAllocatorConfig& config,
 
 void set_base_address(LruAllocatorConfig& config, size_t addr);
 
+void set_block_size(NvmCacheConfig& config, uint64_t blockSize);
+
+void set_simple_file(NvmCacheConfig& config,
+                     const std::string& fileName,
+                     uint64_t fileSize,
+                     bool truncateFile);
+
+void set_region_size(NvmCacheConfig& config, uint32_t regionSize);
+
 int8_t add_pool(const LruAllocator& cache,
                 folly::StringPiece name,
                 size_t size);

cachelib/rust/src/lib.rs

@@ -55,6 +55,9 @@ mod ffi {
             config: UniquePtr<LruAllocatorConfig>,
         ) -> Result<UniquePtr<LruAllocator>>;
 
+        type NvmCacheConfig;
+        fn make_nvm_cache_config() -> Result<UniquePtr<NvmCacheConfig>>;
+
         type LruAllocatorConfig;
         fn make_lru_allocator_config() -> Result<UniquePtr<LruAllocatorConfig>>;
         fn setCacheSize(
@@ -75,6 +78,11 @@ mod ffi {
             min_retained_slabs: u32,
         ) -> Result<SharedPtr<RebalanceStrategy>>;
 
+        fn enable_nvm_cache(
+            config: Pin<&mut LruAllocatorConfig>,
+            nvm_config: Pin<&mut NvmCacheConfig>,
+        ) -> Result<()>;
+
         fn enable_free_memory_monitor(
             config: Pin<&mut LruAllocatorConfig>,
             interval: milliseconds,
@@ -123,6 +131,17 @@ mod ffi {
             directory: Pin<&mut CxxString>,
         );
 
+        fn set_block_size(config: Pin<&mut NvmCacheConfig>, size: u64) -> Result<()>;
+
+        fn set_simple_file(
+            config: Pin<&mut NvmCacheConfig>,
+            file_name: &CxxString,
+            file_size: u64,
+            truncate_file: bool,
+        ) -> Result<()>;
+
+        fn set_region_size(config: Pin<&mut NvmCacheConfig>, region_size: u32) -> Result<()>;
+
         fn add_pool(cache: &LruAllocator, name: StringPiece<'_>, size: usize) -> Result<i8>;
         fn get_unreserved_size(cache: &LruAllocator) -> usize;
 

cachelib/rust/src/lrucache.rs

@@ -154,6 +154,24 @@ struct AccessConfig {
     lock_power: u32,
 }
 
+/// NvmDevice configuration options.
+#[allow(dead_code)]
+enum NvmDevice {
+    SimpleFile {
+        file_name: String,
+        file_size: u64,
+        truncate: bool,
+    },
+    DefaultDevice,
+}
+
+/// NvmCache configuration options.
+struct NvmCacheConfig {
+    block_size: u64,
+    region_size: u32,
+    device: NvmDevice,
+}
+
 /// LRU cache configuration options.
 pub struct LruCacheConfig {
     size: usize,
@@ -164,6 +182,7 @@ pub struct LruCacheConfig {
     access_config: Option<AccessConfig>,
     cache_directory: Option<PathBuf>,
     base_address: Option<*mut std::ffi::c_void>,
+    nvm_cache_config: Option<NvmCacheConfig>,
 }
 
 impl LruCacheConfig {
@@ -178,9 +197,17 @@ impl LruCacheConfig {
             access_config: None,
             cache_directory: None,
             base_address: None,
+            nvm_cache_config: None,
         }
     }
 
+    /// Enable NvmCache with the given configuration.
+    #[allow(private_interfaces)]
+    pub fn set_nvm_cache_config(mut self, config: NvmCacheConfig) -> Self {
+        self.nvm_cache_config = Some(config);
+        self
+    }
+
     /// Enables the container shrinker if running in a supported container runtime.
     /// So far, this only works for Facebook internal containers
     pub fn set_container_shrinker(mut self) -> Self {
@@ -354,6 +381,22 @@ impl LruCache {
             ffi::set_base_address(cache_config.pin_mut(), addr as usize)?;
         }
 
+        if let Some(nvm_config) = config.nvm_cache_config {
+            let mut nvm_cache_config = ffi::make_nvm_cache_config()?;
+            ffi::set_block_size(nvm_cache_config.pin_mut(), nvm_config.block_size)?;
+            if let NvmDevice::SimpleFile {
+                file_name,
+                file_size,
+                truncate,
+            } = nvm_config.device
+            {
+                let_cxx_string!(name = file_name);
+                ffi::set_simple_file(nvm_cache_config.pin_mut(), &name, file_size, truncate)?;
+            }
+            ffi::set_region_size(nvm_cache_config.pin_mut(), nvm_config.region_size)?;
+            ffi::enable_nvm_cache(cache_config.pin_mut(), nvm_cache_config.pin_mut())?;
+        }
+
         if let Some(cache_directory) = config.cache_directory {
             // If cache directory is enabled, create a persistent shared-memory cache.
             let_cxx_string!(cache_directory = cache_directory.as_os_str().as_bytes());
@@ -1163,12 +1206,13 @@ impl VolatileLruCachePool {
 
 #[cfg(test)]
 mod test {
+    use tempfile::NamedTempFile;
     use tempfile::TempDir;
 
     use super::*;
 
-    fn create_cache(fb: FacebookInit) {
-        let config = LruCacheConfig::new(128 * 1024 * 1024)
+    fn create_basic_cache_config() -> LruCacheConfig {
+        LruCacheConfig::new(128 * 1024 * 1024)
             .set_shrinker(ShrinkMonitor {
                 shrinker_type: ShrinkMonitorType::ResidentSize {
                     max_process_size_gib: 16,
@@ -1196,7 +1240,11 @@ mod test {
                     age_difference_ratio: 0.1,
                     min_retained_slabs: 1,
                 },
-            });
+            })
+    }
+
+    fn create_cache(fb: FacebookInit) {
+        let config = create_basic_cache_config();
 
         if let Err(e) = init_cache(fb, config) {
             panic!("{}", e);
@@ -1207,38 +1255,34 @@ mod test {
         TempDir::with_prefix(dir_prefix).expect("failed to create temp dir")
     }
 
+    fn create_temp_file() -> String {
+        NamedTempFile::new()
+            .expect("Failed to create temporary file in test")
+            .path()
+            .to_string_lossy()
+            .to_string()
+    }
+
     fn create_shared_cache(fb: FacebookInit, cache_directory: PathBuf) {
-        let config = LruCacheConfig::new(128 * 1024 * 1024)
-            .set_shrinker(ShrinkMonitor {
-                shrinker_type: ShrinkMonitorType::ResidentSize {
-                    max_process_size_gib: 16,
-                    min_process_size_gib: 1,
-                },
-                interval: Duration::new(1, 0),
-                max_resize_per_iteration_percent: 10,
-                max_removed_percent: 90,
-                strategy: RebalanceStrategy::LruTailAge {
-                    age_difference_ratio: 0.1,
-                    min_retained_slabs: 1,
-                },
-            })
-            .set_pool_resizer(PoolResizeConfig {
-                interval: Duration::new(1, 0),
-                slabs_per_iteration: 100,
-                strategy: RebalanceStrategy::LruTailAge {
-                    age_difference_ratio: 0.1,
-                    min_retained_slabs: 1,
-                },
-            })
-            .set_cache_dir(cache_directory)
-            .set_pool_rebalance(PoolRebalanceConfig {
-                interval: Duration::new(1, 0),
-                strategy: RebalanceStrategy::LruTailAge {
-                    age_difference_ratio: 0.1,
-                    min_retained_slabs: 1,
-                },
-            });
+        let mut config = create_basic_cache_config();
+        config = config.set_cache_dir(cache_directory);
+        if let Err(e) = init_cache(fb, config) {
+            panic!("{}", e);
+        }
+    }
 
+    fn create_hybrid_cache(fb: FacebookInit) {
+        let mut config = create_basic_cache_config();
+        let nvm_cache_config = NvmCacheConfig {
+            block_size: 4096,
+            region_size: 16 * 1024 * 1024,
+            device: NvmDevice::SimpleFile {
+                file_name: create_temp_file(),
+                file_size: 18 * 1024 * 1024,
+                truncate: false,
+            },
+        };
+        config = config.set_nvm_cache_config(nvm_cache_config);
         if let Err(e) = init_cache(fb, config) {
             panic!("{}", e);
         }
@@ -1257,6 +1301,11 @@ mod test {
         );
     }
 
+    #[fbinit::test]
+    fn only_create_hybrid_cache(fb: FacebookInit) {
+        create_hybrid_cache(fb);
+    }
+
     #[fbinit::test]
     fn set_item(fb: FacebookInit) {
         // Insert only, and confirm insert success
@@ -1479,6 +1528,42 @@ mod test {
         Ok(())
     }
 
+    #[fbinit::test]
+    fn test_hybrid_cache(fb: FacebookInit) -> Result<()> {
+        create_hybrid_cache(fb);
+
+        // Test set or replace (since Insert API is not support for HybridCache right now)
+        let pool = get_or_create_pool("find_pool_by_name", 24 * 1024 * 1024)?;
+        assert!(
+            pool.set_or_replace(b"rimmer", Bytes::from(b"I am a fish".as_ref()))
+                .unwrap(),
+            "Set failed"
+        );
+
+        // Fetch an item that doesn't exist
+        assert_eq!(
+            pool.get(b"doesnotexist").unwrap(),
+            None,
+            "Successfully fetched a bad value"
+        );
+
+        // Test get
+        assert_eq!(
+            pool.get(b"rimmer").unwrap(),
+            Some(Bytes::from(b"I am a fish".as_ref())),
+            "Fetch failed"
+        );
+
+        // Test update and fetch
+        pool.set_or_replace(b"rimmer", Bytes::from(b"I am a bird".as_ref()))?;
+        assert_eq!(
+            pool.get(b"rimmer").unwrap(),
+            Some(Bytes::from(b"I am a bird".as_ref())),
+            "Fetch failed"
+        );
+        Ok(())
+    }
+
     #[fbinit::test]
     fn ttl(fb: FacebookInit) {
         // test ttl in seconds of cache items are set correctly based on the input