Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
ck_swlock(3)	       FreeBSD Library Functions Manual		  ck_swlock(3)

NAME
     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

LIBRARY
     Concurrency Kit (libck, -lck)

SYNOPSIS
     #include <ck_swlock.h>

     ck_swlock_t lock =	CK_SWLOCK_INITIALIZER;

     void
     ck_swlock_init(ck_swlock_t	*lock);

     void
     ck_swlock_write_lock(ck_swlock_t *lock);

     void
     ck_swlock_write_unlock(ck_swlock_t	*lock);

     void
     ck_swlatch_write_latch(ck_swlatch_t *latch);

     void
     ck_swlatch_write_unlatch(ck_swlatch_t *latch);

     bool
     ck_swlock_write_trylock(ck_swlock_t *lock);

     bool
     ck_swlock_write_downgrade(ck_swlock_t *lock);

     bool
     ck_swlock_locked_writer(ck_swlock_t *lock);

     void
     ck_swlock_read_lock(ck_swlock_t *lock);

     bool
     ck_swlock_read_trylock(ck_swlock_t	*lock);

     void
     ck_swlock_read_unlock(ck_swlock_t *lock);

     bool
     ck_swlock_locked_reader(ck_swlock_t *lock);

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

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

SEE ALSO
     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.

NAME | LIBRARY | SYNOPSIS | DESCRIPTION | EXAMPLE | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=ck_swlock&sektion=3&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help