DragonFly On-Line Manual Pages

ck_rwlock(3)          DragonFly Library Functions Manual          ck_rwlock(3)

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.