Man page - ck_swlock(3)

Packages contas this manual

Package: libck-dev
apt-get install libck-dev

Manuals in package:

Documentations in package:

libck-dev

Manual

ck_swlock(3)

Library Functions Manual

ck_swlock(3)

NAME

ck_swlock_init, ck_swlock_write_latch, ck_swlock_write_unlatch, ck_swlock_write_lock, ck_swlock_write_unlock, ck_swlock_write_trylock, ck_swlock_write_downgrade, ck_swlock_locked_writer, ck_swlock_read_lock, ck_swlock_read_trylock, ck_swlock_read_unlock, ck_swlock_locked_reader — centralized copy-safe write-biased single-writer read-write locks

LIBRARY

Concurrency Kit (libck, -lck)

SYNOPSIS

#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);

DESCRIPTION

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).

EXAMPLE

#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;
}