Crate pflock

source ·
Expand description

This library provides a phase-fair reader-writer lock, as described in the paper “Reader-Writer Synchronization for Shared-Memory Multiprocessor Real-Time Systems” by Brandenburg et. al.

Reader preference, writer preference, and task-fair reader-writer locks are shown to cause undue blocking in multiprocessor real-time systems. A new phase-fair reader-writer lock is proposed as an alternative that significantly reduces worst-case blocking for readers.


use pflock::PFLock;

let lock = PFLock::new(5);

// many reader locks can be held at once
    let r1 =;
    let r2 =;
    assert_eq!(*r1, 5);
    assert_eq!(*r2, 5);
} // read locks are dropped at this point

// only one write lock may be held, however
    let mut w = lock.write();
    *w += 1;
    assert_eq!(*w, 6);
} // write lock is dropped here

Spin vs. suspend

PFLock is a spinlock specifically targeted at short critical sections and does not suspend threads while blocking. Section 3 of the paper addresses this:

The terms “short” and “long” arise because (intuitively) spinning is appropriate only for short critical sections, since spinning wastes processor time. However, two recent studies have shown that, in terms of schedulability, spinning is usually preferable to suspending when overheads are considered [11, 15]. Based on these trends (and due to space constraints), we restrict our focus to short resources in this paper and delegate RW synchronization of long resources to future work.


Type Definitions

A phase-fair reader-writer lock.