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

FreeBSD Manual Pages

  
 
  

home | help
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  re-
       cursion	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 for-
       feit 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.			  ck_rwlock(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=ck_rwlock&sektion=3&manpath=FreeBSD+Ports+14.3.quarterly>

home | help