ck_brlock(3)               Library Functions Manual               ck_brlock(3)

NAME
     ck_brlock_init, ck_brlock_write_lock, ck_brlock_write_unlock,
     ck_brlock_write_trylock, ck_brlock_read_register,
     ck_brlock_read_unregister, ck_brlock_read_lock, ck_brlock_read_trylock,
     ck_brlock_read_unlock - big-reader locks

LIBRARY
     Concurrency Kit (libck, -lck)

SYNOPSIS
     #include <ck_brlock.h>

     ck_brlock_t brlock = CK_BRLOCK_INITIALIZER;

     ck_brlock_reader_t reader = CK_BRLOCK_READER_INITIALIZER;

     void
     ck_brlock_init(ck_brlock_t *br);

     void
     ck_brlock_write_lock(ck_brlock_t *br);

     void
     ck_brlock_write_unlock(ck_brlock_t *br);

     bool
     ck_brlock_write_trylock(ck_brlock_t *br, unsigned int factor);

     void
     ck_brlock_read_register(ck_brlock_t *br, ck_brlock_reader_t *reader);

     void
     ck_brlock_read_unregister(ck_brlock_t *br, ck_brlock_reader_t *reader);

     void
     ck_brlock_read_lock(ck_brlock_t *br, ck_brlock_reader_t *reader);

     bool
     ck_brlock_read_trylock(ck_brlock_t *br, ck_brlock_reader_t *reader,
         unsigned int factor);

     void
     ck_brlock_read_unlock(ck_brlock_reader_t *reader);

DESCRIPTION
     Big reader locks are distributed reader-writer locks with low latency
     constant time reader acquisition (with respect to number of concurrent
     readers). On the other hand, writer acquisitions are a relatively
     expensive O(n) operation. This is a write-biased lock.

EXAMPLE
           static ck_brlock_t lock = CK_BRLOCK_INITIALIZER;
           static __thread ck_brlock_reader_t reader;

           static void
           reader(void)
           {

                   /* Add our thread as a lock participant. */
                   ck_brlock_read_register(&lock, &reader);

                   for (;;) {
                           ck_brlock_read_lock(&lock, &reader);
                           /* Read-side critical section. */
                           ck_brlock_read_unlock(&reader);

                           if (ck_brlock_read_trylock(&lock, &reader, 1) == true) {
                                   /* Read-side critical section. */
                                   ck_brlock_read_unlock(&reader);
                           }
                   }

                   return;
           }

           static void
           writer(void)
           {

                   for (;;) {
                           ck_brlock_write_lock(&lock);
                           /* Write-side critical section. */
                           ck_brlock_write_unlock(&lock);

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

                   return;
           }

SEE ALSO
     ck_bytelock(3), ck_rwlock(3)

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

                                July 26, 2013.