NAME

       ck_rwlock_init,        ck_rwlock_write_lock,       ck_rwlock_write_unlock,       ck_rwlock_write_trylock,
       ck_rwlock_write_downgrade,    ck_rwlock_locked_writer,    ck_rwlock_read_lock,    ck_rwlock_read_trylock,
       ck_rwlock_read_unlock,              ck_rwlock_locked_reader,              ck_rwlock_recursive_write_lock,
       ck_rwlock_recursive_write_trylock,    ck_rwlock_recurisve_write_unlock,    ck_rwlock_recursive_read_lock,
       ck_rwlock_recursive_read_trylock,  ck_rwlock_recursive_read_unlock  —  centralized  write-biased  reader-
       writer locks

LIBRARY

       Concurrency Kit (libck, -lck)

SYNOPSIS

       #include <ck_rwlock.h>

       ck_rwlock_t lock = CK_RWLOCK_INITIALIZER;

       void
       ck_rwlock_init(ck_rwlock_t *lock);

       void
       ck_rwlock_write_lock(ck_rwlock_t *lock);

       void
       ck_rwlock_write_unlock(ck_rwlock_t *lock);

       bool
       ck_rwlock_write_trylock(ck_rwlock_t *lock);

       bool
       ck_rwlock_write_downgrade(ck_rwlock_t *lock);

       bool
       ck_rwlock_locked_writer(ck_rwlock_t *lock);

       void
       ck_rwlock_read_lock(ck_rwlock_t *lock);

       bool
       ck_rwlock_read_trylock(ck_rwlock_t *lock);

       void
       ck_rwlock_read_unlock(ck_rwlock_t *lock);

       bool
       ck_rwlock_locked_reader(ck_rwlock_t *lock);

       ck_rwlock_recursive_t lock = CK_RWLOCK_RECURSIVE_INITIALIZER;

       void
       ck_rwlock_recursive_write_lock(ck_rwlock_recursive_t *lock, unsigned int tid);

       bool
       ck_rwlock_recursive_write_trylock(ck_rwlock_recursive_t *lock, unsigned int tid);

       void
       ck_rwlock_recurisve_write_unlock(ck_rwlock_recursive_t *lock);

       void
       ck_rwlock_recursive_read_lock(ck_rwlock_recursive_t *lock);

       bool
       ck_rwlock_recursive_read_trylock(ck_rwlock_recursive_t *lock);

       void
       ck_rwlock_recursive_read_unlock(ck_rwlock_recursive_t *lock);

DESCRIPTION

       This is a centralized write-biased reader-writer lock. It requires very little space overhead and  has  a
       low  latency  fast path. Write-side recursion requires usage of ck_rwlock_recursive.  Read-side recursion
       is disallowed. The ck_rwlock_write_downgrade() function degrades the caller's write-side acquisition to a
       read-side acquisition without forfeit of current critical section.

EXAMPLE

             #include <ck_rwlock.h>

             static ck_rwlock_t lock = CK_RWLOCK_INITIALIZER;

             static void
             reader(void)
             {

                     for (;;) {
                             ck_rwlock_read_lock(&lock);
                             /* Read-side critical section. */
                             ck_rwlock_read_unlock(&lock);

                             if (ck_rwlock_read_trylock(&lock) == true) {
                                     /* Read-side critical section. */
                                     ck_rwlock_read_unlock(&lock);
                             }
                     }

                     return;
             }

             static void
             writer(void)
             {

                     for (;;) {
                             ck_rwlock_write_lock(&lock);
                             /* Write-side critical section. */
                             ck_rwlock_write_unlock(&lock);

                             if (ck_rwlock_write_trylock(&lock, 1) == true) {
                                     /* Write-side critical section. */
                                     ck_rwlock_write_unlock(&lock);
                             }
                     }

                     return;
             }

SEE ALSO

       ck_brlock(3), ck_elide(3)

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

                                                 July 26, 2013.                                     ck_rwlock(3)