ck_swlock_init, ck_swlock_write_latch, ck_swlock_write_unlatch, ck_swlock_write_lock,

       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).

             #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;
             }

       Concurrency Kit (libck, -lck)

       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

ck_brlock(3), ck_elide(3), ck_pflock(3), ck_rwlock(3), ck_tflock(3)

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

                                                 April 22, 2014.                                    ck_swlock(3)

#include<ck_swlock.h>

       ck_swlock_t lock = CK_SWLOCK_INITIALIZER;

       voidck_swlock_init(ck_swlock_t*lock);

       voidck_swlock_write_lock(ck_swlock_t*lock);

       voidck_swlock_write_unlock(ck_swlock_t*lock);

       voidck_swlatch_write_latch(ck_swlatch_t*latch);

       voidck_swlatch_write_unlatch(ck_swlatch_t*latch);

       boolck_swlock_write_trylock(ck_swlock_t*lock);

       boolck_swlock_write_downgrade(ck_swlock_t*lock);

       boolck_swlock_locked_writer(ck_swlock_t*lock);

       voidck_swlock_read_lock(ck_swlock_t*lock);

       boolck_swlock_read_trylock(ck_swlock_t*lock);

       voidck_swlock_read_unlock(ck_swlock_t*lock);

       boolck_swlock_locked_reader(ck_swlock_t*lock);