#cache #object-pool #pool #buffer


A hybrid object pool and LFU cache that permits cached object reuse. Useful for avoiding allocations

2 releases

Uses old Rust 2015

0.1.1 Apr 9, 2016
0.1.0 Apr 9, 2016

#306 in Caching

Download history 46/week @ 2024-01-08 199/week @ 2024-01-29 382/week @ 2024-02-05 323/week @ 2024-02-12 115/week @ 2024-02-19 142/week @ 2024-02-26 79/week @ 2024-03-04 200/week @ 2024-03-11 384/week @ 2024-03-18 57/week @ 2024-03-25 241/week @ 2024-04-01 58/week @ 2024-04-08 294/week @ 2024-04-15

669 downloads per month
Used in nut

MIT license

100 lines


A hybrid LFU cache and object pool that allows values to be cached and easily reused.


A PoolCache is a hybrid LFU cache and object pool, that allows for caching behavior with the possibility of reusing object rather than dropping them from the cache automatically.


use poolcache::PoolCache;

// Create a new pool cache with a maximum 'heat' of 4.
// Larger maxium heat values make popular values more resistent
// to being reused, but at the cost of increasing the potential
// work required to find a re-usable entry.
let mut cache : PoolCache<u64, Vec<u8>> = PoolCache::new(4);

// Caches are empty until you populate them..`insert` adds a 
// new value associated with a key.
cache.insert(1, Vec::new());

// `cache` now contains a single vector, associated with the key
// `1`, which can be retrieved with `get`
    let vecref : &Vec<u8> = cache.get(&1).unwrap();

// You can also add values that aren't associated with any key with
// `put`. These newly added values will be used to satisfy `take`
// requests before evicting objects with keys.

// You can get an owned object from the pool using `take`. This will
// use any free objects (if available), or evict the least `hot`
// key from the cache, and return its value.
let ownedvec : Vec<u8> = cache.take().unwrap();

No runtime deps