Struct UnsafeLock 

pub struct UnsafeLock<T: ?Sized> { /* private fields */ }

Implementations

impl<T> UnsafeLock<T>

pub unsafe fn new(value: T) -> Self

Safety

There must be no copies of the value. See Send implementation.

Examples found in repository

tests-san/tsan.rs (line 19)

fn test_unsafelock() {
    let Ok(num_cpus) = thread::available_parallelism() else {
        return;
    };
    let mut num_threads = num_cpus.get();

    let val = Rc::new(Cell::new(0_usize));

    // UnsafeLock requires that there's no copies of the value.
    // We're cloning the value here, but we're not going to use the original value so it's fine.
    let lock = unsafe { UnsafeLock::new(val.clone()) };

    // Threads will increase the value. The value will become N * num_threads.
    const N: usize = 10_000;
    let mut handles = Vec::new();
    for _ in 0..num_threads {
        let c_lock = lock.clone();
        let handle = thread::spawn(move || {
            for _ in 0..N {
                unsafe {
                    let val = c_lock.lock().as_mut();
                    val.set(val.get() + 1);
                    c_lock.unlock();
                }
            }
        });
        handles.push(handle);
    }

    // UnsafeLock's guarantee is upheld when all data is under its protection. But, this block of
    // code violate the safety. You can check this through thread sanitizer.
    //
    // num_threads += 1;
    // for _ in 0..N {
    //     val.set(val.get() + 1); // val is outside the UnsafeLock
    // }

    for handle in handles {
        handle.join().unwrap();
    }

    unsafe {
        let val = lock.lock().as_ref();
        assert_eq!(val.get(), N * num_threads);
        lock.unlock();
    }
}

impl<T: ?Sized> UnsafeLock<T>

pub unsafe fn lock(&self) -> NonNull<T>

Safety

• Do not dereference to the returned pointer after unlock.
• Do not make copies of T from the returned pointer. See Send implementation.

Examples found in repository

tests-san/tsan.rs (line 29)

fn test_unsafelock() {
    let Ok(num_cpus) = thread::available_parallelism() else {
        return;
    };
    let mut num_threads = num_cpus.get();

    let val = Rc::new(Cell::new(0_usize));

    // UnsafeLock requires that there's no copies of the value.
    // We're cloning the value here, but we're not going to use the original value so it's fine.
    let lock = unsafe { UnsafeLock::new(val.clone()) };

    // Threads will increase the value. The value will become N * num_threads.
    const N: usize = 10_000;
    let mut handles = Vec::new();
    for _ in 0..num_threads {
        let c_lock = lock.clone();
        let handle = thread::spawn(move || {
            for _ in 0..N {
                unsafe {
                    let val = c_lock.lock().as_mut();
                    val.set(val.get() + 1);
                    c_lock.unlock();
                }
            }
        });
        handles.push(handle);
    }

    // UnsafeLock's guarantee is upheld when all data is under its protection. But, this block of
    // code violate the safety. You can check this through thread sanitizer.
    //
    // num_threads += 1;
    // for _ in 0..N {
    //     val.set(val.get() + 1); // val is outside the UnsafeLock
    // }

    for handle in handles {
        handle.join().unwrap();
    }

    unsafe {
        let val = lock.lock().as_ref();
        assert_eq!(val.get(), N * num_threads);
        lock.unlock();
    }
}

pub unsafe fn unlock(&self)

Safety

Must follow lock.

Examples found in repository

tests-san/tsan.rs (line 31)

fn test_unsafelock() {
    let Ok(num_cpus) = thread::available_parallelism() else {
        return;
    };
    let mut num_threads = num_cpus.get();

    let val = Rc::new(Cell::new(0_usize));

    // UnsafeLock requires that there's no copies of the value.
    // We're cloning the value here, but we're not going to use the original value so it's fine.
    let lock = unsafe { UnsafeLock::new(val.clone()) };

    // Threads will increase the value. The value will become N * num_threads.
    const N: usize = 10_000;
    let mut handles = Vec::new();
    for _ in 0..num_threads {
        let c_lock = lock.clone();
        let handle = thread::spawn(move || {
            for _ in 0..N {
                unsafe {
                    let val = c_lock.lock().as_mut();
                    val.set(val.get() + 1);
                    c_lock.unlock();
                }
            }
        });
        handles.push(handle);
    }

    // UnsafeLock's guarantee is upheld when all data is under its protection. But, this block of
    // code violate the safety. You can check this through thread sanitizer.
    //
    // num_threads += 1;
    // for _ in 0..N {
    //     val.set(val.get() + 1); // val is outside the UnsafeLock
    // }

    for handle in handles {
        handle.join().unwrap();
    }

    unsafe {
        let val = lock.lock().as_ref();
        assert_eq!(val.get(), N * num_threads);
        lock.unlock();
    }
}

Trait Implementations

impl<T: Clone + ?Sized> Clone for UnsafeLock<T>

fn clone(&self) -> UnsafeLock<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for UnsafeLock<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: ?Sized> Send for UnsafeLock<T>

Unlike Mutex, this lock is Send and Sync regardless of whether T is Send or not. That’s because T is always under the protection of this lock whenever clients uphold the safety of the lock.

Safety

There must be no copies of the value inside this lock. Clients must not have copies before and after creation of this lock. Because this lock assumes that the value inside the lock has no copies, so the lock is Send and Sync even if T isn’t.
For example, imagine that you have multiple Rc<T>, which is not Send, and make UnsafeLock<Rc<T>> from one copy of them, then you send the lock to another thread. It can cause data race because of Rc<T> outside this lock.
But if you have only one T and wrap it within UnsafeLock, then T is guaranteed to be protected by this lock. Making copies of UnsafeLock<T>, sending it to another thread, and accessing it from another thread does not break the guarantee. But you still can make copies of T from its pointer, but you shouldn’t.

impl<T: ?Sized> Sync for UnsafeLock<T>