~drizzle-trunk/drizzle/development

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

Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.

Copyright (c) 2008, Google Inc.

Portions of this file contain modifications contributed and copyrighted by

Google, Inc. Those modifications are gratefully acknowledged and are described

briefly in the InnoDB documentation. The contributions by Google are

incorporated with their permission, and subject to the conditions contained in

the file COPYING.Google.

This program is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free Software

Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with

this program; if not, write to the Free Software Foundation, Inc., 59 Temple

Place, Suite 330, Boston, MA 02111-1307 USA

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

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

@file include/sync0sync.ic

Mutex, the basic synchronization primitive

Created 9/5/1995 Heikki Tuuri

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

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

Sets the waiters field in a mutex. */

UNIV_INTERN

void

mutex_set_waiters(

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

	mutex_t*	mutex,	/*!< in: mutex */

	ulint		n);	/*!< in: value to set */

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

Reserves a mutex for the current thread. If the mutex is reserved, the

function spins a preset time (controlled by SYNC_SPIN_ROUNDS) waiting

for the mutex before suspending the thread. */

UNIV_INTERN

void

mutex_spin_wait(

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

	mutex_t*	mutex,		/*!< in: pointer to mutex */

	const char*	file_name,	/*!< in: file name where mutex

					requested */

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

#ifdef UNIV_SYNC_DEBUG

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

Sets the debug information for a reserved mutex. */

UNIV_INTERN

void

mutex_set_debug_info(

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

	mutex_t*	mutex,		/*!< in: mutex */

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

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

#endif /* UNIV_SYNC_DEBUG */

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

Releases the threads waiting in the primary wait array for this mutex. */

UNIV_INTERN

void

mutex_signal_object(

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

	mutex_t*	mutex);	/*!< in: mutex */

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

Performs an atomic test-and-set instruction to the lock_word field of a

mutex.

@return	the previous value of lock_word: 0 or 1 */

UNIV_INLINE

byte

mutex_test_and_set(

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

	mutex_t*	mutex)	/*!< in: mutex */

{

#if defined(HAVE_ATOMIC_BUILTINS)

	return(os_atomic_test_and_set_byte(&mutex->lock_word, 1));

#else

	ibool	ret;

	ret = os_fast_mutex_trylock(&(mutex->os_fast_mutex));

	if (ret == 0) {

		/* We check that os_fast_mutex_trylock does not leak

		and allow race conditions */

		ut_a(mutex->lock_word == 0);

		mutex->lock_word = 1;

	}

	return((byte)ret);

#endif

}

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

Performs a reset instruction to the lock_word field of a mutex. This

instruction also serializes memory operations to the program order. */

UNIV_INLINE

void

mutex_reset_lock_word(

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

	mutex_t*	mutex)	/*!< in: mutex */

{

#if defined(HAVE_ATOMIC_BUILTINS)

	/* In theory __sync_lock_release should be used to release the lock.

	Unfortunately, it does not work properly alone. The workaround is

	that more conservative __sync_lock_test_and_set is used instead. */

	os_atomic_test_and_set_byte(&mutex->lock_word, 0);

#else

	mutex->lock_word = 0;

	os_fast_mutex_unlock(&(mutex->os_fast_mutex));

#endif

}

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

Gets the value of the lock word. */

UNIV_INLINE

lock_word_t

mutex_get_lock_word(

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

	const mutex_t*	mutex)	/*!< in: mutex */

{

	ut_ad(mutex);

	return(mutex->lock_word);

}

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

Gets the waiters field in a mutex.

@return	value to set */

UNIV_INLINE

ulint

mutex_get_waiters(

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

	const mutex_t*	mutex)	/*!< in: mutex */

{

	const volatile ulint*	ptr;	/*!< declared volatile to ensure that

					the value is read from memory */

	ut_ad(mutex);

	ptr = &(mutex->waiters);

	return(*ptr);		/* Here we assume that the read of a single

				word from memory is atomic */

}

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

Unlocks a mutex owned by the current thread. */

UNIV_INLINE

void

mutex_exit(

/*=======*/

	mutex_t*	mutex)	/*!< in: pointer to mutex */

{

	ut_ad(mutex_own(mutex));

	ut_d(mutex->thread_id = (os_thread_id_t) ULINT_UNDEFINED);

#ifdef UNIV_SYNC_DEBUG

	sync_thread_reset_level(mutex);

#endif

	mutex_reset_lock_word(mutex);

	/* A problem: we assume that mutex_reset_lock word

	is a memory barrier, that is when we read the waiters

	field next, the read must be serialized in memory

	after the reset. A speculative processor might

	perform the read first, which could leave a waiting

	thread hanging indefinitely.

	Our current solution call every second

	sync_arr_wake_threads_if_sema_free()

	to wake up possible hanging threads if

	they are missed in mutex_signal_object. */

	if (mutex_get_waiters(mutex) != 0) {

		mutex_signal_object(mutex);

	}

#ifdef UNIV_SYNC_PERF_STAT

	mutex_exit_count++;

#endif

}

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

Locks a mutex for the current thread. If the mutex is reserved, the function

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

before suspending the thread. */

UNIV_INLINE

void

mutex_enter_func(

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

	mutex_t*	mutex,		/*!< in: pointer to mutex */

	const char*	file_name,	/*!< in: file name where locked */

	ulint		line)		/*!< in: line where locked */

{

	ut_ad(mutex_validate(mutex));

	ut_ad(!mutex_own(mutex));

	/* Note that we do not peek at the value of lock_word before trying

	the atomic test_and_set; we could peek, and possibly save time. */

	ut_d(mutex->count_using++);

	if (!mutex_test_and_set(mutex)) {

		ut_d(mutex->thread_id = os_thread_get_curr_id());

#ifdef UNIV_SYNC_DEBUG

		mutex_set_debug_info(mutex, file_name, line);

#endif

		return;	/* Succeeded! */

	}

	mutex_spin_wait(mutex, file_name, line);

}