instance_copy_on_write/

lib.rs

/*-
 * instance-copy-on-write - a synchronization primitive based on copy-on-write.
 * 
 * Copyright (C) 2025 Aleksandr Morozov alex@
 * 
 * The scram-rs crate can be redistributed and/or modified
 * under the terms of either of the following licenses:
 *
 *   1. the Mozilla Public License Version 2.0 (the “MPL”) OR
 *                     
 *   2. EUROPEAN UNION PUBLIC LICENCE v. 1.2 EUPL © the European Union 2007, 2016
 */



extern crate crossbeam_utils;
extern crate crossbeam_deque;

#[cfg(test)]
use std::sync::{Arc, Weak};

use std::
{
    cell::RefCell, collections::HashMap, fmt::{self}, marker::PhantomData, ops::{Deref, DerefMut}, ptr::{self, NonNull}, sync::atomic::{AtomicPtr, AtomicU32, Ordering}, time::Duration
};

use crossbeam_deque::{Injector, Steal};
use crossbeam_utils::{atomic::AtomicCell, sync::{Parker, Unparker}, Backoff};

/// An internal instance which exists in the heap i.e boxed which pointer is leaked.
/// Must be destructed manually. Contains all controlling items and the stored item 
/// itself.
#[derive(Debug)]
struct InstanceCopyOnWriteInner<ITEM: Send + fmt::Debug>
{
    /// Needed for tests only.
    #[cfg(test)]
    arc_tag: Arc<()>,

    /// Amount of borrows. Normally it eq 1 which means exists in base only.
    refs: AtomicU32,

    /// An exclusive lock which required to be waken up when all (except base) borrows
    /// are dropped.
    wake_up_lock: AtomicPtr<()>,

    /// A stored item.
    item: ITEM
}

impl<ITEM: Send + fmt::Debug> InstanceCopyOnWriteInner<ITEM>
{
    thread_local! 
    {
        /// A borrows counter for EACH THREAD which helps to detect dead locks when borrowed and
        /// gains exclusive lock from same thread (viceversa not possible).
        static BORROWS: RefCell<HashMap<usize, usize>> = RefCell::new(HashMap::with_capacity(10));
    }

    /// Creates new instance.
    fn new(item: ITEM) -> Self
    {
        return 
            Self
            {
                #[cfg(test)]
                arc_tag: Arc::new(()),

                refs: AtomicU32::new(1),

                wake_up_lock: AtomicPtr::new(ptr::null_mut()),

                item: item,
            };
    }

    /// Returns the weak reference to check if instance is still exists.
    #[cfg(test)]
    fn get_weak_tag(&self) -> Weak<()>
    {
        return Arc::downgrade(&self.arc_tag);
    }
}

/// An instance which contains a clonned [InstanceCopyOnWriteInner]. Desctructs the
/// [InstanceCopyOnWriteInner] when no references left or wakes up the locking
/// thread.
#[derive(Debug)]
struct InstanceCopyOnWriteClone<ITEM: Send + fmt::Debug>
{
    /// A copied pointer to the heap.
    inst: NonNull<InstanceCopyOnWriteInner<ITEM>>
}


impl<ITEM: Send + fmt::Debug> Clone for InstanceCopyOnWriteClone<ITEM>
{
    /// Clones the self. 
    #[inline]
    fn clone(&self) -> Self 
    {
        let inner = unsafe { self.inst.as_ref() };

        inner.refs.fetch_add(1, Ordering::SeqCst);

        return Self { inst: self.inst };
    }
}



impl<ITEM: Send + fmt::Debug> Drop for InstanceCopyOnWriteClone<ITEM>
{
    fn drop(&mut self) 
    {
        // decrease the refs, returns the value before substruction
        let subed = unsafe{ self.inst.as_ref() }.refs.fetch_sub(1, Ordering::AcqRel);

        if subed == 2
        {
            // check if the locking thread needs to be unparked i.e waked up.
            let inst_ref = unsafe{ self.inst.as_ref() };

            let wakeup_ptr = inst_ref.wake_up_lock.swap(ptr::null_mut(), Ordering::Relaxed);

            if wakeup_ptr.is_null() == false
            {
                unsafe { Unparker::from_raw(wakeup_ptr.cast_const()) }.unpark();
            }
        }
        else if subed == 1
        {
            // remove the borrow ID
            InstanceCopyOnWriteInner
                ::<ITEM>
                ::BORROWS
                    .with_borrow_mut(|v|
                        {
                           // v.remove(&self.inner().id);
                            v.remove(&self.inst.as_ptr().addr());
                        }
                    );
            
            drop(unsafe { Box::from_raw(self.inst.as_ptr()) });
        }

        return;
    }
}

impl<ITEM: Send + fmt::Debug>  InstanceCopyOnWriteClone<ITEM>
{
    fn new(item: ITEM) -> Self
    {
        let status = Box::new(InstanceCopyOnWriteInner::new(item));

        return Self{ inst: Box::leak(status).into() };
    }

    #[inline]
    fn load_refs(&self) -> u32
    {
        return unsafe { self.inst.as_ref() }.refs.load(Ordering::Acquire);
    }

    #[inline]
    fn inner(&self) -> &InstanceCopyOnWriteInner<ITEM>
    {
        return unsafe { self.inst.as_ref() };
    }

    #[inline]
    fn inner_mut(&mut self) -> &mut InstanceCopyOnWriteInner<ITEM>
    {
        return unsafe { self.inst.as_mut() };
    }
}

/// A error for the Cow operations.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CowGuardError
{
    /// The instance was poisoned during exclusive lock (non-cow operation).
    Poisoned,

    /// An exclusive lock is pending so another writing opration performing Cow 
    /// would block.
    ExclusiveLockPending,

    /// Is returned by the borrow operation if an exclusive lock (non-cow op) is pending.
    WouldBlock, 
}

impl fmt::Display for CowGuardError
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        match self
        {
            Self::Poisoned => 
                write!(f, "poisoned"),
            Self::ExclusiveLockPending => 
                write!(f, "exclusive lock pending"),
            Self::WouldBlock => 
                write!(f, "wouldblock"),
        }
    }
}

/// A guard which guards the read-only CoW operation. 
#[derive(Debug)]
pub struct CowReadGuard<'read, ITEM: Send + fmt::Debug> 
{
    /// A clonned instance with increased reference value
    inst: InstanceCopyOnWriteClone<ITEM>,

    /// A reference to the main instance.
    owner_ref: &'read InstanceCopyOnWrite<ITEM>,

    _p_thread_lock: PhantomData<*const ()>,
}


impl<'read, ITEM: Send + fmt::Debug> CowReadGuard<'read, ITEM>
{
    /// Creates new instance.
    /// 
    /// # Arguments
    /// 
    /// * `owner` - a reference to base structure [InstanceCopyOnWrite].
    /// 
    /// * `try_borrow` - if set to `true` will return [CowGuardError::WouldBlock].
    /// 
    /// # Returns
    /// 
    /// A [Result] is returned with:
    /// 
    /// * [Result::Ok] with the guard is returned.
    /// 
    /// * [Result::Err] with the error is returned:
    /// 
    /// 
    /// * [CowGuardError::Poisoned] - if the exclusive was poisoned i.e thread panicked.
    /// 
    /// * [CowGuardError::WouldBlock] - if the argument `try_borrow` is set to `true`.
    #[inline]
    fn new(owner: &'read InstanceCopyOnWrite<ITEM>, try_borrow: bool) -> Result<CowReadGuard<'read, ITEM>, CowGuardError>
    {
        let bkoff = Backoff::new();

        loop
        {
            // try to update the status
            let status = 
                owner.owner_lock.compare_exchange(CowLockStatus::Ok, CowLockStatus::Borrow);

            match status
            {
                Ok(CowLockStatus::Ok) =>
                {
                    let ptr = owner.owner_inner.load(Ordering::Relaxed);

                    let cloned_read: InstanceCopyOnWriteClone<ITEM> = unsafe {ptr.as_ref()}.unwrap().clone();

                    // return the status back. it does not matter if it was not restored due to changes.
                    let _ = owner.owner_lock.compare_exchange(CowLockStatus::Borrow, CowLockStatus::Ok);

                    // set the thread local borrow counter for the exclusive lock
                    InstanceCopyOnWriteInner::<ITEM>::BORROWS.with_borrow_mut(|v| 
                        {
                            v.entry(cloned_read.inst.as_ptr().addr()).and_modify(|v| *v += 1).or_insert(1);
                        }
                    );

                    return Ok(
                        Self
                        {
                            inst: cloned_read,
                            owner_ref: owner,
                            _p_thread_lock: PhantomData
                        }
                    );
                },
                Err(CowLockStatus::Borrow) =>
                {
                    // someone already borrowed it
                    bkoff.snooze();
                    continue;
                },
                Err(CowLockStatus::Poisoned) =>
                {
                    return Err(CowGuardError::Poisoned);
                },
                Err(CowLockStatus::Park) =>
                {
                    // an exclusive lock is pending.

                    if try_borrow == false
                    {
                        if bkoff.is_completed() == true
                        {
                            let p = Parker::new();
                            let u = p.unparker().clone();

                            owner.park_queue.push(u);

                            p.park_timeout(Duration::from_millis(500));
                        }
                        else
                        {
                            bkoff.snooze();
                        }
                    }
                    else
                    {
                        return Err(CowGuardError::WouldBlock);
                    }

                    continue;
                },
                _ => 
                    panic!("assertion trap: wrong status: {:?}", status),
            }
        }
       
    }
}

impl<'read, ITEM: Send + fmt::Debug> Deref for CowReadGuard<'read, ITEM>
{
    type Target = ITEM;

    fn deref(&self) -> &Self::Target
    {
        return & unsafe { self.inst.inst.as_ref()}.item;
    }
}

impl<'read, ITEM: Send + fmt::Debug> Drop for CowReadGuard<'read, ITEM>
{
    fn drop(&mut self) 
    {
        // decrease the borrow count for the thread.
        InstanceCopyOnWriteInner
            ::<ITEM>
            ::BORROWS
                .with_borrow_mut(|v| 
                    {
                        v
                            .get_mut(&self.inst.inst.as_ptr().addr())
                            .map(|v| *v -= 1);
                    }
                );
    }
}

/// A guard which guards the CoW read/write operation. During this operation, the 
/// instance is borrowed and copied or clonned or default or new instance created.
/// 
/// This method of modifying does not require to release all borrows i.e [CowReadGuard].
/// Instead the value in the base will be replaced and anyone who will request the
/// `borrow` after the update will see the new value. The rest who keeps `borrow` would
/// still use old value.
#[derive(Debug)]
pub struct CowTransactionGuard<'tra, ITEM: Send + fmt::Debug> 
{
    /// A reference to the base instance.
    icow: &'tra InstanceCopyOnWrite<ITEM>,
    
    /// A copied or newly created instance.
    new_inst: ITEM,

    /// A guard to read only guard.
    cloned_read: CowReadGuard<'tra, ITEM>,

    /// No send, no sync
    _p_thread_lock: PhantomData<*const ()>,
}

impl<'tra, ITEM: Send + fmt::Debug> Deref for CowTransactionGuard<'tra, ITEM>
{
    type Target = ITEM;

    fn deref(&self) -> &Self::Target
    {
        return &self.new_inst;
    }
}

impl<'tra, ITEM: Send + fmt::Debug> DerefMut for CowTransactionGuard<'tra, ITEM>
{
    fn deref_mut(&mut self) -> &mut Self::Target
    {
        return &mut self.new_inst;
    }
}


impl<'tra, ITEM: Send + fmt::Debug> CowTransactionGuard<'tra, ITEM>
{
    /// Returns the previous reference to the item (old value) which will be replaced.
    pub 
    fn get_previous(&self) -> &ITEM
    {
        return &self.cloned_read;
    }

    /// Completes the transaction by attempting to replace the old `item` with new `item`
    /// in the base. If argument `try_update` is set to `true`, the completed will not block,
    /// but return an error to repeat the attempt later.
    /// 
    /// # Arguments
    /// 
    /// The instance is consumed.
    /// 
    /// `try_update` - if set to `true` does not block if exclusive lock is pending.
    /// 
    /// # Returns
    /// 
    /// A [Result] is returned with:
    /// 
    /// * [Result::Ok] with the guard is returned.
    /// 
    /// * [Result::Err] with the error is returned:
    /// 
    /// 
    /// * [CowGuardError::Poisoned] - if the exclusive was poisoned i.e thread panicked.
    /// 
    /// * [CowGuardError::ExclusiveLockPending] - if the argument `try_borrow` is set to `true`.
    pub 
    fn completed(self, try_update: bool) -> Result<(),(Self, CowGuardError)>
    {
        let bkoff = Backoff::new();

        loop
        {
            let status = 
                self.icow.owner_lock.compare_exchange(CowLockStatus::Ok, CowLockStatus::Borrow);

            match status
            {
                Ok(CowLockStatus::Ok) =>
                {
                    let boxed_inner = Box::new(InstanceCopyOnWriteClone::new(self.new_inst));

                    let prev_inner = self.icow.owner_inner.swap(Box::leak(boxed_inner), Ordering::Relaxed);

                    drop(unsafe { Box::from_raw(prev_inner) });

                    let _ = self.icow.owner_lock.compare_exchange(CowLockStatus::Borrow, CowLockStatus::Ok);

                    return Ok(());
                },
                Err(CowLockStatus::Poisoned) =>
                {
                    return Err((self, CowGuardError::Poisoned));
                },
                Err(CowLockStatus::Borrow) =>
                {
                    bkoff.snooze();
                    continue;
                },
                Err(CowLockStatus::Park) =>
                {
                    if try_update == false
                    {
                        bkoff.snooze();
                        continue;
                    }
                    else
                    {
                        // reject locked exclusivly.
                        return Err((self, CowGuardError::ExclusiveLockPending));
                    }
                },
                _ => 
                    panic!("assertion trap: CowTransactionGuard::complete() unknwon status: {:?}", status)
            }
        }
    }
}

/// An errors for exclusive lock i.e non-cow operation.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum NoCowGuardErr
{
    /// The instance is already exclusivly locked, so either try again later or
    /// borrow. This can be used to prevent multiple update on failures.
    AlreadyLocked,

    /// The instance is borrowed (CoW read) by the calling thread already, so deadlock
    /// prevented.
    Borrowed,

    /// The instance is poisoned.
    Poisoned //todo
}

impl fmt::Display for NoCowGuardErr
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        match self
        {
            NoCowGuardErr::AlreadyLocked => 
                write!(f, "already locked"),
            NoCowGuardErr::Borrowed => 
                write!(f, "borrowed"),
            NoCowGuardErr::Poisoned => 
                write!(f, "poisoned"),
        }
    }
}

/// A guard which is assigned to the [NoCowGuard] for the execution flow
/// control. 
#[derive(Clone, Debug)]
struct NoCowPanicGuard
{
    #[cfg(all(panic = "unwind"))]
    panicking: bool,
}

#[cfg(all(panic = "unwind"))]
impl Default for NoCowPanicGuard
{
    fn default() -> Self 
    {
        use std::thread;

        Self { panicking: thread::panicking() }
    }
}


/// Guards the exclusive lock. During this lock, any CoW operations are
/// blocked. 
/// 
/// * The current thread must not borrow the locking instance.
/// 
/// * No other thread (except calling) should already hold exclusive lock.
/// 
/// * Must not be poisoned.
#[derive(Debug)]
pub struct NoCowGuard<'lock, ITEM: Send + fmt::Debug> 
{
    /// Poison detection.
    poison_guard: NoCowPanicGuard,

    /// The instance which is modified.
    inst: InstanceCopyOnWriteClone<ITEM>,

    /// A reference to base.
    icow: &'lock InstanceCopyOnWrite<ITEM>,
}

impl<'lock, ITEM: Send + fmt::Debug> Drop for NoCowGuard<'lock, ITEM>
{
    fn drop(&mut self) 
    {
        // check panic and restore or set status lock
        #[cfg(all(panic = "unwind"))]
        let res = 
            if self.poison_guard.panicking == false && std::thread::panicking() == true
            {
                self.icow.owner_lock.compare_exchange(CowLockStatus::Park, CowLockStatus::Poisoned)
            }
            else
            {
                self.icow.owner_lock.compare_exchange(CowLockStatus::Park, CowLockStatus::Ok)
            };

        #[cfg(not(all(panic = "unwind")))]
        let res =
            self.icow.owner_lock.compare_exchange(CowLockStatus::Park, CowLockStatus::Ok);


        if let Err(e) = res
        {
            panic!("asserion trap: expected CowLockStatus::Ok, got {}", e);
        }

        loop
        {
            match self.icow.park_queue.steal()
            {
                Steal::Empty => 
                    break,
                Steal::Success(unp) => 
                    unp.unpark(),
                Steal::Retry => 
                    {},
            }
        }

        return;
    }
}

impl<'lock, ITEM: Send + fmt::Debug> Deref for NoCowGuard<'lock, ITEM>
{
    type Target = ITEM;

    fn deref(&self) -> &Self::Target
    {
        return & unsafe { self.inst.inst.as_ref() }.item;
    }
}

impl<'lock, ITEM: Send + fmt::Debug> DerefMut for NoCowGuard<'lock, ITEM>
{
    fn deref_mut(&mut self) -> &mut Self::Target
    {
        return &mut unsafe { self.inst.inst.as_mut() }.item;
    }
}

impl<'lock, ITEM: Send + fmt::Debug> NoCowGuard<'lock, ITEM>
{
    /// Creates new instance.
    /// 
    /// # Arguments 
    /// 
    /// * `depoison` - [bool] if set to true would attemt to accure lock even if the instance was
    ///     poisoned.
    /// 
    /// # Returns
    /// 
    /// A [Result] is returned with:
    /// 
    /// * [Result::Ok] with the guard is returned.
    /// 
    /// * [Result::Err] with the error is returned:
    /// 
    /// 
    /// * [NoCowGuardErr::Poisoned] - if the exclusive was poisoned i.e thread panicked.
    /// 
    /// * [NoCowGuardErr::Borrowed] - if the instance is borrowed by the current thread.
    /// 
    /// * [NoCowGuardErr::AlreadyLocked] - if the instance already exclusivly locked.
    #[inline]
    fn new(owner: &'lock InstanceCopyOnWrite<ITEM>, depoison: bool) -> Result<NoCowGuard<'lock, ITEM>, NoCowGuardErr>
    {

        let status = 
            if depoison == false
            {
                CowLockStatus::Ok
            }
            else
            {
                CowLockStatus::Poisoned
            };
            
        let poison_guard = NoCowPanicGuard::default();

        let bkoff = Backoff::new();

        loop
        {
            let status = 
                owner.owner_lock.compare_exchange(status, CowLockStatus::Park);

            if let Ok(CowLockStatus::Ok) = status
            {
                let ptr = owner.owner_inner.load(Ordering::Relaxed);
                let ptr_ref = unsafe{ ptr.as_ref() }.unwrap();
                
                // check if thread borrows the variable
                if 
                    InstanceCopyOnWriteInner
                        ::<ITEM>
                        ::BORROWS
                            .with_borrow(|v| 
                                v.get(&ptr_ref.inst.as_ptr().addr()).map_or(true, |f| f.eq(&0))
                            ) 
                    == false
                {
                    let _ = owner.owner_lock.compare_exchange(CowLockStatus::Park, CowLockStatus::Ok);

                    return Err(NoCowGuardErr::Borrowed);
                }

                let mut unparker_ptr: Option<*const ()> = None;

                let p = Parker::new();

                // locked, now wait until every any borrow still active
                loop
                {
                    

                    let ptr_refs = ptr_ref.load_refs();

                   
                    if ptr_refs == 1
                    {
                        break;
                    }
                    else if ptr_refs == 0
                    {
                        // (should not happen) return error
                        panic!("assetion trap: ptr_rfs == 0");
                    }

                    if bkoff.is_completed() == true
                    {
                        
                        // park the thread or return WouldBlock?

                       if let None = unparker_ptr
                       {
                            let cloned_read: InstanceCopyOnWriteClone<ITEM> = ptr_ref.clone();

                            let unpark_ptr = Unparker::into_raw(p.unparker().clone());

                            unparker_ptr.replace(unpark_ptr);

                            cloned_read.inner().wake_up_lock.store(unpark_ptr.cast_mut(), Ordering::Relaxed);
                        }
                      
                        p.park_timeout(Duration::from_millis(10));
                    }
                    else
                    {
                        bkoff.snooze();
                    }
                }
 
                if let Some(_) = unparker_ptr
                {
                    let unpark_ptr = ptr_ref.inner().wake_up_lock.swap(ptr::null_mut(), Ordering::Relaxed).cast_const();

                    if unpark_ptr.is_null() == false
                    {
                        drop( unsafe { Unparker::from_raw(unpark_ptr) });
                    }
                }

                return Ok(
                    Self
                    {
                        poison_guard: poison_guard,
                        inst: ptr_ref.clone(),
                        icow: owner,
                    }
                );
            }
            else if let Err(CowLockStatus::Poisoned) = status
            {
                return Err(NoCowGuardErr::Poisoned);
            }
            else if let Err(CowLockStatus::Borrow) = status
            {
                bkoff.snooze();
                continue;
            }
            else
            {
                return Err(NoCowGuardErr::AlreadyLocked);
            }
        } // loop
       
    } 
}

/// An internal lock status.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum CowLockStatus
{
    Ok, Borrow, Park, Poisoned
}

impl fmt::Display for CowLockStatus
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        match self
        {
            Self::Ok => 
                write!(f, "OK"),
            Self::Borrow => 
                write!(f, "BORROW"),
            Self::Park => 
                write!(f, "PARK"),
            Self::Poisoned =>
                write!(f, "POISONED")
        }
    }
}

/// A base instance which is used to perform CoW and non-CoW operations on the inner value.
/// 
/// Borrow:
/// 
/// ```ignore
/// let val = 
///     InstanceCopyOnWrite::new(TestStruct::new(1, 2));
/// 
/// let test_borrow = val.borrow().unwrap();
/// ```
/// 
/// CoW copy-on-write
/// 
/// ```ignore
/// let val = 
///     InstanceCopyOnWrite::new(TestStruct::new(1, 2));
/// 
/// let test_borrow = val.borrow().unwrap();
/// ```
/// 
/// ```ignore
/// let val = 
///     InstanceCopyOnWrite::new(TestStruct::new(1, 2));
/// 
/// let mut transaction = val.start_copying().unwrap();
/// 
/// transaction.start = 5;
/// transaction.stop = 6;
/// 
/// transaction.completed(false).unwrap();
/// ```
/// 
/// Exclusive lock (non-CoW)
/// 
/// ```ignore
/// let val = 
///     InstanceCopyOnWrite::new(TestStruct::new(1, 2));
/// 
/// let lock = val.lock();
/// 
/// drop(lock);
/// ```
#[derive(Debug)]
pub struct InstanceCopyOnWrite<ITEM: Send + fmt::Debug>
{
    /// A sync primitive based on the [AtomicCell]. Contains the current status.
    owner_lock: AtomicCell<CowLockStatus>,

    /// All threads which were awaiting the exclusive lock and parked.
    park_queue: Injector<Unparker>,

    /// Contains a raw [Box] value which must be destructed manually when the writing is
    /// completed!
    owner_inner: AtomicPtr<InstanceCopyOnWriteClone<ITEM>>,
}

impl<ITEM: Send + fmt::Debug> Drop for  InstanceCopyOnWrite<ITEM>
{
    fn drop(&mut self) 
    {
        let status = 
            self.owner_lock.compare_exchange(CowLockStatus::Ok, CowLockStatus::Borrow);

        if let Ok(CowLockStatus::Ok) = status
        {
            let ptr = self.owner_inner.swap(ptr::null_mut(), Ordering::Relaxed);

            if ptr.is_null() == false
            {
                drop(unsafe { Box::from_raw(ptr) });
            }

            while let Steal::Success(s) = self.park_queue.steal() 
            {
                s.unpark();
            }

            return;
        }
        else 
        {
            panic!("assertion trap: destructing InstanceCopyOnWrite while borrowed");
        }
    }
}

impl<ITEM: Send + fmt::Debug> InstanceCopyOnWrite<ITEM>
{
    /// Cretaes new instance with the pre-initialized item.
    pub 
    fn new(item: ITEM) -> Self
    {
        let boxed_inner = Box::new(InstanceCopyOnWriteClone::new(item));

        return 
            Self
            {
                owner_lock: AtomicCell::new(CowLockStatus::Ok), 
                park_queue: Injector::new(),
                owner_inner: AtomicPtr::new( Box::leak(boxed_inner) ) 
            };
    }

    /// Borrows the `ITEM` for read-only operations. The instance will remain
    /// unchaned even after the writing using copy-on-write. As long as the
    /// `borrow` exists, the exclusive lock is not possible.
    /// 
    /// # Returns 
    /// 
    /// Either a [Result::Ok] with [CowReadGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    #[inline]
    pub 
    fn borrow(&self) -> Result<CowReadGuard<'_, ITEM>, CowGuardError>
    {
        return CowReadGuard::new(self, false);    
    }

    /// Attempts to borrows the `ITEM` for read-only operations. If eclusive lock is
    /// pending, the error will be returned see [CowReadGuard::new].
    /// 
    /// The instance will remain unchaned even after the writing using copy-on-write. 
    /// As long as the `borrow` exists, the exclusive lock is not possible.
    /// 
    /// # Returns 
    /// 
    /// Either a [Result::Ok] with [CowReadGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    #[inline]
    pub 
    fn try_borrow(&self) -> Result<CowReadGuard<'_, ITEM>, CowGuardError>
    {
        return CowReadGuard::new(self, true);    
    }

    /// Makes the exclusive lock. See [NoCowGuard] for more information about 
    /// pre-requests. See [NoCowGuard::new] for more info.
    /// 
    /// # Returns 
    /// 
    /// Either a [Result::Ok] with [NoCowGuard] or [Result::Err] with [NoCowGuardErr]
    /// is returned.
    #[inline]
    pub 
    fn lock(&self) -> Result<NoCowGuard<'_, ITEM>, NoCowGuardErr>
    {
        return NoCowGuard::new(self, false); 
    }

    /// Manually removes poison status by forcing the lock. (untested)
    /// 
    /// Does not check if any borrows.
    /// 
    /// See [NoCowGuard] for more info.
    /// 
    /// # Returns 
    /// 
    /// Either a [Result::Ok] with [NoCowGuard] or [Result::Err] with [NoCowGuardErr]
    /// is returned.
    pub 
    fn remove_poison_lock(&self) -> Result<NoCowGuard<'_, ITEM>, NoCowGuardErr>
    {
        return NoCowGuard::new(self, true); 
    }

    /// Manually removes poison status by setting `new_inst` to the inner.  (untested)
    /// 
    /// Is safer than [Self::remove_poison_lock] because active borrows would not be affected.
    /// 
    /// See [NoCowGuard] for more info.
    /// 
    /// # Returns 
    /// 
    /// Either a [Result::Ok] with () or [Result::Err] with [NoCowGuardErr]
    /// is returned.
    /// 
    /// * [NoCowGuardErr::AlreadyLocked] - if someone is already attempting to depoison.
    /// 
    /// * [NoCowGuardErr::Poisoned] - depoisoning have failed
    pub 
    fn remove_poison_write(&self, new_inst: ITEM) -> Result<(), NoCowGuardErr>
    {
        let Ok(_) = self.owner_lock.compare_exchange(CowLockStatus::Poisoned, CowLockStatus::Park)
            else { return Err( NoCowGuardErr::AlreadyLocked )};

        let boxed_inner = Box::new(InstanceCopyOnWriteClone::new(new_inst));

        let prev_inner = self.owner_inner.swap(Box::leak(boxed_inner), Ordering::Relaxed);

        drop(unsafe { Box::from_raw(prev_inner) });

        let Ok(_) = self.owner_lock.compare_exchange(CowLockStatus::Park, CowLockStatus::Ok)
            else { return Err(NoCowGuardErr::Poisoned) };

        return Ok(());
    }
}

impl<ITEM: Send + fmt::Debug + Copy>  InstanceCopyOnWrite<ITEM>
{
    /// Performing the copy-on-write by copying [Copy] the inner value `ITEM`.
    /// 
    /// See [CowTransactionGuard] for more info.
    /// 
    /// Either a [Result::Ok] with [CowTransactionGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    pub 
    fn start_copying(&self) -> Result<CowTransactionGuard<'_, ITEM>, CowGuardError>
    {
        let cloned_read = self.borrow()?;

        let new_inst = unsafe { cloned_read.inst.inst.as_ref()}.item;

        return Ok(
            CowTransactionGuard
            {
                icow: self, 
                new_inst: new_inst,
                cloned_read: cloned_read,
                _p_thread_lock: PhantomData,
            }
        );
    }

    /// Attempts to perform the copy-on-write by copying [Copy] the inner value `ITEM`.
    /// 
    /// See [CowTransactionGuard] for more info.
    /// 
    /// Either a [Result::Ok] with [CowTransactionGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    pub 
    fn try_start_copying(&self) -> Result<CowTransactionGuard<'_, ITEM>, CowGuardError>
    {
        let cloned_read = self.try_borrow()?;

        let new_inst = unsafe { cloned_read.inst.inst.as_ref()}.item;

        return Ok(
            CowTransactionGuard
            {
                icow: self, 
                new_inst: new_inst,
                cloned_read: cloned_read,
                _p_thread_lock: PhantomData,
            }
        );
    }
}

impl<ITEM: Send + fmt::Debug + Clone>  InstanceCopyOnWrite<ITEM>
{
    /// Performing the copy-on-write by cloning [Clone] the inner value `ITEM`.
    /// 
    /// See [CowTransactionGuard] for more info.
    /// 
    /// Either a [Result::Ok] with [CowTransactionGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    pub 
    fn start_cloning(&self) -> Result<CowTransactionGuard<'_, ITEM>, CowGuardError>
    {
        let cloned_read = self.borrow()?;

        let new_inst = unsafe { cloned_read.inst.inst.as_ref()}.item.clone();

        return Ok(
            CowTransactionGuard
            {
                icow: self, 
                new_inst: new_inst,
                cloned_read: cloned_read,
                _p_thread_lock: PhantomData,
            }   
        );
    }

    /// Attempts to perform the copy-on-write by copying [Clone] the inner value `ITEM`.
    /// 
    /// See [CowTransactionGuard] for more info.
    /// 
    /// Either a [Result::Ok] with [CowTransactionGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    pub 
    fn try_start_cloning(&self) -> Result<CowTransactionGuard<'_, ITEM>, CowGuardError>
    {
        let cloned_read = self.try_borrow()?;

        let new_inst = unsafe { cloned_read.inst.inst.as_ref()}.item.clone();

        return Ok(
            CowTransactionGuard
            {
                icow: self, 
                new_inst: new_inst,
                cloned_read: cloned_read,
                _p_thread_lock: PhantomData,
            }   
        );
    }
}

impl<ITEM: Send + fmt::Debug + Default>  InstanceCopyOnWrite<ITEM>
{
    /// Performing the copy-on-write by creating the default [Default] of the inner value `ITEM`.
    /// 
    /// See [CowTransactionGuard] for more info.
    /// 
    /// Either a [Result::Ok] with [CowTransactionGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    pub 
    fn start_default(&self) -> Result<CowTransactionGuard<'_, ITEM>, CowGuardError>
    {   
        let cloned_read = self.borrow()?;

        return Ok(
            CowTransactionGuard
            {
                icow: self, 
                new_inst: ITEM::default(),
                cloned_read: cloned_read,
                _p_thread_lock: PhantomData,
            }
        );
    }

    /// Attempts to perform the copy-on-write by creating the default [Default] 
    /// of the inner value `ITEM`.
    /// 
    /// See [CowTransactionGuard] for more info.
    /// 
    /// Either a [Result::Ok] with [CowTransactionGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    pub 
    fn try_start_default(&self) -> Result<CowTransactionGuard<'_, ITEM>, CowGuardError>
    {
        let cloned_read = self.try_borrow()?;

        return Ok(
            CowTransactionGuard
            {
                icow: self, 
                new_inst: ITEM::default(),
                cloned_read: cloned_read,
                _p_thread_lock: PhantomData,
            }
        );
    }
}

impl<ITEM: Send + fmt::Debug>  InstanceCopyOnWrite<ITEM>
{
    /// Performing the copy-on-write from the provided instance of the inner value `ITEM`.
    /// 
    /// See [CowTransactionGuard] for more info.
    /// 
    /// Either a [Result::Ok] with [CowTransactionGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    pub 
    fn start_new(&self, new_inst: ITEM) -> Result<CowTransactionGuard<'_, ITEM>, CowGuardError>
    {
        let cloned_read = self.borrow()?;
        
        return Ok(
            CowTransactionGuard
            {
                icow: self, 
                new_inst: new_inst,
                cloned_read: cloned_read,
                _p_thread_lock: PhantomData,
            }
        );
    }

    /// Attempting to perform the copy-on-write from the provided instance of the inner 
    /// value `ITEM`.
    /// 
    /// See [CowTransactionGuard] for more info.
    /// 
    /// Either a [Result::Ok] with [CowTransactionGuard] or [Result::Err] with [CowGuardError]
    /// is returned.
    pub 
    fn try_start_new(&self, new_inst: ITEM) -> Result<CowTransactionGuard<'_, ITEM>, CowGuardError>
    {
        let cloned_read = self.try_borrow()?;
        
        return Ok(
            CowTransactionGuard
            {
                icow: self, 
                new_inst: new_inst,
                cloned_read: cloned_read,
                _p_thread_lock: PhantomData,
            }
        );
    }
}

#[cfg(test)]
mod tests
{
    use std::{sync::{atomic::Ordering, mpsc, LazyLock, Mutex}, time::{Duration, Instant}};


    use crate::{CowGuardError, InstanceCopyOnWrite, InstanceCopyOnWriteInner, NoCowGuardErr};

    #[derive(Debug, Copy, Clone)]
    struct TestStruct
    {
        start: u64,
        stop: u64
    }

    impl TestStruct
    {
        fn new(val: u64, val2: u64) -> Self
        {
            return Self{ start: val, stop: val2 };
        }
    }

    #[test]
    fn test_bench()
    {
        let val = 
            InstanceCopyOnWrite::new(TestStruct::new(1, 2));

        for _ in 0..10
        {
            let inst_glob = Instant::now();
            let test_borrow = val.borrow().unwrap();

            let e_g = inst_glob.elapsed();
            println!("{:?}", e_g);
        }

        println!("mux");
        
        let mux = Mutex::new(TestStruct::new(1, 2));

        for _ in 0..10
        {
            let inst_glob = Instant::now();
            let test_borrow = val.lock().unwrap();

            let e_g = inst_glob.elapsed();
            println!("{:?}", e_g);
        }
    }

    #[test]
    fn test_simple_nocow()
    {
        
        let val = 
            InstanceCopyOnWrite::new(TestStruct::new(1, 2));

        let test_borrow = val.borrow().unwrap().start;


        assert_eq!(test_borrow, 1);

        let lock = val.lock();

        assert_eq!(lock.is_ok(), true);

        let mut lock = lock.unwrap();

        let lock_dup = val.lock();

        assert_eq!(lock_dup.is_err(), true);

        lock.start = 2;
        lock.stop = 3;

        drop(lock);

        let borrow = val.borrow().unwrap();

        assert_eq!(borrow.start, 2);
        assert_eq!(borrow.stop, 3);

    }

    #[test]
    fn test_simple_multithread_lock_parking_test()
    {
        static VAL: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 

        let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);

        let inst_glob = Instant::now();

        let thread1 = 
                std::thread::spawn(move ||
                    {
                        let mut lock = VAL.lock().unwrap();

                            

                        lock.start = 5;
                        lock.stop = 6;
                        //let _ = mpsc_send.send(1);

                        std::thread::sleep(Duration::from_millis(944));

                        drop(lock);
                    }
                );

        drop(borrow1);

        std::thread::sleep(Duration::from_micros(1));
        let inst = Instant::now();
        
        let borrow2 = VAL.borrow().unwrap();

        let e_g = inst_glob.elapsed();
        let e_b = inst.elapsed();    

        println!("{:?} {:?}", e_g, e_b);  

        let dur = e_g - e_b;
        println!("{}", dur.as_millis());
        assert_eq!(dur.as_millis(), 0);
    }

    //fix e_g - e_th
    #[test]
    fn test_simple_multithread_lock_parking_test2()
    {
        static VAL: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 

        let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);

        
        let inst_glob = Instant::now();
        let thread1 = 
                std::thread::spawn(move ||
                    {
                        let inst_loc = Instant::now();
                        let mut lock = VAL.lock().unwrap();
                        let e_g = inst_loc.elapsed();
                            

                        lock.start = 5;
                        lock.stop = 6;
                        //let _ = mpsc_send.send(1);

                        

                        drop(lock);

                        return e_g;
                    }
                );

        std::thread::sleep(Duration::from_millis(944));
        drop(borrow1);
        let e_g = inst_glob.elapsed();
        
        let e_th = thread1.join().unwrap();
        println!("{:?} {:?}", e_g, e_th);  

        let dur = e_g - e_th;
        println!("{}", dur.as_millis());
        assert_eq!(dur.as_millis(), 0);
    }

    //todo fix
    #[test]
    fn test_simple_multithread_lock_comp()
    {
        static VAL: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 
        

            let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);

            let (mpsc_send, mpsc_rcv) = mpsc::channel::<u64>();
            let (mpsc_send2, mpsc_rcv2) = mpsc::channel::<u64>();

            let thread1 = 
                std::thread::spawn(move ||
                    {
                        for _ in 0..10000
                        {
                            let mut lock = 
                                loop
                                {
                                    let lock = VAL.lock();

                                    if let Err(NoCowGuardErr::AlreadyLocked) = lock
                                    {
                                        std::thread::sleep(Duration::from_nanos(100));
                                        continue;
                                    }

                                    break lock.unwrap();
                                };

                            

                            lock.start = 5;
                            lock.stop = 6;
                            
                           drop(lock);
                           /*let borrow2 = VAL.borrow().unwrap();
                            assert_eq!(borrow2.start, 5);
                            assert_eq!(borrow2.stop, 6);
                            drop(borrow2);*/

                            let _ = mpsc_send.send(1);

                            let _ = mpsc_rcv2.recv();

                            std::thread::sleep(Duration::from_nanos(1000));
                        }
                    }
                );
            
            drop(borrow1);

            for i in 0..10000
            {
                let val = mpsc_rcv.recv();
               // println!("i: {} {:?}", i, val);

                
                
                let e_b =
                    {
                        let inst = Instant::now();
                    let borrow2 = VAL.borrow().unwrap();

                    let e_b = inst.elapsed();

                    assert_eq!(borrow2.start, 5);
                    assert_eq!(borrow2.stop, 6);

                    drop(borrow2);

                    e_b
                    };
                 let _ = mpsc_send2.send(1);

                let inst = Instant::now();
                let mut lock = VAL.lock().unwrap();
                let e_l = inst.elapsed();

                lock.start = 1;
                lock.stop = 2;

                drop(lock);

                println!("b: {:?} e: {:?}", e_b, e_l);
                assert!(e_b.as_millis() == 0);
                assert!(e_l.as_millis() == 0);
            }
            
            let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);

            thread1.join().unwrap();        

    }


    #[test]
    fn test_simple_copy()
    {
        let val = 
            InstanceCopyOnWrite::new(TestStruct::new(1, 2));

        let s = Instant::now();
        let borrow1 = val.borrow().unwrap();
        let e = s.elapsed();

        let s = Instant::now();
        let borrow2 = val.borrow().unwrap();
        let e2 = s.elapsed();

        println!("{:?} {:?}", e, e2);

        assert_eq!(borrow1.start, 1);
        assert_eq!(borrow1.stop, 2);

        assert_eq!(borrow1.start, borrow2.start);
        assert_eq!(borrow1.stop, borrow2.stop);

        let mut transaction = val.start_copying().unwrap();

        transaction.start = 5;
        transaction.stop = 6;

        assert_eq!(borrow1.start, 1);
        assert_eq!(borrow1.stop, 2);

        transaction.completed(false).unwrap();

        assert_eq!(borrow1.start, 1);
        assert_eq!(borrow1.stop, 2);

        let borrow3 = val.borrow().unwrap();

        assert_eq!(borrow3.start, 5);
        assert_eq!(borrow3.stop, 6);

        drop(borrow1);

        let refs = borrow2.inst.inner().refs.load(std::sync::atomic::Ordering::Relaxed);
        assert_eq!(refs, 1);

        let weak_tag = borrow2.inst.inner().get_weak_tag();

        {
            let arc_upg = weak_tag.upgrade();
            assert_eq!(arc_upg.is_some(), true);
        }

        drop(borrow2);

        {
            let arc_upg = weak_tag.upgrade();
            assert_eq!(arc_upg.is_none(), true);
        }
        
    }

    #[derive(Debug, Default)]
    struct TestStructDef
    {
        start: Option<u64>,
        stop: Option<u64>,
    }

    impl TestStructDef
    {
        fn new(val: u64, val2: u64) -> Self
        {
            return Self{ start: Some(val), stop: Some(val2) };
        }
    }


    #[test]
    fn test_simple_default()
    {
        let val = 
            InstanceCopyOnWrite::new(TestStructDef::new(1, 2));

        let s = Instant::now();
        let borrow1 = val.borrow().unwrap();
        let e = s.elapsed();

        for _ in 0..10
        {
        let s = Instant::now();
        let borrow2 = val.borrow().unwrap();
        let e2 = s.elapsed();
        println!("{:?} {:?}", e, e2);

        }

        let s = Instant::now();
        let borrow2 = val.borrow().unwrap();
        let e2 = s.elapsed();
        println!("{:?} {:?}", e, e2);

        assert_eq!(borrow1.start, Some(1));
        assert_eq!(borrow1.stop, Some(2));

        assert_eq!(borrow1.start, borrow2.start);
        assert_eq!(borrow1.stop, borrow2.stop);

        let mut transaction = val.start_default().unwrap();

        transaction.start = Some(5);
        transaction.stop = Some(6);

        assert_eq!(borrow1.start, Some(1));
        assert_eq!(borrow1.stop, Some(2));

        transaction.completed(false).unwrap();

        assert_eq!(borrow1.start, Some(1));
        assert_eq!(borrow1.stop, Some(2));

        let borrow3 = val.borrow().unwrap();

        assert_eq!(borrow3.start, Some(5));
        assert_eq!(borrow3.stop, Some(6));

        drop(borrow1);

        let refs = borrow2.inst.inner().refs.load(std::sync::atomic::Ordering::Relaxed);
        assert_eq!(refs, 1);

        let weak_tag = borrow2.inst.inner().get_weak_tag();

        {
            let arc_upg = weak_tag.upgrade();
            assert_eq!(arc_upg.is_some(), true);
        }

        drop(borrow2);

        {
            let arc_upg = weak_tag.upgrade();
            assert_eq!(arc_upg.is_none(), true);
        }
        
    }

    #[test]
    fn test_simple_multithread_clone()
    {
        static VAL: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 
        

        let borrow1 = VAL.borrow().unwrap();

        let thread1 = 
            std::thread::spawn(move ||
                {
                    let borrow1 = VAL.borrow().unwrap();

                    let mut transaction = VAL.start_copying().unwrap();

                    transaction.start = 5;
                    transaction.stop = 6;

                    transaction.completed(false).unwrap();

                    let borrow2 = VAL.borrow().unwrap();

                    assert_eq!(borrow1.start, 1);
                    assert_eq!(borrow1.stop, 2);

                    assert_eq!(borrow2.start, 5);
                    assert_eq!(borrow2.stop, 6);
                }
            );
        
        let borrow2 = VAL.borrow().unwrap();
        let borrow3 = VAL.borrow().unwrap();
        
        assert_eq!(borrow1.start, 1);
        assert_eq!(borrow1.stop, 2);

        thread1.join().unwrap();

        drop(borrow2);
        let weak_tag = borrow3.inst.inner().get_weak_tag();
        drop(borrow3);

        {
            let arc_upg = weak_tag.upgrade();
            assert_eq!(arc_upg.is_some(), true);
        }

        
    }

    #[test]
    fn test_simple_multithread_clone_compl()
    {
        static VAL: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 
        

        
        
        for _ in 0..100000
        {
            let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);

            let (mpsc_send, mpsc_rcv) = mpsc::channel::<u64>();

            let thread1 = 
                std::thread::spawn(move ||
                    {
                        let borrow1 = VAL.borrow().unwrap();

                        let mut transaction = VAL.start_copying().unwrap();

                        transaction.start = 5;
                        transaction.stop = 6;

                        let _ = mpsc_send.send(1);

                        std::thread::sleep(Duration::from_micros(1));
                        transaction.completed(false).unwrap();

                        let borrow2 = VAL.borrow().unwrap();

                        assert_eq!(borrow1.start, 1);
                        assert_eq!(borrow1.stop, 2);

                        assert_eq!(borrow2.start, 5);
                        assert_eq!(borrow2.stop, 6);
                    }
                );
            
            let _ = mpsc_rcv.recv();

            for _ in 0..100000000
            {
                let borrow2 = VAL.borrow().unwrap();

                if borrow2.start == 1
                {
                    continue;
                }
                else
                {
                    break;
                }
            }
            
            let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 5);
            assert_eq!(borrow1.stop, 6);

            thread1.join().unwrap();

            let mut transaction = VAL.start_copying().unwrap();
            transaction.start = 1;
            transaction.stop = 2;
            transaction.completed(false).unwrap();
        }

    }

    #[test]
    fn test_simple_multithread_clone_compl_fast()
    {
        static VAL: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 
        

        
        
        for i in 0..100000
        {
            let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);

            let (mpsc_send, mpsc_rcv) = mpsc::channel::<u64>();

            let thread1 = 
                std::thread::spawn(move ||
                    {
                        let borrow1 = VAL.borrow().unwrap();

                        let mut transaction = VAL.start_copying().unwrap();

                        transaction.start = 5;
                        transaction.stop = 6;

                        let _ = mpsc_send.send(1);

                        std::thread::sleep(Duration::from_nanos(100001-i));
                        transaction.completed(false).unwrap();

                        let borrow2 = VAL.borrow().unwrap();

                        assert_eq!(borrow1.start, 1);
                        assert_eq!(borrow1.stop, 2);

                        assert_eq!(borrow2.start, 5);
                        assert_eq!(borrow2.stop, 6);
                    }
                );
            
            let _ = mpsc_rcv.recv();

            for _ in 0..100000000
            {
                let borrow2 = VAL.borrow().unwrap();

                if borrow2.start == 1
                {
                    continue;
                }
                else
                {
                    break;
                }
            }
            
            let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 5);
            assert_eq!(borrow1.stop, 6);

            thread1.join().unwrap();

            let mut transaction = VAL.start_copying().unwrap();
            transaction.start = 1;
            transaction.stop = 2;
            transaction.completed(false).unwrap();
        }

    }

    #[test]
    fn test_simple_multithread_clone_compl2()
    {
        static VAL: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 
        

        
        
            let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);

            let (mpsc_send, mpsc_rcv) = mpsc::channel::<u64>();
            let (mpsc_send2, mpsc_rcv2) = mpsc::channel::<u64>();

            let thread1 = 
                std::thread::spawn(move ||
                    {
                        for _ in 0..1000
                        {
                            let _ = mpsc_rcv2.recv();
                            let borrow1 = VAL.borrow().unwrap();

                            let mut transaction = VAL.start_copying().unwrap();

                            transaction.start = 5;
                            transaction.stop = 6;

                            

                            std::thread::sleep(Duration::from_nanos(1001));
                            transaction.completed(false).unwrap();

                            let borrow2 = VAL.borrow().unwrap();
                            

                            assert_eq!(borrow1.start, 1);
                            assert_eq!(borrow1.stop, 2);

                            assert_eq!(borrow2.start, 5);
                            assert_eq!(borrow2.stop, 6);

                            let _ = mpsc_send.send(1);
                        }
                    }
                );
            
            

            for x in 0..1000
            {
                println!("{}", x);
                mpsc_send2.send(1).unwrap();
                let _ = mpsc_rcv.recv();

                let borrow1 = VAL.borrow().unwrap();
                assert_eq!(borrow1.start, 5);
                assert_eq!(borrow1.stop, 6);

                let mut transaction = VAL.start_copying().unwrap();
                transaction.start = 1;
                transaction.stop = 2;
                transaction.completed(false).unwrap();

                let borrow1 = VAL.borrow().unwrap();
                assert_eq!(borrow1.start, 1);
                assert_eq!(borrow1.stop, 2);
                
            }
            
            

            thread1.join().unwrap();

            
        }


    #[test]
    fn test_thread_local()
    {
        static VAL: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 

        static VAL2: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 

        static VAL3: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 

        let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);

        let borrow_ptr_0 = borrow1.inst.inst.as_ptr().addr();

        let thread1 = 
                std::thread::spawn(move ||
                    {
                        let b = InstanceCopyOnWriteInner::<TestStruct>::BORROWS.with_borrow(|v| v.get(&borrow_ptr_0).map(|v| *v).clone());

                        return b;
                    }
                );
        
        let thread_borrow = thread1.join().unwrap();
        
        let local_borrow = InstanceCopyOnWriteInner::<TestStruct>::BORROWS.with_borrow(|v| *(v.get(&borrow_ptr_0).unwrap()));

        println!("tthread: {:?}, local: {}", thread_borrow, local_borrow);

        assert_eq!(thread_borrow.is_none(), true);
        assert_eq!(local_borrow, 1);

        drop(borrow1);

        let local_borrow = InstanceCopyOnWriteInner::<TestStruct>::BORROWS.with_borrow(|v| *(v.get(&borrow_ptr_0).unwrap()));

        println!("tthread: {:?}, local: {}", thread_borrow, local_borrow);
        assert_eq!(local_borrow, 0);


        // check deadlocks
        let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);

        let res = VAL.lock();
        assert_eq!(Some(NoCowGuardErr::Borrowed), res.err());

        drop(borrow1);

        // check double lock
        let res1 = VAL2.lock();
        assert_eq!(true, res1.is_ok(), "{:?}", res1);

        let borrow_ptr_1 = res1.as_ref().unwrap().inst.inst.as_ptr().addr();

        let res2 = VAL2.lock();
        assert_eq!(Some(NoCowGuardErr::AlreadyLocked), res2.err());

        // -----
        let thread1 = 
            std::thread::spawn(move ||
                {
                    let borrow1 = VAL2.try_borrow();
                    assert_eq!(borrow1.err(), Some(CowGuardError::WouldBlock));

                    let borrow1 = VAL.borrow().unwrap();
                    assert_eq!(borrow1.start, 1);
                    assert_eq!(borrow1.stop, 2);

                    let b = InstanceCopyOnWriteInner::<TestStruct>::BORROWS.with_borrow(|v| v.get(&borrow_ptr_0).map(|v| *v).clone());

                    let mut clone = VAL3.start_cloning().unwrap();

                    let borrow_ptr_2 = VAL3.owner_inner.load(Ordering::Relaxed).addr();

                    clone.start = 3;

                    clone.completed(false).unwrap();

                    let b2 = InstanceCopyOnWriteInner::<TestStruct>::BORROWS.with_borrow(|v| v.get(&borrow_ptr_1).map(|v| *v).clone());

                    let b3 = InstanceCopyOnWriteInner::<TestStruct>::BORROWS.with_borrow(|v| v.get(&borrow_ptr_2).map(|v| *v).clone());

                    return (b, b2, b3);
                }
            );

            
        let borrow_ptr_2 = VAL3.owner_inner.load(Ordering::Relaxed).addr();

        let local_borrow1 = InstanceCopyOnWriteInner::<TestStruct>::BORROWS.with_borrow(|v| (v.get(&borrow_ptr_0).map(|v| *v).clone()));
        let local_borrow2 = InstanceCopyOnWriteInner::<TestStruct>::BORROWS.with_borrow(|v| (v.get(&borrow_ptr_1).map(|v| *v).clone()));
        let local_borrow3 = InstanceCopyOnWriteInner::<TestStruct>::BORROWS.with_borrow(|v| (v.get(&borrow_ptr_2).map(|v| *v).clone()));

        let (thread_borrow1, thread_borrow2, thread_borrow3) = thread1.join().unwrap();
        drop(res1.unwrap());

        assert_eq!(Some(0), local_borrow1);
        assert_eq!(Some(1), thread_borrow1);

        assert_eq!(None, thread_borrow2);
        assert_eq!(None, local_borrow2);

        assert_eq!(None, thread_borrow3);
        assert_eq!(None, local_borrow3);
    }
    

    //todo poison test

    #[test]
    #[should_panic(expected = "test panic1")]
    fn test_thread_poison()
    {
        static VAL: LazyLock<InstanceCopyOnWrite<TestStruct>> = 
            LazyLock::new(|| InstanceCopyOnWrite::new(TestStruct::new(1, 2))); 

           
        let borrow1 = VAL.borrow().unwrap();
            assert_eq!(borrow1.start, 1);
            assert_eq!(borrow1.stop, 2);


        let thread1 = 
                std::thread::spawn(move ||
                    {
                        let mut lock = VAL.lock().unwrap();
                        lock.start = 2;
                        std::thread::sleep(Duration::from_micros(1));

                        panic!("test panic1");
                    }
                );

        drop(borrow1);

        let thread_res = thread1.join();

        let borrow = VAL.borrow();
        assert_eq!(Some(CowGuardError::Poisoned), borrow.err());

        let lock = VAL.lock();
        assert_eq!(Some(NoCowGuardErr::Poisoned), lock.err());

        let transaction = VAL.start_copying();
        assert_eq!(Some(CowGuardError::Poisoned), transaction.err());

        println!("{:?}", thread_res);

        panic!("test panic1");
    } 

    #[test]
    fn test_main_drop()
    {
         let val = 
            InstanceCopyOnWrite::new(TestStruct::new(1, 2));

        {
        let test_borrow = val.borrow().unwrap().start;

        assert_eq!(test_borrow, 1);
        }

        {
        let lock = val.lock();

        assert_eq!(lock.is_ok(), true);

        let mut lock = lock.unwrap();

        let lock_dup = val.lock();

        assert_eq!(lock_dup.is_err(), true);

        lock.start = 2;
        lock.stop = 3;

        drop(lock);
        }

        {
        let borrow = val.borrow().unwrap();

        drop(borrow);
        }

        drop(val);

        return;
    }
}