bionic (3) ck_rwlock.3.gz

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.