I wrote:
> I did a survey of the various behaviours of rwlock implementations [1].
> Find the results there [2].
> [1]
> https://gitweb.git.savannah.gnu.org/gitweb/?p=gnulib/maint-tools.git;a=tree;f=test-programs/pthread-rwlock;h=bc63cb8ee32bf508f0b7daab6f367fd507786a2b;hb=HEAD
> [2]
> https://gitweb.git.savannah.gnu.org/gitweb/?p=gnulib/maint-tools.git;a=blob_plain;f=test-programs/pthread-rwlock/results.txt;hb=HEAD
In fact, these results were incomplete, because I did some of them on VMs
with just 1 CPU. The result with more CPUs are different: Find attached
* out.1_cpu, out.2_cpus, out.4_cpus, out.8_cpus
the results with limitation to 1, 2, 4, or 8 CPUs (done with the
"taskset -c" command in an Alpine Linux 3.20 VM with 8 CPUs),
* out.fifo, out.rr, out.other, out.idle
the results with different Linux scheduling policies (done with the
"chrt" command in an Alpine Linux 3.20 VM with 8 CPUs).
The summary is, in all 4 cases:
When releasing the last reader lock:
If at least one of the enqueued lock attempts is for reading, the
first one of them is granted.
Otherwise, the first of the waiting write attempts is granted.
When releasing a writer lock:
???
This implementation does not globally prefer readers, only when releasing
a reader lock.
This implementation does not prefer writers.
The influence of the Linux scheduling policy that Natanael detected [1]
probably comes from the fact that musl does not actually distinguish readers
from writers to be awoken and instead leaves that distinction to the kernel.
(See musl/src/thread/pthread_rwlock_unlock.c.)
Whereas the non-influence of the Linux scheduling policy on glibc systems
that I see [2] can be explained by the detailed case-by-case logic found in
glibc/nptl/pthread_rwlock_unlock.c
glibc/nptl/pthread_rwlock_common.c
Bruno
[1] https://lists.gnu.org/archive/html/bug-gnulib/2025-05/msg00164.html
[2] https://lists.gnu.org/archive/html/bug-gnulib/2025-05/msg00167.html
Default
When releasing the last reader lock:
If at least one of the enqueued lock attempts is for reading, the
first one of them is granted.
Otherwise, the first of the waiting write attempts is granted.
When releasing a writer lock:
The first of the enqueued lock attempts is granted.
This implementation does not globally prefer readers, only when releasing
a reader lock.
This implementation does not prefer writers.
This implementation is deterministic.
Default
WRR => W1 R2 R3
WRW => W1 W3 R2
WWR => W1 R3 W2
WWW => W1 W2 W3
WRRR => W1 R2 R3 R4
WRRW => W1 R2 R3 W4
WRWR => W1 W3 R4 R2
WRWW => W1 R2 W3 W4
WWRR => W1 W2 R3 R4
WWRW => W1 W2 R3 W4
WWWR => W1 W2 W3 R4
WWWW => W1 W2 W4 W3
WRRRR => W1 R2 R3 R4 R5
WRRRW => W1 R2 R3 R4 W5
WRRWR => W1 R2 R3 W4 R5
WRRWW => W1 R2 R3 W4 W5
WRWRR => W1 W3 R4 R2 R5
WRWRW => W1 R2 W3 R4 W5
WRWWR => W1 R2 W3 W4 R5
WRWWW => W1 R2 W3 W4 W5
WWRRR => W1 W2 R4 R5 R3
WWRRW => W1 W2 R3 R4 W5
WWRWR => W1 R3 W2 W4 R5
WWRWW => W1 W2 R3 W4 W5
WWWRR => W1 W2 R4 R5 W3
WWWRW => W1 W2 W3 R4 W5
WWWWR => W1 W2 W4 R5 W3
WWWWW => W1 W2 W3 W4 W5
WRR => W1 R2 R3
WRW => W1 W3 R2
WWR => W1 R3 W2
WWW => W1 W3 W2
WRRR => W1 R2 R3 R4
WRRW => W1 R3 R2 W4
WRWR => W1 R2 W3 R4
WRWW => W1 W3 R2 W4
WWRR => W1 W2 R3 R4
WWRW => W1 R3 W2 W4
WWWR => W1 W3 R4 W2
WWWW => W1 W2 W3 W4
WRRRR => W1 R2 R3 R4 R5
WRRRW => W1 R2 R3 R4 W5
WRRWR => W1 R3 R2 W4 R5
WRRWW => W1 R3 R2 W4 W5
WRWRR => W1 R2 W3 R4 R5
WRWRW => W1 W3 R2 R4 W5
WRWWR => W1 R2 W3 W4 R5
WRWWW => W1 W3 W4 W5 R2
WWRRR => W1 W2 R3 R4 R5
WWRRW => W1 W2 R3 R4 W5
WWRWR => W1 W2 R3 W4 R5
WWRWW => W1 R3 W2 W4 W5
WWWRR => W1 W3 W2 R4 R5
WWWRW => W1 W2 W3 R4 W5
WWWWR => W1 W2 W4 R5 W3
WWWWW => W1 W3 W4 W5 W2
WRR => W1 R3 R2
WRW => W1 R2 W3
WWR => W1 R3 W2
WWW => W1 W2 W3
WRRR => W1 R3 R2 R4
WRRW => W1 R2 R3 W4
WRWR => W1 W3 R2 R4
WRWW => W1 R2 W4 W3
WWRR => W1 W2 R3 R4
WWRW => W1 W2 R3 W4
WWWR => W1 W2 W3 R4
WWWW => W1 W3 W2 W4
WRRRR => W1 R2 R3 R4 R5
WRRRW => W1 R2 R3 R4 W5
WRRWR => W1 R2 R3 W4 R5
WRRWW => W1 R2 R3 W4 W5
WRWRR => W1 R2 R4 R5 W3
WRWRW => W1 R2 W3 R4 W5
WRWWR => W1 R2 W3 W4 R5
WRWWW => W1 W3 R2 W4 W5
WWRRR => W1 R3 W2 R4 R5
WWRRW => W1 R3 R4 W5 W2
WWRWR => W1 W2 W4 R5 R3
WWRWW => W1 R3 W2 W4 W5
WWWRR => W1 W2 W3 R5 R4
WWWRW => W1 W2 R4 W5 W3
WWWWR => W1 W2 W4 R5 W3
WWWWW => W1 W2 W4 W5 W3
When releasing the last reader lock:
If at least one of the enqueued lock attempts is for reading, the
first one of them is granted.
Otherwise, the first of the waiting write attempts is granted.
When releasing a writer lock:
???
This implementation does not globally prefer readers, only when releasing
a reader lock.
This implementation does not prefer writers.
Default
WRR => W1 R2 R3
WRW => W1 W3 R2
WWR => W1 R3 W2
WWW => W1 W2 W3
WRRR => W1 R2 R4 R3
WRRW => W1 R2 R3 W4
WRWR => W1 R2 W3 R4
WRWW => W1 R2 W3 W4
WWRR => W1 R3 W2 R4
WWRW => W1 W2 R3 W4
WWWR => W1 W3 W2 R4
WWWW => W1 W2 W3 W4
WRRRR => W1 R4 R3 R5 R2
WRRRW => W1 R3 R4 R2 W5
WRRWR => W1 R3 R2 R5 W4
WRRWW => W1 R2 R3 W5 W4
WRWRR => W1 R2 W3 R4 R5
WRWRW => W1 R2 W3 R4 W5
WRWWR => W1 R2 W3 R5 W4
WRWWW => W1 R2 W3 W5 W4
WWRRR => W1 W2 R3 R5 R4
WWRRW => W1 W2 R4 R3 W5
WWRWR => W1 W2 R3 W4 R5
WWRWW => W1 W2 R3 W4 W5
WWWRR => W1 W2 W3 R4 R5
WWWRW => W1 W2 W3 W5 R4
WWWWR => W1 W3 W2 W4 R5
WWWWW => W1 W2 W3 W4 W5
WRR => W1 R3 R2
WRW => W1 R2 W3
WWR => W1 W2 R3
WWW => W1 W3 W2
WRRR => W1 R2 R3 R4
WRRW => W1 R2 R3 W4
WRWR => W1 R2 W3 R4
WRWW => W1 W3 R2 W4
WWRR => W1 R3 W2 R4
WWRW => W1 W2 R3 W4
WWWR => W1 R4 W3 W2
WWWW => W1 W3 W2 W4
WRRRR => W1 R2 R3 R4 R5
WRRRW => W1 R4 R2 R3 W5
WRRWR => W1 R2 R3 W4 R5
WRRWW => W1 R2 R3 W4 W5
WRWRR => W1 R2 R4 R5 W3
WRWRW => W1 R2 W3 R4 W5
WRWWR => W1 R2 W4 R5 W3
WRWWW => W1 R2 W3 W5 W4
WWRRR => W1 W2 R4 R3 R5
WWRRW => W1 R3 W2 W5 R4
WWRWR => W1 W2 R3 W4 R5
WWRWW => W1 W2 R3 W5 W4
WWWRR => W1 W2 R5 W3 R4
WWWRW => W1 W2 W3 R4 W5
WWWWR => W1 W2 W3 W4 R5
WWWWW => W1 W2 W3 W4 W5
WRR => W1 R2 R3
WRW => W1 W3 R2
WWR => W1 R3 W2
WWW => W1 W2 W3
WRRR => W1 R2 R4 R3
WRRW => W1 R2 R3 W4
WRWR => W1 W3 R4 R2
WRWW => W1 R2 W3 W4
WWRR => W1 W2 R3 R4
WWRW => W1 W2 R3 W4
WWWR => W1 W2 W3 R4
WWWW => W1 W3 W2 W4
WRRRR => W1 R2 R3 R4 R5
WRRRW => W1 R3 R2 R4 W5
WRRWR => W1 R2 R3 W4 R5
WRRWW => W1 R2 R3 W4 W5
WRWRR => W1 R2 W3 R4 R5
WRWRW => W1 R4 R2 W3 W5
WRWWR => W1 R2 W3 W4 R5
WRWWW => W1 W3 R2 W5 W4
WWRRR => W1 W2 R3 R4 R5
WWRRW => W1 W2 W5 R4 R3
WWRWR => W1 W2 R3 W4 R5
WWRWW => W1 R3 W4 W5 W2
WWWRR => W1 W3 R4 R5 W2
WWWRW => W1 W2 R4 W5 W3
WWWWR => W1 W2 W3 W4 R5
WWWWW => W1 W2 W4 W3 W5
When releasing the last reader lock:
If at least one of the enqueued lock attempts is for reading, the
first one of them is granted.
Otherwise, the first of the waiting write attempts is granted.
When releasing a writer lock:
???
This implementation does not globally prefer readers, only when releasing
a reader lock.
This implementation does not prefer writers.
Default
WRR => W1 R2 R3
WRW => W1 R2 W3
WWR => W1 R3 W2
WWW => W1 W2 W3
WRRR => W1 R3 R2 R4
WRRW => W1 R2 R3 W4
WRWR => W1 W3 R2 R4
WRWW => W1 W3 R2 W4
WWRR => W1 R3 W2 R4
WWRW => W1 W2 R3 W4
WWWR => W1 W2 W3 R4
WWWW => W1 W3 W2 W4
WRRRR => W1 R2 R3 R5 R4
WRRRW => W1 R3 R2 R4 W5
WRRWR => W1 R3 R2 R5 W4
WRRWW => W1 R3 R2 W4 W5
WRWRR => W1 W3 R2 R4 R5
WRWRW => W1 W3 R4 R2 W5
WRWWR => W1 R2 W3 W4 R5
WRWWW => W1 R2 W3 W4 W5
WWRRR => W1 W2 R4 R5 R3
WWRRW => W1 W2 R4 W5 R3
WWRWR => W1 R3 W4 R5 W2
WWRWW => W1 W2 R3 W4 W5
WWWRR => W1 W2 R4 W3 R5
WWWRW => W1 W2 W3 W5 R4
WWWWR => W1 W4 W2 R5 W3
WWWWW => W1 W3 W2 W4 W5
WRR => W1 R2 R3
WRW => W1 R2 W3
WWR => W1 W2 R3
WWW => W1 W3 W2
WRRR => W1 R3 R4 R2
WRRW => W1 R2 R3 W4
WRWR => W1 R4 R2 W3
WRWW => W1 R2 W3 W4
WWRR => W1 R3 R4 W2
WWRW => W1 W2 W4 R3
WWWR => W1 W2 W3 R4
WWWW => W1 W2 W3 W4
WRRRR => W1 R3 R5 R2 R4
WRRRW => W1 R3 W5 R2 R4
WRRWR => W1 R2 R3 W4 R5
WRRWW => W1 R3 R2 W5 W4
WRWRR => W1 R2 W3 R4 R5
WRWRW => W1 R2 W3 R4 W5
WRWWR => W1 R2 W3 R5 W4
WRWWW => W1 R2 W5 W4 W3
WWRRR => W1 W2 R3 R4 R5
WWRRW => W1 R3 W2 W5 R4
WWRWR => W1 W2 W4 R5 R3
WWRWW => W1 R3 W2 W5 W4
WWWRR => W1 W2 W3 R4 R5
WWWRW => W1 W3 W2 W5 R4
WWWWR => W1 W2 W3 W4 R5
WWWWW => W1 W2 W3 W4 W5
When releasing the last reader lock:
If at least one of the enqueued lock attempts is for reading, the
first one of them is granted.
Otherwise, the first of the waiting write attempts is granted.
When releasing a writer lock:
???
This implementation does not globally prefer readers, only when releasing
a reader lock.
This implementation does not prefer writers.
Default
WRR => W1 R2 R3
WRW => W1 R2 W3
WWR => W1 R3 W2
WWW => W1 W3 W2
WRRR => W1 R2 R3 R4
WRRW => W1 R3 R2 W4
WRWR => W1 W3 R4 R2
WRWW => W1 R2 W3 W4
WWRR => W1 W2 R3 R4
WWRW => W1 W2 R3 W4
WWWR => W1 W2 R4 W3
WWWW => W1 W3 W4 W2
WRRRR => W1 R3 R2 R4 R5
WRRRW => W1 R2 R3 W5 R4
WRRWR => W1 R2 R3 W4 R5
WRRWW => W1 R2 R3 W4 W5
WRWRR => W1 R2 R4 W3 R5
WRWRW => W1 W3 R2 R4 W5
WRWWR => W1 R2 W3 W4 R5
WRWWW => W1 W3 R2 W4 W5
WWRRR => W1 W2 R5 R3 R4
WWRRW => W1 W2 R3 R4 W5
WWRWR => W1 W2 R3 W4 R5
WWRWW => W1 W2 W4 R3 W5
WWWRR => W1 W2 W3 R4 R5
WWWRW => W1 W3 W2 R4 W5
WWWWR => W1 W3 W4 W2 R5
WWWWW => W1 W3 W2 W4 W5
WRR => W1 R3 R2
WRW => W1 R2 W3
WWR => W1 W2 R3
WWW => W1 W2 W3
WRRR => W1 R2 R3 R4
WRRW => W1 R2 W4 R3
WRWR => W1 R2 W3 R4
WRWW => W1 R2 W3 W4
WWRR => W1 W2 R3 R4
WWRW => W1 W2 R3 W4
WWWR => W1 W2 W3 R4
WWWW => W1 W3 W2 W4
WRRRR => W1 R2 R3 R4 R5
WRRRW => W1 R3 R2 R4 W5
WRRWR => W1 R3 R2 W4 R5
WRRWW => W1 R2 W4 W5 R3
WRWRR => W1 R2 R4 R5 W3
WRWRW => W1 R2 W3 R4 W5
WRWWR => W1 W4 W3 R2 R5
WRWWW => W1 R2 W4 W5 W3
WWRRR => W1 R3 W2 R4 R5
WWRRW => W1 R3 W2 R4 W5
WWRWR => W1 W2 R5 R3 W4
WWRWW => W1 W2 W4 R3 W5
WWWRR => W1 W2 W3 R5 R4
WWWRW => W1 R4 W2 W3 W5
WWWWR => W1 R5 W3 W2 W4
WWWWW => W1 W3 W2 W4 W5
WRR => W1 R2 R3
WRW => W1 W3 R2
WWR => W1 W2 R3
WWW => W1 W2 W3
WRRR => W1 R2 R3 R4
WRRW => W1 R2 R3 W4
WRWR => W1 R2 W3 R4
WRWW => W1 W3 R2 W4
WWRR => W1 R4 R3 W2
WWRW => W1 W2 R3 W4
WWWR => W1 W3 R4 W2
WWWW => W1 W2 W3 W4
WRRRR => W1 R2 R3 R4 R5
WRRRW => W1 R4 R2 R3 W5
WRRWR => W1 R2 W4 R3 R5
WRRWW => W1 R3 R2 W5 W4
WRWRR => W1 W3 R2 R4 R5
WRWRW => W1 R4 R2 W3 W5
WRWWR => W1 R2 W4 R5 W3
WRWWW => W1 R2 W3 W4 W5
WWRRR => W1 R4 R3 W2 R5
WWRRW => W1 W2 R4 R3 W5
WWRWR => W1 R3 W2 W4 R5
WWRWW => W1 R3 W2 W5 W4
WWWRR => W1 W2 R4 R5 W3
WWWRW => W1 W2 W3 R4 W5
WWWWR => W1 W2 W3 W4 R5
WWWWW => W1 W2 W4 W3 W5
When releasing the last reader lock:
If at least one of the enqueued lock attempts is for reading, the
first one of them is granted.
Otherwise, the first of the waiting write attempts is granted.
When releasing a writer lock:
???
This implementation does not globally prefer readers, only when releasing
a reader lock.
This implementation does not prefer writers.
Default
WRR => W1 R3 R2
WRW => W1 R2 W3
WWR => W1 R3 W2
WWW => W1 W3 W2
WRRR => W1 R2 R3 R4
WRRW => W1 R3 R2 W4
WRWR => W1 R2 R4 W3
WRWW => W1 R2 W4 W3
WWRR => W1 W2 R4 R3
WWRW => W1 R3 W2 W4
WWWR => W1 R4 W2 W3
WWWW => W1 W2 W4 W3
WRRRR => W1 R3 R2 R4 R5
WRRRW => W1 R4 R3 R2 W5
WRRWR => W1 R3 R5 R2 W4
WRRWW => W1 R2 R3 W4 W5
WRWRR => W1 R4 R2 W3 R5
WRWRW => W1 W3 R4 W5 R2
WRWWR => W1 R2 W3 W4 R5
WRWWW => W1 W3 R2 W4 W5
WWRRR => W1 R5 R3 R4 W2
WWRRW => W1 R3 R4 W5 W2
WWRWR => W1 W2 W4 R5 R3
WWRWW => W1 W4 W2 R3 W5
WWWRR => W1 W2 R4 W3 R5
WWWRW => W1 W3 W2 R4 W5
WWWWR => W1 W3 W2 W4 R5
WWWWW => W1 W2 W3 W5 W4
WRR => W1 R3 R2
WRW => W1 R2 W3
WWR => W1 W2 R3
WWW => W1 W2 W3
WRRR => W1 R3 R2 R4
WRRW => W1 R2 R3 W4
WRWR => W1 R2 W3 R4
WRWW => W1 R2 W3 W4
WWRR => W1 R4 R3 W2
WWRW => W1 W2 W4 R3
WWWR => W1 W2 R4 W3
WWWW => W1 W3 W2 W4
WRRRR => W1 R3 R2 R4 R5
WRRRW => W1 R2 R3 R4 W5
WRRWR => W1 R2 R3 W4 R5
WRRWW => W1 W4 W5 R2 R3
WRWRR => W1 R2 W3 R4 R5
WRWRW => W1 R2 R4 W3 W5
WRWWR => W1 R2 W4 W3 R5
WRWWW => W1 R2 W3 W5 W4
WWRRR => W1 R3 W2 R5 R4
WWRRW => W1 R3 R4 W2 W5
WWRWR => W1 R3 W2 W4 R5
WWRWW => W1 W2 R3 W4 W5
WWWRR => W1 W2 R5 R4 W3
WWWRW => W1 R4 W2 W3 W5
WWWWR => W1 W3 W4 R5 W2
WWWWW => W1 W2 W3 W4 W5
WRR => W1 R2 R3
WRW => W1 R2 W3
WWR => W1 W2 R3
WWW => W1 W2 W3
WRRR => W1 R2 R3 R4
WRRW => W1 R2 R3 W4
WRWR => W1 W3 R2 R4
WRWW => W1 W3 W4 R2
WWRR => W1 R4 W2 R3
WWRW => W1 W2 R3 W4
WWWR => W1 W3 W2 R4
WWWW => W1 W2 W3 W4
WRRRR => W1 R2 R3 R5 R4
WRRRW => W1 R4 R2 R3 W5
WRRWR => W1 R2 R3 R5 W4
WRRWW => W1 R2 R3 W5 W4
WRWRR => W1 W3 R2 R4 R5
WRWRW => W1 W5 R2 R4 W3
WRWWR => W1 R2 R5 W4 W3
WRWWW => W1 R2 W3 W5 W4
WWRRR => W1 W2 R4 R3 R5
WWRRW => W1 W2 R3 R4 W5
WWRWR => W1 W2 R3 W4 R5
WWRWW => W1 R3 W2 W4 W5
WWWRR => W1 W2 R4 W3 R5
WWWRW => W1 W2 W3 R4 W5
WWWWR => W1 W2 W3 W4 R5
WWWWW => W1 W4 W5 W3 W2
When releasing the last reader lock:
If at least one of the enqueued lock attempts is for reading, the
first one of them is granted.
Otherwise, the first of the waiting write attempts is granted.
When releasing a writer lock:
???
This implementation does not globally prefer readers, only when releasing
a reader lock.
This implementation does not prefer writers.
Default
WRR => W1 R2 R3
WRW => W1 R2 W3
WWR => W1 W2 R3
WWW => W1 W2 W3
WRRR => W1 R2 R3 R4
WRRW => W1 R2 R3 W4
WRWR => W1 R2 W3 R4
WRWW => W1 R2 W3 W4
WWRR => W1 R4 R3 W2
WWRW => W1 R3 W2 W4
WWWR => W1 R4 W2 W3
WWWW => W1 W4 W2 W3
WRRRR => W1 R4 R2 R3 R5
WRRRW => W1 R3 R2 W5 R4
WRRWR => W1 W4 R3 R5 R2
WRRWW => W1 R3 R2 W4 W5
WRWRR => W1 W3 R2 R5 R4
WRWRW => W1 R4 W3 R2 W5
WRWWR => W1 W4 R2 R5 W3
WRWWW => W1 R2 W3 W4 W5
WWRRR => W1 R3 W2 R5 R4
WWRRW => W1 W2 R3 R4 W5
WWRWR => W1 W4 R3 W2 R5
WWRWW => W1 W4 W2 R3 W5
WWWRR => W1 W2 R4 W3 R5
WWWRW => W1 W2 R4 W5 W3
WWWWR => W1 W3 W2 W4 R5
WWWWW => W1 W4 W2 W5 W3
WRR => W1 R2 R3
WRW => W1 R2 W3
WWR => W1 R3 W2
WWW => W1 W3 W2
WRRR => W1 R2 R3 R4
WRRW => W1 R2 R3 W4
WRWR => W1 R2 R4 W3
WRWW => W1 R2 W4 W3
WWRR => W1 W2 R4 R3
WWRW => W1 W2 R3 W4
WWWR => W1 W3 W2 R4
WWWW => W1 W3 W2 W4
WRRRR => W1 R3 R4 R2 R5
WRRRW => W1 R3 R2 W5 R4
WRRWR => W1 R2 R3 R5 W4
WRRWW => W1 R2 R3 W4 W5
WRWRR => W1 R2 W3 R5 R4
WRWRW => W1 R2 W3 W5 R4
WRWWR => W1 R2 W4 W3 R5
WRWWW => W1 R2 W4 W3 W5
WWRRR => W1 W2 R3 R5 R4
WWRRW => W1 W2 R3 W5 R4
WWRWR => W1 W2 R3 R5 W4
WWRWW => W1 R3 W2 W4 W5
WWWRR => W1 W3 W2 R4 R5
WWWRW => W1 W3 W2 R4 W5
WWWWR => W1 W2 W3 W4 R5
WWWWW => W1 W3 W2 W4 W5
WRR => W1 R2 R3
WRW => W1 R2 W3
WWR => W1 W2 R3
WWW => W1 W2 W3
WRRR => W1 R2 R3 R4
WRRW => W1 R2 R3 W4
WRWR => W1 R2 W3 R4
WRWW => W1 R2 W3 W4
WWRR => W1 W2 R3 R4
WWRW => W1 W2 R3 W4
WWWR => W1 W2 R4 W3
WWWW => W1 W2 W3 W4
WRRRR => W1 R2 R5 R3 R4
WRRRW => W1 R2 R3 R4 W5
WRRWR => W1 R2 R3 W4 R5
WRRWW => W1 R2 R3 W4 W5
WRWRR => W1 R2 W3 R5 R4
WRWRW => W1 R4 R2 W3 W5
WRWWR => W1 W3 R2 W4 R5
WRWWW => W1 R2 W3 W5 W4
WWRRR => W1 W2 R3 R4 R5
WWRRW => W1 W2 R4 R3 W5
WWRWR => W1 W2 W4 R3 R5
WWRWW => W1 W2 R3 W4 W5
WWWRR => W1 W2 W3 R5 R4
WWWRW => W1 W2 W3 R4 W5
WWWWR => W1 W2 W3 W4 R5
WWWWW => W1 W2 W3 W5 W4
When releasing the last reader lock:
If at least one of the enqueued lock attempts is for reading, the
first one of them is granted.
Otherwise, the first of the waiting write attempts is granted.
When releasing a writer lock:
???
This implementation does not globally prefer readers, only when releasing
a reader lock.
This implementation does not prefer writers.
Default
WRR => W1 R2 R3
WRW => W1 W3 R2
WWR => W1 R3 W2
WWW => W1 W2 W3
WRRR => W1 R2 R3 R4
WRRW => W1 R2 R3 W4
WRWR => W1 R2 W3 R4
WRWW => W1 W3 R2 W4
WWRR => W1 W2 R4 R3
WWRW => W1 R3 W2 W4
WWWR => W1 W3 R4 W2
WWWW => W1 W3 W2 W4
WRRRR => W1 R3 R2 R4 R5
WRRRW => W1 R3 R2 W5 R4
WRRWR => W1 R2 R3 R5 W4
WRRWW => W1 R3 R2 W5 W4
WRWRR => W1 R2 W3 R4 R5
WRWRW => W1 R2 W3 R4 W5
WRWWR => W1 R2 W4 W3 R5
WRWWW => W1 R2 W4 W3 W5
WWRRR => W1 R3 W2 R5 R4
WWRRW => W1 R3 W2 R4 W5
WWRWR => W1 R3 W2 R5 W4
WWRWW => W1 R3 W2 W4 W5
WWWRR => W1 W3 W2 R5 R4
WWWRW => W1 W3 R4 W5 W2
WWWWR => W1 W3 W2 R5 W4
WWWWW => W1 W3 W2 W5 W4
WRR => W1 R3 R2
WRW => W1 W3 R2
WWR => W1 R3 W2
WWW => W1 W3 W2
WRRR => W1 R3 R2 R4
WRRW => W1 R3 R2 W4
WRWR => W1 W3 R2 R4
WRWW => W1 W3 R2 W4
WWRR => W1 R3 W2 R4
WWRW => W1 R3 W2 W4
WWWR => W1 W2 W3 R4
WWWW => W1 W3 W2 W4
WRRRR => W1 R2 R4 R5 R3
WRRRW => W1 R2 R3 R4 W5
WRRWR => W1 R2 R3 W4 R5
WRRWW => W1 R3 R2 W5 W4
WRWRR => W1 R2 W3 R5 R4
WRWRW => W1 R2 W3 W5 R4
WRWWR => W1 R2 W3 W4 R5
WRWWW => W1 R2 W3 W4 W5
WWRRR => W1 R3 W2 R4 R5
WWRRW => W1 W2 R3 R4 W5
WWRWR => W1 W2 R3 W4 R5
WWRWW => W1 W2 W4 W5 R3
WWWRR => W1 W2 R4 W3 R5
WWWRW => W1 W2 W3 R4 W5
WWWWR => W1 W2 W4 W3 R5
WWWWW => W1 W2 W5 W3 W4
WRR => W1 R2 R3
WRW => W1 R2 W3
WWR => W1 W2 R3
WWW => W1 W2 W3
WRRR => W1 R2 R3 R4
WRRW => W1 R2 R3 W4
WRWR => W1 R2 W3 R4
WRWW => W1 R2 W4 W3
WWRR => W1 R3 R4 W2
WWRW => W1 W2 R3 W4
WWWR => W1 W2 W3 R4
WWWW => W1 W2 W3 W4
WRRRR => W1 R2 R4 R5 R3
WRRRW => W1 R2 R4 R3 W5
WRRWR => W1 R2 R5 W4 R3
WRRWW => W1 R2 R3 W4 W5
WRWRR => W1 R2 W3 R4 R5
WRWRW => W1 R2 W3 R4 W5
WRWWR => W1 R2 W4 R5 W3
WRWWW => W1 W4 W3 W5 R2
WWRRR => W1 W2 R3 R4 R5
WWRRW => W1 W2 R3 R4 W5
WWRWR => W1 W2 R3 W4 R5
WWRWW => W1 W2 W4 R3 W5
WWWRR => W1 W2 R4 R5 W3
WWWRW => W1 W2 W3 W5 R4
WWWWR => W1 W2 R5 W3 W4
WWWWW => W1 W2 W3 W4 W5
When releasing the last reader lock:
If at least one of the enqueued lock attempts is for reading, the
first one of them is granted.
Otherwise, the first of the waiting write attempts is granted.
When releasing a writer lock:
???
This implementation does not globally prefer readers, only when releasing
a reader lock.
This implementation does not prefer writers.
