Struct forceps::evictors::FifoEvictor

pub struct FifoEvictor { /* fields omitted */ }

First-in-first-out eviction algorithm for a Cache

This algorithm will evict items in a Cache in the order that they were originally written to the cache, so the first entry will be the first removed. It will stop evicting items when a certain minimum total size is met.

O(?) & Async

This eviction algorithm has no guarantee on being fast or efficient at all. It is expected that this algorithm is called infrequently, only when absolutely needed.

This algorithm also contains blocking calls in an async context, mainly metadata iterations and lookups. The reason for the async context is for the actual removals from cache.

Configuration

Minimum Size

This is the minimum size that the cache must shrink to until the eviction algorithm will stop evicting items.

Batch Size

To create one batch, an entire iteration over the metadata must be performed. However, smaller values means that there is less checking/sorting for each batch found. Higher values should be used if you’re expecting to evict more items at a time.

Examples

use forceps::{Cache, evictors::FifoEvictor};

let cache = Cache::new("./cache")
    .build()
    .await?;
const MIN_SIZE: u64 = 512 * 1024 * 1024; // 512MiB

// Option 1:
cache.evict_with(FifoEvictor::new(MIN_SIZE).set_batch_size(500)).await?;

// Option 2:
use forceps::evictors::Evictor;
FifoEvictor::new(MIN_SIZE).set_batch_size(500).evict(&cache).await?;

Implementations

impl FifoEvictor

pub fn new(min_size: u64) -> Self

Creates a new instance of FifoEvictor that will evict items to min_size bytes.

pub fn set_batch_size(self, size: usize) -> Self

Sets the batch size for the evictor

Larger numbers generally increase performance on larger evictions, but decrease performance on smaller evictions. Read FifoEvictor documentation for more information.

Default is 250

Trait Implementations

impl Clone for FifoEvictor

fn clone(&self) -> FifoEvictor

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FifoEvictor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Evictor for FifoEvictor

type Err = ForcepError

The error type that the evict method will produce.

fn evict<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cache: &'life1 Cache
) -> Pin<Box<dyn Future<Output = Result<(), Self::Err>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

The method that is called to evict old or outdated items from the Cache database.