cogciprocate/qutex

Synchronization mechanisms based on lock-free queues and Rust futures

qutex's Issues

TODOs

• Consider adding a fast path for reads and writes which would not require creating a oneshot channel when queue is empty.
• Wrap Canceled error in custom error type?

disable debug, implement Default?

qutex/src/qrw_lock.rs

Line 34 in dac4838

const PRINT_DEBUG: bool = true;

impl<T: Default> Default for Qutex<T> {
  fn default() -> Self {
    Self::new(T::default())
  }
}
// and QrwLock

Detecting deadlock with single qutex/qrwlock

Here's example code which causes deadlock without unsafe code.

extern crate futures;
extern crate qutex;

use qutex::*;
use futures::prelude::*;

fn main() {
    let lock = QrwLock::from(0i32);

    let f = lock.clone().write().and_then(move |mut guard_w| {
        eprintln!("write lock acquired");
        lock.read().and_then(move |guard_r| {
            eprintln!("read lock acquired");

            let r0 = *guard_r;
            *guard_w += 1;
            let r1 = *guard_r;
            assert_eq!(r0, r1);
            Ok(())
        })
    });

    assert_eq!(Ok(()), f.wait());
}

Is there any way to detect the deadlock? It would be nice for FutureGuard to return Deadlocked error (just like Canceled error) if there's any prior FutureGuard which belongs to current task. In that case, above example will return Error(Deadlocked) on f.wait() instead of hanging on deadlock.

`Guard::unlock` leaves `Qutex` locked

The implementation of Guard::unlock actually leaves the lock still locked by canceling the Drop implementation for Guard. I believe a call to qutex.direct_unlock() is needed after the mem::forget for the function to work as intended.