lock-free-freelist

A fast lock free limited length free list for multiple producer and consumer. It is meant for cases where consumer is as fast as producer and hence the limited length of the free list doesn't matter.

It uses bitmaps of type usize to keep track of the free list and hence free list has a size equal to number of bits in usize. If usize is 8 bytes then 64 and if usize is 4 bytes then 32.

A free list can store free pointers for one type only. For example,

rust let free_list = FreeList::<Box<i32>>::new(); // a free list for Box<i32>

Example

```rust use lockfreefreelist::{FreeList, Reusable}; use std::{thread, iter};

[macro_use]

extern crate lazy_static;

[derive(Reusable)]

struct MyType { name: String, age: u32, }

// from https://crates.io/crates/lazystatic lazystatic! { static ref FREE_LIST: FreeList> = FreeList::>::new(); }

fn main() { // Spawn 4 threads // Each thread will allocate elements of type MyType using FREELIST let threads = iter::repeat(0).take(100) .map(|| { thread::spawn(|| { for i in 0..1000 { let mytype = MyType { name: "Jane".tostring(), age: 30 };

            let mut my_type_on_heap = FREE_LIST.reuse_or_alloc(my_type);

            // This is similar to:
            //      let mut my_type_on_heap = Box::new(my_type);
            // But when using FREE_LIST.reuse_or_alloc(), the dropped
            // memory will be reused.

            my_type_on_heap.name.push_str(" Doe");
            my_type_on_heap.age = i;
        }})
    })
    .collect::<Vec<_>>();

for handle in threads {
    handle.join().unwrap()
}

} ```