[−][src]Crate lockfree_object_pool

A thread-safe object pool collection with automatic return.

Some implementations are lockfree :

Other use std::Mutex :

MutexObjectPool

And NoneObjectPool basic allocation without pool.

Example

The general pool creation looks like this for

  use lockfree_object_pool::LinearObjectPool;
   
  let pool = LinearObjectPool::<u32>::new(
    ||  Default::default(),
    |v| {*v = 0; });

  // And use the object pool
  let mut item = pool.pull();
  *item = 5;

At the end of the scope item return in object pool.

Multithreading

All implementation support allocation/desallocation from on or more thread. You only need to wrap the pool in a std::sync::Arc :

  use lockfree_object_pool::LinearObjectPool;
  use std::sync::Arc;

  let pool = Arc::new(LinearObjectPool::<u32>::new(
       ||  Default::default(),
       |v| {*v = 0; }));

Performance

Global report.

Allocation

ObjectPool	Duration in Monothreading (us)	Duration Multithreading (us)
`NoneObjectPool`	1.2162	0.63033
`MutexObjectPool`	1.2458	1.5140
`SpinLockObjectPool`	1.2437	1.3737
`LinearObjectPool`	0.21764	0.22418
`crate 'sharded-slab'`	1.5	0.82790
`crate 'object-pool'`	0.61956	0.26323

Report monothreading and multithreading.

Desallocation

ObjectPool	Duration in Monothreading (ns)	Duration Multithreading (ns)
`NoneObjectPool`	91.362	86.530
`MutexObjectPool`	25.486	101.40
`SpinLockObjectPool`	22.089	50.411
`LinearObjectPool`	7.1384	34.481
`crate 'sharded-slab'`	9.0273	11.127
`crate 'object-pool'`	20.038	47.768

Report monothreading and multithreading.

Structs

LinearObjectPool	ObjectPool use a lockfree vector to secure multithread access to pull.
LinearReusable	Wrapper over T used by `LinearObjectPool`.
MutexObjectPool	ObjectPool use a `std::sync::Mutex` over vector to secure multithread access to pull.
MutexReusable	Wrapper over T used by `MutexObjectPool`.
NoneObjectPool	Basic allocation without pull. Used to compare default rust allocation with different kind of object pool.
NoneReusable	Wrapper over T used by `NoneObjectPool`.
SpinLockObjectPool	ObjectPool use a spin lock over vector to secure multithread access to pull.
SpinLockReusable	Wrapper over T used by `SpinLockObjectPool`.