[][src]Crate lockfree_object_pool

A thread-safe object pool collection with automatic return and attach/detach semantics.

Some implementations are lockfree :

Other use std::Mutex :

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

ObjectPoolDuration in Monothreading (us)Duration Multithreading (us)
NoneObjectPool1.2937587.75
MutexObjectPool1.31431.3210
SpinLockObjectPool1.31701.2555
LinearObjectPool0.293990.19894

Report monothreading and multithreading.

Desallocation

ObjectPoolDuration in Monothreading (ns)Duration Multithreading (ns)
NoneObjectPool114.2225.474
MutexObjectPool26.17399.511
SpinLockObjectPool22.49052.378
LinearObjectPool9.915523.028

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.