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

FreeBSD Manual Pages

  
 
  

home | help
ck_rwlock(3)	       FreeBSD 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 -- cen-
     tralized 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 recur-
     sion requires usage of ck_rwlock_recursive.  Read-side recursion is dis-
     allowed. The ck_rwlock_write_downgrade() function degrades	the caller's
     write-side	acquisition to a read-side acquisition without forfeit of cur-
     rent 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.

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_rwlock&sektion=3&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help