use std::cell::Cell;
use crate::handle_unwind::handle_unwind;
use crate::lockable::{Lockable, RawLock, Sharable};
use crate::Keyable;
/// Returns a list of locks in the given collection and sorts them by their
/// memory address
#[must_use]
pub fn get_locks<L: Lockable>(data: &L) -> Vec<&dyn RawLock> {
let mut locks = get_locks_unsorted(data);
locks.sort_by_key(|lock| &raw const **lock);
locks
}
/// Returns a list of locks from the data. Unlike the above function, this does
/// not do any sorting of the locks.
#[must_use]
pub fn get_locks_unsorted<L: Lockable>(data: &L) -> Vec<&dyn RawLock> {
let mut locks = Vec::new();
data.get_ptrs(&mut locks);
locks
}
/// returns `true` if the sorted list contains a duplicate
#[must_use]
pub fn ordered_contains_duplicates(l: &[&dyn RawLock]) -> bool {
if l.is_empty() {
// Return early to prevent panic in the below call to `windows`
return false;
}
l.windows(2)
// NOTE: addr_eq is necessary because eq would also compare the v-table pointers
.any(|window| std::ptr::addr_eq(window[0], window[1]))
}
/// Lock a set of locks in the given order. It's UB to call this without a `ThreadKey`
pub unsafe fn ordered_write(locks: &[&dyn RawLock]) {
// these will be unlocked in case of a panic
let locked = Cell::new(0);
handle_unwind(
|| {
for lock in locks {
lock.raw_write();
locked.set(locked.get() + 1);
}
},
|| attempt_to_recover_writes_from_panic(&locks[0..locked.get()]),
)
}
/// Lock a set of locks in the given order. It's UB to call this without a `ThreadKey`
pub unsafe fn ordered_read(locks: &[&dyn RawLock]) {
let locked = Cell::new(0);
handle_unwind(
|| {
for lock in locks {
lock.raw_read();
locked.set(locked.get() + 1);
}
},
|| attempt_to_recover_reads_from_panic(&locks[0..locked.get()]),
)
}
/// Locks the locks in the order they are given. This causes deadlock if the
/// locks contain duplicates, or if this is called by multiple threads with the
/// locks in different orders.
pub unsafe fn ordered_try_write(locks: &[&dyn RawLock]) -> bool {
let locked = Cell::new(0);
handle_unwind(
|| unsafe {
for (i, lock) in locks.iter().enumerate() {
// safety: we have the thread key
if lock.raw_try_write() {
locked.set(locked.get() + 1);
} else {
for lock in &locks[0..i] {
// safety: this lock was already acquired
lock.raw_unlock_write();
}
return false;
}
}
true
},
||
// safety: everything in locked is locked
attempt_to_recover_writes_from_panic(&locks[0..locked.get()]),
)
}
/// Locks the locks in the order they are given. This causes deadlock if this
/// is called by multiple threads with the locks in different orders.
pub unsafe fn ordered_try_read(locks: &[&dyn RawLock]) -> bool {
// these will be unlocked in case of a panic
let locked = Cell::new(0);
handle_unwind(
|| unsafe {
for (i, lock) in locks.iter().enumerate() {
// safety: we have the thread key
if lock.raw_try_read() {
locked.set(locked.get() + 1);
} else {
for lock in &locks[0..i] {
// safety: this lock was already acquired
lock.raw_unlock_read();
}
return false;
}
}
true
},
||
// safety: everything in locked is locked
attempt_to_recover_reads_from_panic(&locks[0..locked.get()]),
)
}
pub fn scoped_write<'a, L: RawLock + Lockable + ?Sized, R>(
collection: &'a L,
key: impl Keyable,
f: impl FnOnce(L::DataMut<'a>) -> R,
) -> R {
unsafe {
// safety: we have the key
collection.raw_write();
// safety: we just locked this
let r = handle_unwind(
|| f(collection.data_mut()),
|| collection.raw_unlock_write(),
);
// this ensures the key is held long enough
drop(key);
// safety: we've locked already, and aren't using the data again
collection.raw_unlock_write();
r
}
}
pub fn scoped_try_write<'a, L: RawLock + Lockable + ?Sized, Key: Keyable, R>(
collection: &'a L,
key: Key,
f: impl FnOnce(L::DataMut<'a>) -> R,
) -> Result<R, Key> {
unsafe {
// safety: we have the key
if !collection.raw_try_write() {
return Err(key);
}
// safety: we just locked this
let r = handle_unwind(
|| f(collection.data_mut()),
|| collection.raw_unlock_write(),
);
// this ensures the key is held long enough
drop(key);
// safety: we've locked already, and aren't using the data again
collection.raw_unlock_write();
Ok(r)
}
}
pub fn scoped_read<'a, L: RawLock + Sharable + ?Sized, R>(
collection: &'a L,
key: impl Keyable,
f: impl FnOnce(L::DataRef<'a>) -> R,
) -> R {
unsafe {
// safety: we have the key
collection.raw_read();
// safety: we just locked this
let r = handle_unwind(|| f(collection.data_ref()), || collection.raw_unlock_read());
// this ensures the key is held long enough
drop(key);
// safety: we've locked already, and aren't using the data again
collection.raw_unlock_read();
r
}
}
pub fn scoped_try_read<'a, L: RawLock + Sharable + ?Sized, Key: Keyable, R>(
collection: &'a L,
key: Key,
f: impl FnOnce(L::DataRef<'a>) -> R,
) -> Result<R, Key> {
unsafe {
// safety: we have the key
if !collection.raw_try_read() {
return Err(key);
}
// safety: we just locked this
let r = handle_unwind(|| f(collection.data_ref()), || collection.raw_unlock_read());
// this ensures the key is held long enough
drop(key);
// safety: we've locked already, and aren't using the data again
collection.raw_unlock_read();
Ok(r)
}
}
/// Unlocks the already locked locks in order to recover from a panic
pub unsafe fn attempt_to_recover_writes_from_panic(locks: &[&dyn RawLock]) {
handle_unwind(
|| {
// safety: the caller assumes that these are already locked
for lock in locks {
lock.raw_unlock_write();
}
},
// if we get another panic in here, we'll just have to poison what remains
|| locks.iter().for_each(|l| l.poison()),
)
}
/// Unlocks the already locked locks in order to recover from a panic
pub unsafe fn attempt_to_recover_reads_from_panic(locked: &[&dyn RawLock]) {
handle_unwind(
|| {
// safety: the caller assumes these are already locked
for lock in locked {
lock.raw_unlock_read();
}
},
// if we get another panic in here, we'll just have to poison what remains
|| locked.iter().for_each(|l| l.poison()),
)
}
#[cfg(test)]
mod tests {
use crate::collection::utils::ordered_contains_duplicates;
#[test]
fn empty_array_does_not_contain_duplicates() {
assert!(!ordered_contains_duplicates(&[]))
}
}
|
