Make a single call to run_pending_tasks to evict as many entries as

possible from the cache

Ensure the loop in the `do_run_pending_tasks` method is eventually stopped.

src/common.rs

@@ -76,10 +76,10 @@ pub(crate) struct HousekeeperConfig {
     pub(crate) maintenance_task_timeout: Duration,
     /// The maximum repeat count for receiving operation logs from the read and write
     /// log channels. Default: `MAX_LOG_SYNC_REPEATS`.
-    pub(crate) max_log_sync_repeats: usize,
+    pub(crate) max_log_sync_repeats: u32,
     /// The batch size of entries to be processed by each internal eviction method.
     /// Default: `EVICTION_BATCH_SIZE`.
-    pub(crate) eviction_batch_size: usize,
+    pub(crate) eviction_batch_size: u32,
 }
 
 impl Default for HousekeeperConfig {
@@ -88,7 +88,7 @@ impl Default for HousekeeperConfig {
             maintenance_task_timeout: Duration::from_millis(
                 DEFAULT_MAINTENANCE_TASK_TIMEOUT_MILLIS,
             ),
-            max_log_sync_repeats: DEFAULT_MAX_LOG_SYNC_REPEATS,
+            max_log_sync_repeats: DEFAULT_MAX_LOG_SYNC_REPEATS as u32,
             eviction_batch_size: DEFAULT_EVICTION_BATCH_SIZE,
         }
     }
@@ -98,14 +98,15 @@ impl HousekeeperConfig {
     #[cfg(test)]
     pub(crate) fn new(
         maintenance_task_timeout: Option<Duration>,
-        max_log_sync_repeats: Option<usize>,
-        eviction_batch_size: Option<usize>,
+        max_log_sync_repeats: Option<u32>,
+        eviction_batch_size: Option<u32>,
     ) -> Self {
         Self {
             maintenance_task_timeout: maintenance_task_timeout.unwrap_or(Duration::from_millis(
                 DEFAULT_MAINTENANCE_TASK_TIMEOUT_MILLIS,
             )),
-            max_log_sync_repeats: max_log_sync_repeats.unwrap_or(DEFAULT_MAX_LOG_SYNC_REPEATS),
+            max_log_sync_repeats: max_log_sync_repeats
+                .unwrap_or(DEFAULT_MAX_LOG_SYNC_REPEATS as u32),
             eviction_batch_size: eviction_batch_size.unwrap_or(DEFAULT_EVICTION_BATCH_SIZE),
         }
     }

src/common/concurrent/constants.rs

@@ -14,7 +14,7 @@ pub(crate) const WRITE_LOG_CH_SIZE: usize =
 
 // TODO: Calculate the batch size based on the number of entries in the cache (or an
 // estimated number of entries to evict)
-pub(crate) const DEFAULT_EVICTION_BATCH_SIZE: usize = WRITE_LOG_CH_SIZE;
+pub(crate) const DEFAULT_EVICTION_BATCH_SIZE: u32 = WRITE_LOG_CH_SIZE as u32;
 
 /// The default timeout duration for the `run_pending_tasks` method.
 pub(crate) const DEFAULT_MAINTENANCE_TASK_TIMEOUT_MILLIS: u64 = 100;

src/common/concurrent/housekeeper.rs

@@ -14,12 +14,13 @@ use std::{
 };
 
 pub(crate) trait InnerSync {
-    /// Runs the pending tasks. Returns `true` if there are more entries to evict.
+    /// Runs the pending tasks. Returns `true` if there are more entries to evict in
+    /// next run.
     fn run_pending_tasks(
         &self,
         timeout: Option<Duration>,
-        max_log_sync_repeats: usize,
-        eviction_batch_size: usize,
+        max_log_sync_repeats: u32,
+        eviction_batch_size: u32,
     ) -> bool;
 
     fn now(&self) -> Instant;
@@ -43,10 +44,10 @@ pub(crate) struct Housekeeper {
     maintenance_task_timeout: Option<Duration>,
     /// The maximum repeat count for receiving operation logs from the read and write
     /// log channels. Default: `MAX_LOG_SYNC_REPEATS`.
-    max_log_sync_repeats: usize,
+    max_log_sync_repeats: u32,
     /// The batch size of entries to be processed by each internal eviction method.
     /// Default: `EVICTION_BATCH_SIZE`.
-    eviction_batch_size: usize,
+    eviction_batch_size: u32,
     auto_run_enabled: AtomicBool,
 }