dealloc(target_ptr.cast(), value_layout);

                lock.data[dealloc_index] = ptr::null_mut();

            }

            index += 1;

            index &= lock.compare_mask;

        }

        // With all of those set to null, we'll just iterate through all

        // pointers and destruct+deallocate the ones not set to null yet

        for target_ptr in lock.data.iter().copied() {

            if !target_ptr.is_null() {

                unsafe {

                    ptr::drop_in_place(target_ptr);

                    dealloc(target_ptr.cast(), value_layout);

                }

            }

        }

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use rand::prelude::*;

    use rand_pcg::Pcg32;

    use std::sync::Arc;

    use std::sync::atomic::{AtomicU64, Ordering};

    fn seeds() -> Vec<[u8;16]> {

        return vec![

            [241, 47, 70, 87, 240, 246, 20, 173, 219, 143, 74, 23, 158, 58, 205, 172],

            [178, 112, 230, 205, 230, 178, 2, 90, 162, 218, 49, 196, 224, 222, 208, 43],

            [245, 42, 35, 167, 153, 205, 221, 144, 200, 253, 144, 117, 176, 231, 17, 70],

            [143, 39, 177, 216, 124, 96, 225, 39, 30, 82, 239, 193, 133, 58, 255, 193],

            [25, 105, 10, 52, 161, 212, 190, 112, 178, 193, 68, 249, 167, 153, 172, 144],

        ]

    }

    #[test]

    fn test_ctor_dtor_simple_unthreaded() {

        const NUM_ROUNDS: usize = 5;

        const NUM_ELEMENTS: usize = 1024;

        let store = ComponentStore::new(32);

        let ctor_counter = Arc::new(AtomicU64::new(0));

        let dtor_counter = Arc::new(AtomicU64::new(0));

        let mut indices = Vec::with_capacity(NUM_ELEMENTS);

        for _round_index in 0..NUM_ROUNDS {

            // Creation round

            for value in 0..NUM_ELEMENTS {

                let new_resource = Resource::new(ctor_counter.clone(), dtor_counter.clone(), value as u64);

pub mod component;

pub mod unfair_se_lock;

pub mod queue_mpsc;

pub(crate) use component::ComponentStore;