ck_swlock3
Centralized copy-safe write-biased single-writer read-write locks
Usage
#include <ck_swlock.h>
ck_swlock_t lock = CK_SWLOCK_INITIALIZER;
void
ck_swlock_init(ck_swlock_t *lock);
void
ck_swlock_write_lock(ck_swlock_t *lock);
void
ck_swlock_write_unlock(ck_swlock_t *lock);
void
ck_swlatch_write_latch(ck_swlatch_t *latch);
void
ck_swlatch_write_unlatch(ck_swlatch_t *latch);
bool
ck_swlock_write_trylock(ck_swlock_t *lock);
bool
ck_swlock_write_downgrade(ck_swlock_t *lock);
bool
ck_swlock_locked_writer(ck_swlock_t *lock);
void
ck_swlock_read_lock(ck_swlock_t *lock);
bool
ck_swlock_read_trylock(ck_swlock_t *lock);
void
ck_swlock_read_unlock(ck_swlock_t *lock);
bool
ck_swlock_locked_reader(ck_swlock_t *lock);
Library
Concurrency Kit (libck, -lck)
Overview
This is a centralized write-biased single-writer reader-writer lock. It requires half the space that ck_rwlock does and has a low latency fast path. The lock supports latch and unlatch operations that allow it to be used in a copy-safe manner (reader-bits may be over-written safely).
Examples
#include <ck_swlock.h>
static ck_swlock_t lock = CK_SWLOCK_INITIALIZER;
static void
reader(void)
{
for (;;) {
ck_swlock_read_lock(&lock);
/* Read-side critical section. */
ck_swlock_read_unlock(&lock);
if (ck_swlock_read_trylock(&lock) == true) {
/* Read-side critical section. */
ck_swlock_read_unlock(&lock);
}
}
return;
}
static void
writer(void)
{
ck_swlock_t contrived;
for (;;) {
ck_swlock_write_lock(&lock);
/* Write-side critical section. */
ck_swlock_write_unlock(&lock);
if (ck_swlock_write_trylock(&lock) == true) {
/* Write-side critical section. */
ck_swlock_write_unlock(&lock);
}
ck_swlock_write_latch(&lock);
/* Write-side critical section. */
/* This is safe to do with-in a latch. */
contrived = lock;
lock = contrived;
ck_swlock_write_unlatch(&lock);
}
return;
}
Releases
Unchanged in 4 releases since Debian 9 (Stretch).