~drizzle-trunk/drizzle/development

/******************************************************

The read-write lock (for threads)

(c) 1995 Innobase Oy

Created 9/11/1995 Heikki Tuuri

*******************************************************/

/**********************************************************************

Lock an rw-lock in shared mode for the current thread. If the rw-lock is

locked in exclusive mode, or there is an exclusive lock request waiting,

the function spins a preset time (controlled by SYNC_SPIN_ROUNDS),

waiting for the lock before suspending the thread. */

void

rw_lock_s_lock_spin(

/*================*/

	rw_lock_t*	lock,	/* in: pointer to rw-lock */

	ulint		pass,	/* in: pass value; != 0, if the lock will

				be passed to another thread to unlock */

	const char*	file_name,/* in: file name where lock requested */

	ulint		line);	/* in: line where requested */

#ifdef UNIV_SYNC_DEBUG

/**********************************************************************

Inserts the debug information for an rw-lock. */

void

rw_lock_add_debug_info(

/*===================*/

	rw_lock_t*	lock,		/* in: rw-lock */

	ulint		pass,		/* in: pass value */

	ulint		lock_type,	/* in: lock type */

	const char*	file_name,	/* in: file where requested */

	ulint		line);		/* in: line where requested */

/**********************************************************************

Removes a debug information struct for an rw-lock. */

void

rw_lock_remove_debug_info(

/*======================*/

	rw_lock_t*	lock,		/* in: rw-lock */

	ulint		pass,		/* in: pass value */

	ulint		lock_type);	/* in: lock type */

#endif /* UNIV_SYNC_DEBUG */

/************************************************************************

Accessor functions for rw lock. */

UNIV_INLINE

ulint

rw_lock_get_waiters(

/*================*/

	rw_lock_t*	lock)

{

	return(lock->waiters);

}

UNIV_INLINE

void

rw_lock_set_waiters(

/*================*/

	rw_lock_t*	lock,

	ulint		flag)

{

	lock->waiters = flag;

}

UNIV_INLINE

ulint

rw_lock_get_writer(

/*===============*/

	rw_lock_t*	lock)

{

	return(lock->writer);

}

UNIV_INLINE

void

rw_lock_set_writer(

/*===============*/

	rw_lock_t*	lock,

	ulint		flag)

{

	lock->writer = flag;

}

UNIV_INLINE

ulint

rw_lock_get_reader_count(

/*=====================*/

	rw_lock_t*	lock)

{

	return(lock->reader_count);

}

UNIV_INLINE

void

rw_lock_set_reader_count(

/*=====================*/

	rw_lock_t*	lock,

	ulint		count)

{

	lock->reader_count = count;

}

UNIV_INLINE

mutex_t*

rw_lock_get_mutex(

/*==============*/

	rw_lock_t*	lock)

{

	return(&(lock->mutex));

}

/**********************************************************************

Returns the value of writer_count for the lock. Does not reserve the lock

mutex, so the caller must be sure it is not changed during the call. */

UNIV_INLINE

ulint

rw_lock_get_x_lock_count(

/*=====================*/

				/* out: value of writer_count */

	rw_lock_t*	lock)	/* in: rw-lock */

{

	return(lock->writer_count);

}

/**********************************************************************

Low-level function which tries to lock an rw-lock in s-mode. Performs no

spinning. */

UNIV_INLINE

ibool

rw_lock_s_lock_low(

/*===============*/

				/* out: TRUE if success */

	rw_lock_t*	lock,	/* in: pointer to rw-lock */

	ulint		pass __attribute__((unused)),

				/* in: pass value; != 0, if the lock will be

				passed to another thread to unlock */

	const char*	file_name, /* in: file name where lock requested */

	ulint		line)	/* in: line where requested */

{

	ut_ad(mutex_own(rw_lock_get_mutex(lock)));

	/* Check if the writer field is free */

	if (UNIV_LIKELY(lock->writer == RW_LOCK_NOT_LOCKED)) {

		/* Set the shared lock by incrementing the reader count */

		lock->reader_count++;

#ifdef UNIV_SYNC_DEBUG

		rw_lock_add_debug_info(lock, pass, RW_LOCK_SHARED, file_name,

				       line);

#endif

		lock->last_s_file_name = file_name;

		lock->last_s_line = line;

		return(TRUE);	/* locking succeeded */

	}

	return(FALSE);	/* locking did not succeed */

}

/**********************************************************************

Low-level function which locks an rw-lock in s-mode when we know that it

is possible and none else is currently accessing the rw-lock structure.

Then we can do the locking without reserving the mutex. */

UNIV_INLINE

void

rw_lock_s_lock_direct(

/*==================*/

	rw_lock_t*	lock,		/* in: pointer to rw-lock */

	const char*	file_name,	/* in: file name where requested */

	ulint		line)		/* in: line where lock requested */

{

	ut_ad(lock->writer == RW_LOCK_NOT_LOCKED);

	ut_ad(rw_lock_get_reader_count(lock) == 0);

	/* Set the shared lock by incrementing the reader count */

	lock->reader_count++;

	lock->last_s_file_name = file_name;

	lock->last_s_line = line;

#ifdef UNIV_SYNC_DEBUG

	rw_lock_add_debug_info(lock, 0, RW_LOCK_SHARED, file_name, line);

#endif

}

/**********************************************************************

Low-level function which locks an rw-lock in x-mode when we know that it

is not locked and none else is currently accessing the rw-lock structure.

Then we can do the locking without reserving the mutex. */

UNIV_INLINE

void

rw_lock_x_lock_direct(

/*==================*/

	rw_lock_t*	lock,		/* in: pointer to rw-lock */

	const char*	file_name,	/* in: file name where requested */

	ulint		line)		/* in: line where lock requested */

{

	ut_ad(rw_lock_validate(lock));

	ut_ad(rw_lock_get_reader_count(lock) == 0);

	ut_ad(rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED);

	rw_lock_set_writer(lock, RW_LOCK_EX);

	lock->writer_thread = os_thread_get_curr_id();

	lock->writer_count++;

	lock->pass = 0;

	lock->last_x_file_name = file_name;

	lock->last_x_line = line;

#ifdef UNIV_SYNC_DEBUG

	rw_lock_add_debug_info(lock, 0, RW_LOCK_EX, file_name, line);

#endif

}

/**********************************************************************

NOTE! Use the corresponding macro, not directly this function! Lock an

rw-lock in shared mode for the current thread. If the rw-lock is locked

in exclusive mode, or there is an exclusive lock request waiting, the

function spins a preset time (controlled by SYNC_SPIN_ROUNDS), waiting for

the lock, before suspending the thread. */

UNIV_INLINE

void

rw_lock_s_lock_func(

/*================*/

	rw_lock_t*	lock,	/* in: pointer to rw-lock */

	ulint		pass,	/* in: pass value; != 0, if the lock will

				be passed to another thread to unlock */

	const char*	file_name,/* in: file name where lock requested */

	ulint		line)	/* in: line where requested */

{

	/* NOTE: As we do not know the thread ids for threads which have

	s-locked a latch, and s-lockers will be served only after waiting

	x-lock requests have been fulfilled, then if this thread already

	owns an s-lock here, it may end up in a deadlock with another thread

	which requests an x-lock here. Therefore, we will forbid recursive

	s-locking of a latch: the following assert will warn the programmer

	of the possibility of this kind of a deadlock. If we want to implement

	safe recursive s-locking, we should keep in a list the thread ids of

	the threads which have s-locked a latch. This would use some CPU

	time. */

#ifdef UNIV_SYNC_DEBUG

	ut_ad(!rw_lock_own(lock, RW_LOCK_SHARED)); /* see NOTE above */

#endif /* UNIV_SYNC_DEBUG */

	mutex_enter(rw_lock_get_mutex(lock));

	if (UNIV_LIKELY(rw_lock_s_lock_low(lock, pass, file_name, line))) {

		mutex_exit(rw_lock_get_mutex(lock));

		return; /* Success */

	} else {

		/* Did not succeed, try spin wait */

		mutex_exit(rw_lock_get_mutex(lock));

		rw_lock_s_lock_spin(lock, pass, file_name, line);

		return;

	}

}

/**********************************************************************

NOTE! Use the corresponding macro, not directly this function! Lock an

rw-lock in shared mode for the current thread if the lock can be acquired

immediately. */

UNIV_INLINE

ibool

rw_lock_s_lock_func_nowait(

/*=======================*/

				/* out: TRUE if success */

	rw_lock_t*	lock,	/* in: pointer to rw-lock */

	const char*	file_name,/* in: file name where lock requested */

	ulint		line)	/* in: line where requested */

{

	ibool	success	= FALSE;

	mutex_enter(rw_lock_get_mutex(lock));

	if (lock->writer == RW_LOCK_NOT_LOCKED) {

		/* Set the shared lock by incrementing the reader count */

		lock->reader_count++;

#ifdef UNIV_SYNC_DEBUG

		rw_lock_add_debug_info(lock, 0, RW_LOCK_SHARED, file_name,

				       line);

#endif

		lock->last_s_file_name = file_name;

		lock->last_s_line = line;

		success = TRUE;

	}

	mutex_exit(rw_lock_get_mutex(lock));

	return(success);

}

/**********************************************************************

NOTE! Use the corresponding macro, not directly this function! Lock an

rw-lock in exclusive mode for the current thread if the lock can be

obtained immediately. */

UNIV_INLINE

ibool

rw_lock_x_lock_func_nowait(

/*=======================*/

				/* out: TRUE if success */

	rw_lock_t*	lock,	/* in: pointer to rw-lock */

	const char*	file_name,/* in: file name where lock requested */

	ulint		line)	/* in: line where requested */

{

	ibool		success		= FALSE;

	os_thread_id_t	curr_thread	= os_thread_get_curr_id();

	mutex_enter(rw_lock_get_mutex(lock));

	if (UNIV_UNLIKELY(rw_lock_get_reader_count(lock) != 0)) {

	} else if (UNIV_LIKELY(rw_lock_get_writer(lock)

			       == RW_LOCK_NOT_LOCKED)) {

		rw_lock_set_writer(lock, RW_LOCK_EX);

		lock->writer_thread = curr_thread;

		lock->pass = 0;

relock:

		lock->writer_count++;

#ifdef UNIV_SYNC_DEBUG

		rw_lock_add_debug_info(lock, 0, RW_LOCK_EX, file_name, line);

#endif

		lock->last_x_file_name = file_name;

		lock->last_x_line = line;

		success = TRUE;

	} else if (rw_lock_get_writer(lock) == RW_LOCK_EX

		   && lock->pass == 0

		   && os_thread_eq(lock->writer_thread, curr_thread)) {

		goto relock;

	}

	mutex_exit(rw_lock_get_mutex(lock));

	ut_ad(rw_lock_validate(lock));

	return(success);

}

/**********************************************************************

Releases a shared mode lock. */

UNIV_INLINE

void

rw_lock_s_unlock_func(

/*==================*/

	rw_lock_t*	lock	/* in: rw-lock */

#ifdef UNIV_SYNC_DEBUG

	,ulint		pass	/* in: pass value; != 0, if the lock may have

				been passed to another thread to unlock */

#endif

	)

{

	mutex_t*	mutex	= &(lock->mutex);

	ibool		sg	= FALSE;

	/* Acquire the mutex protecting the rw-lock fields */

	mutex_enter(mutex);

	/* Reset the shared lock by decrementing the reader count */

	ut_a(lock->reader_count > 0);

	lock->reader_count--;

#ifdef UNIV_SYNC_DEBUG

	rw_lock_remove_debug_info(lock, pass, RW_LOCK_SHARED);

#endif

	/* If there may be waiters and this was the last s-lock,

	signal the object */

	if (UNIV_UNLIKELY(lock->waiters)

	    && lock->reader_count == 0) {

		sg = TRUE;

		rw_lock_set_waiters(lock, 0);

	}

	mutex_exit(mutex);

	if (UNIV_UNLIKELY(sg)) {

		sync_array_signal_object(sync_primary_wait_array, lock);

	}

	ut_ad(rw_lock_validate(lock));

#ifdef UNIV_SYNC_PERF_STAT

	rw_s_exit_count++;

#endif

}

/**********************************************************************

Releases a shared mode lock when we know there are no waiters and none

else will access the lock during the time this function is executed. */

UNIV_INLINE

void

rw_lock_s_unlock_direct(

/*====================*/

	rw_lock_t*	lock)	/* in: rw-lock */

{

	/* Reset the shared lock by decrementing the reader count */

	ut_ad(lock->reader_count > 0);

	lock->reader_count--;

#ifdef UNIV_SYNC_DEBUG

	rw_lock_remove_debug_info(lock, 0, RW_LOCK_SHARED);

#endif

	ut_ad(!lock->waiters);

	ut_ad(rw_lock_validate(lock));

#ifdef UNIV_SYNC_PERF_STAT

	rw_s_exit_count++;

#endif

}

/**********************************************************************

Releases an exclusive mode lock. */

UNIV_INLINE

void

rw_lock_x_unlock_func(

/*==================*/

	rw_lock_t*	lock	/* in: rw-lock */

#ifdef UNIV_SYNC_DEBUG

	,ulint		pass	/* in: pass value; != 0, if the lock may have

				been passed to another thread to unlock */

#endif

	)

{

	ibool	sg	= FALSE;

	/* Acquire the mutex protecting the rw-lock fields */

	mutex_enter(&(lock->mutex));

	/* Reset the exclusive lock if this thread no longer has an x-mode

	lock */

	ut_ad(lock->writer_count > 0);

	lock->writer_count--;

	if (lock->writer_count == 0) {

		rw_lock_set_writer(lock, RW_LOCK_NOT_LOCKED);

	}

#ifdef UNIV_SYNC_DEBUG

	rw_lock_remove_debug_info(lock, pass, RW_LOCK_EX);

#endif

	/* If there may be waiters, signal the lock */

	if (UNIV_UNLIKELY(lock->waiters)

	    && lock->writer_count == 0) {

		sg = TRUE;

		rw_lock_set_waiters(lock, 0);

	}

	mutex_exit(&(lock->mutex));

	if (UNIV_UNLIKELY(sg)) {

		sync_array_signal_object(sync_primary_wait_array, lock);

	}

	ut_ad(rw_lock_validate(lock));

#ifdef UNIV_SYNC_PERF_STAT

	rw_x_exit_count++;

#endif

}

/**********************************************************************

Releases an exclusive mode lock when we know there are no waiters, and

none else will access the lock durint the time this function is executed. */

UNIV_INLINE

void

rw_lock_x_unlock_direct(

/*====================*/

	rw_lock_t*	lock)	/* in: rw-lock */

{

	/* Reset the exclusive lock if this thread no longer has an x-mode

	lock */

	ut_ad(lock->writer_count > 0);

	lock->writer_count--;

	if (lock->writer_count == 0) {

		rw_lock_set_writer(lock, RW_LOCK_NOT_LOCKED);

	}

#ifdef UNIV_SYNC_DEBUG

	rw_lock_remove_debug_info(lock, 0, RW_LOCK_EX);

#endif

	ut_ad(!lock->waiters);

	ut_ad(rw_lock_validate(lock));

#ifdef UNIV_SYNC_PERF_STAT

	rw_x_exit_count++;

#endif

}