ck_swlock (3) - Linux Man Pages

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

In ck_swlock.h

ck_swlock_t lock = CK_SWLOCK_INITIALIZER;

Ft void Fn ck_swlock_init ck_swlock_t *lock Ft void Fn ck_swlock_write_lock ck_swlock_t *lock Ft void Fn ck_swlock_write_unlock ck_swlock_t *lock Ft void Fn ck_swlatch_write_latch ck_swlatch_t *latch Ft void Fn ck_swlatch_write_unlatch ck_swlatch_t *latch Ft bool Fn ck_swlock_write_trylock ck_swlock_t *lock Ft bool Fn ck_swlock_write_downgrade ck_swlock_t *lock Ft bool Fn ck_swlock_locked_writer ck_swlock_t *lock Ft void Fn ck_swlock_read_lock ck_swlock_t *lock Ft bool Fn ck_swlock_read_trylock ck_swlock_t *lock Ft void Fn ck_swlock_read_unlock ck_swlock_t *lock Ft bool Fn 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;
}

SEE ALSO

ck_brlock3, ck_elide3, ck_pflock3, ck_rwlock3, ck_tflock3

Additional information available at http://concurrencykit.org/