chore: bump foyer to 0.19

Cargo.toml

@@ -58,7 +58,7 @@ exn = { version = "0.1.0-alpha.5" }
 fastimer = { version = "0.9.0" }
 fastrace = { version = "0.7.9" }
 fastrace-opentelemetry = { version = "0.13.0" }
-foyer = { version = "0.18.0", features = ["nightly"] }
+foyer = { version = "0.19.1", features = ["nightly"] }
 futures-util = { version = "0.3.31" }
 gix-discover = { version = "0.41.0" }
 googletest = { version = "0.14.0" }

crates/core/src/engine.rs

@@ -18,21 +18,25 @@ use std::sync::Arc;
 use exn::IntoExn;
 use exn::Result;
 use exn::bail;
-use foyer::DirectFsDeviceOptions;
+use foyer::BlockEngineBuilder;
+use foyer::DeviceBuilder;
 use foyer::FifoConfig;
+use foyer::FsDeviceBuilder;
 use foyer::HybridCache;
 use foyer::HybridCacheBuilder;
 use foyer::HybridCachePolicy;
-use foyer::LargeEngineOptions;
+use foyer::IoEngineBuilder;
+use foyer::PsyncIoEngineBuilder;
 use foyer::RecoverMode;
 use foyer::RuntimeOptions;
-use sysinfo::Pid;
 use thiserror::Error;
 
+use crate::available_memory;
 use crate::newtype::DiskThrottle;
 use crate::num_cpus;
 
-const DEFAULT_MEMORY_CAPACITY_FACTOR: f64 = 0.8;
+const DEFAULT_MEMORY_CAPACITY_FACTOR: f64 = 0.5; // 50% of available memory
+const DEFAULT_BLOCK_SIZE: usize = 64 * 1024 * 1024; // 64 MiB
 
 #[derive(Debug, Error)]
 #[error("{0}")]
@@ -58,27 +62,19 @@ impl FoyerEngine {
             )));
         }
 
-        let mut dev = DirectFsDeviceOptions::new(data_dir)
-            .with_capacity(disk_capacity as usize)
-            .with_file_size(64 * 1024 * 1024);
+        let mut db = FsDeviceBuilder::new(data_dir).with_capacity(disk_capacity as usize);
         if let Some(throttle) = disk_throttle {
-            dev = dev.with_throttle(throttle.into());
+            db = db.with_throttle(throttle.into());
         }
+        let dev = db
+            .build()
+            .map_err(|err| EngineError(format!("failed to create device: {err}")))?;
 
         let parallelism = num_cpus().get();
-        let storage = foyer::Engine::Large(LargeEngineOptions::default());
         let cache = HybridCacheBuilder::new()
             .with_policy(HybridCachePolicy::WriteOnInsertion)
             .memory(
-                (memory_capacity.map_or_else(
-                    || {
-                        let s = sysinfo::System::new_all();
-                        s.process(Pid::from_u32(std::process::id()))
-                            .unwrap()
-                            .memory() as usize
-                    },
-                    |v| v as usize,
-                ) as f64
+                (memory_capacity.map_or_else(|| available_memory().get(), |v| v as usize) as f64
                     * DEFAULT_MEMORY_CAPACITY_FACTOR) as usize,
             )
             .with_weighter(|key: &Vec<u8>, value: &Vec<u8>| {
@@ -88,8 +84,14 @@ impl FoyerEngine {
             })
             .with_shards(parallelism)
             .with_eviction_config(FifoConfig::default())
-            .storage(storage)
-            .with_device_options(dev)
+            .storage()
+            .with_engine_config(BlockEngineBuilder::new(dev).with_block_size(DEFAULT_BLOCK_SIZE))
+            .with_io_engine(
+                PsyncIoEngineBuilder::new()
+                    .build()
+                    .await
+                    .map_err(|err| EngineError(err.to_string()).into_exn())?,
+            )
             .with_recover_mode(RecoverMode::Quiet)
             .with_runtime_options(RuntimeOptions::Unified(Default::default()))
             .build()

crates/core/src/lib.rs

@@ -17,6 +17,8 @@ mod engine;
 mod newtype;
 mod runtime;
 
+use std::num::NonZeroUsize;
+
 pub use config::*;
 pub use engine::*;
 pub use runtime::*;
@@ -25,12 +27,28 @@ pub use runtime::*;
 // This method fills the gap that `std::thread::available_parallelism()`
 // may return `Err` on some platforms, in which case we default to `1`.
 #[track_caller]
-pub fn num_cpus() -> std::num::NonZeroUsize {
+pub fn num_cpus() -> NonZeroUsize {
     match std::thread::available_parallelism() {
         Ok(parallelism) => parallelism,
         Err(err) => {
             log::warn!("failed to fetch the available parallelism (fallback to 1): {err:?}");
-            std::num::NonZeroUsize::new(1).unwrap()
+            NonZeroUsize::new(1).unwrap()
         }
     }
 }
+
+pub fn available_memory() -> NonZeroUsize {
+    const RESERVED_MEMORY: usize = 128 * 1024 * 1024; // 128 MB
+    static MEMORY: std::sync::OnceLock<NonZeroUsize> = std::sync::OnceLock::new();
+
+    *MEMORY.get_or_init(|| {
+        let mut sys = sysinfo::System::new();
+        sys.refresh_memory();
+        let mem = sys.cgroup_limits().map_or_else(
+            || sys.total_memory() as usize,
+            |limits| limits.total_memory as usize,
+        );
+
+        NonZeroUsize::new(mem.saturating_sub(RESERVED_MEMORY).max(RESERVED_MEMORY)).unwrap()
+    })
+}