path: root/storage/xtradb/include/sync0sync.ic

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

Copyright (c) 1995, 2009, Oracle and/or its affiliates. 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.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 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(
/*==============*/
	ib_mutex_t*	mutex,	/*!< in: mutex */
	ulint		n);	/*!< in: value to set */
/******************************************************************//**
Reserves a mutex or a priority 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(
/*============*/
	void*		_mutex,		/*!< in: pointer to mutex */
	bool		high_priority,	/*!< in: whether the mutex is a
					priority mutex with high priority
					specified */
	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(
/*=================*/
	ib_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(
/*================*/
	ib_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
ib_mutex_test_and_set(
/*===============*/
	ib_mutex_t*	mutex)	/*!< in: mutex */
{
#if defined(HAVE_ATOMIC_BUILTINS)
	return(os_atomic_test_and_set_byte_acquire(&mutex->lock_word, 1));
#else
	ibool	ret;

	ret = os_fast_mutex_trylock_full_barrier(&(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(
/*==================*/
	ib_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_release(&mutex->lock_word, 0);
#else
	mutex->lock_word = 0;

	os_fast_mutex_unlock_full_barrier(&(mutex->os_fast_mutex));
#endif
}

/******************************************************************//**
Gets the value of the lock word. */
UNIV_INLINE
lock_word_t
mutex_get_lock_word(
/*================*/
	const ib_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 ib_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 */
}

/******************************************************************//**
NOTE! Use the corresponding macro mutex_exit(), not directly this function!
Unlocks a mutex owned by the current thread. */
UNIV_INLINE
void
mutex_exit_func(
/*============*/
	ib_mutex_t*	mutex)	/*!< in: pointer to mutex */
{
	ut_ad(mutex_own(mutex));

	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
}

/******************************************************************//**
NOTE! Use the corresponding macro mutex_exit(), not directly this function!
Unlocks a priority mutex owned by the current thread. */
UNIV_INLINE
void
mutex_exit_func(
/*============*/
	ib_prio_mutex_t*	mutex)	/*!< in: pointer to mutex */
{
	ut_ad(mutex_own(mutex));

	mutex->base_mutex.thread_id = (os_thread_id_t) ULINT_UNDEFINED;

#ifdef UNIV_SYNC_DEBUG
	sync_thread_reset_level(&mutex->base_mutex);
#endif
	mutex_reset_lock_word(&mutex->base_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. */

	/* Wake up any high priority waiters first.  */
	if (mutex->high_priority_waiters != 0) {

		os_event_set(mutex->high_priority_event);
		sync_array_object_signalled();

	} else if (mutex_get_waiters(&mutex->base_mutex) != 0) {

		mutex_signal_object(&mutex->base_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(
/*=============*/
	ib_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));
#ifndef WITH_WSREP
	/* this cannot be be granted when BF trx kills a trx in lock wait state */
	ut_ad(!mutex_own(mutex));
#endif /* WITH_WSREP */

	/* 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. */

	if (!ib_mutex_test_and_set(mutex)) {
		mutex->thread_id = os_thread_get_curr_id();
#ifdef UNIV_SYNC_DEBUG
		mutex_set_debug_info(mutex, file_name, line);
#endif
		if (srv_instrument_semaphores) {
			mutex->file_name = file_name;
			mutex->line = line;
		}

		return;	/* Succeeded! */
	}

	mutex_spin_wait(mutex, false, file_name, line);
}

/******************************************************************//**
NOTE! Use the corresponding macro in the header file, not this function
directly. Locks a priority 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. If the thread is suspended,
the priority argument value determines the relative order for its wake up.  Any
IB_HIGH_PRIO waiters will be woken up before any IB_LOW_PRIO waiters.  In case
of IB_DEFAULT_PRIO, the relative priority will be set according to
srv_current_thread_priority.  */
UNIV_INLINE
void
mutex_enter_func(
/*=============*/
	ib_prio_mutex_t*	mutex,		/*!< in: pointer to mutex */
	const char*		file_name,	/*!< in: file name where
						locked */
	ulint			line,		/*!< in: line where locked */
	enum ib_sync_priority	priority)
						/*!<in: mutex acquisition
						priority */
{
	bool	high_priority;

	ut_ad(mutex_validate(&mutex->base_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. */

	if (!ib_mutex_test_and_set(&mutex->base_mutex)) {
		mutex->base_mutex.thread_id = os_thread_get_curr_id();
#ifdef UNIV_SYNC_DEBUG
		mutex_set_debug_info(&mutex->base_mutex, file_name, line);
#endif
		mutex->base_mutex.file_name = file_name;
		mutex->base_mutex.line = line;

		return;	/* Succeeded! */
	}

	if (UNIV_LIKELY(priority == IB_DEFAULT_PRIO)) {
		high_priority = srv_current_thread_priority;
	} else {
		high_priority = (priority == IB_HIGH_PRIO);
	}
	mutex_spin_wait(mutex, high_priority, file_name, line);
}

/********************************************************************//**
NOTE! Use the corresponding macro in the header file, not this function
directly. Tries to lock the mutex for the current thread. If the lock is not
acquired immediately, returns with return value 1.
@return	0 if succeed, 1 if not */
UNIV_INLINE
ulint
mutex_enter_nowait_func(
/*====================*/
	ib_prio_mutex_t*	mutex,		/*!< in: pointer to mutex */
	const char*		file_name,	/*!< in: file name where mutex
						requested */
	ulint			line)		/*!< in: line where
					       requested */
{
	return mutex_enter_nowait_func(&mutex->base_mutex, file_name, line);
}

#ifdef UNIV_PFS_MUTEX
/******************************************************************//**
NOTE! Please use the corresponding macro mutex_enter(), not directly
this function!
This is a performance schema instrumented wrapper function for
mutex_enter_func(). */
UNIV_INLINE
void
pfs_mutex_enter_func(
/*=================*/
	ib_mutex_t*	mutex,	/*!< in: pointer to mutex */
	const char*	file_name,	/*!< in: file name where locked */
	ulint		line)		/*!< in: line where locked */
{
	if (mutex->pfs_psi != NULL) {
		PSI_mutex_locker*	locker;
		PSI_mutex_locker_state	state;

		locker = PSI_MUTEX_CALL(start_mutex_wait)(
			&state, mutex->pfs_psi,
			PSI_MUTEX_LOCK, file_name,
			static_cast<uint>(line));

		mutex_enter_func(mutex, file_name, line);

		if (locker != NULL) {
			PSI_MUTEX_CALL(end_mutex_wait)(locker, 0);
		}
	} else {
		mutex_enter_func(mutex, file_name, line);
	}
}

/******************************************************************//**
NOTE! Please use the corresponding macro mutex_enter(), not directly
this function!
This is a performance schema instrumented wrapper function for
mutex_enter_func(). */
UNIV_INLINE
void
pfs_mutex_enter_func(
/*=================*/
	ib_prio_mutex_t*	mutex,		/*!< in: pointer to mutex */
	const char*		file_name,	/*!< in: file name where
						locked */
	ulint			line,		/*!< in: line where locked */
	enum ib_sync_priority	priority)	/*!<in: mutex acquisition
						priority */
{
	if (mutex->base_mutex.pfs_psi != NULL) {
		PSI_mutex_locker*	locker;
		PSI_mutex_locker_state	state;

		locker = PSI_MUTEX_CALL(start_mutex_wait)(
			&state, mutex->base_mutex.pfs_psi,
			PSI_MUTEX_LOCK, file_name, line);

		mutex_enter_func(mutex, file_name, line, priority);

		if (locker != NULL) {
			PSI_MUTEX_CALL(end_mutex_wait)(locker, 0);
		}
	} else {
		mutex_enter_func(mutex, file_name, line, priority);
	}
}

/********************************************************************//**
NOTE! Please use the corresponding macro mutex_enter_nowait(), not directly
this function!
This is a performance schema instrumented wrapper function for
mutex_enter_nowait_func.
@return 0 if succeed, 1 if not */
UNIV_INLINE
ulint
pfs_mutex_enter_nowait_func(
/*========================*/
	ib_mutex_t*	mutex,		/*!< in: pointer to mutex */
	const char*	file_name,	/*!< in: file name where mutex
					requested */
	ulint		line)		/*!< in: line where requested */
{
	ulint		ret;

	if (mutex->pfs_psi != NULL) {
		PSI_mutex_locker*	locker;
		PSI_mutex_locker_state		state;

		locker = PSI_MUTEX_CALL(start_mutex_wait)(
			&state, mutex->pfs_psi,
			PSI_MUTEX_TRYLOCK, file_name,
			static_cast<uint>(line));

		ret = mutex_enter_nowait_func(mutex, file_name, line);

		if (locker != NULL) {
			PSI_MUTEX_CALL(end_mutex_wait)(locker, (int) ret);
		}
	} else {
		ret = mutex_enter_nowait_func(mutex, file_name, line);
	}

	return(ret);
}

/********************************************************************//**
NOTE! Please use the corresponding macro mutex_enter_nowait(), not directly
this function!
This is a performance schema instrumented wrapper function for
mutex_enter_nowait_func.
@return	0 if succeed, 1 if not */
UNIV_INLINE
ulint
pfs_mutex_enter_nowait_func(
/*========================*/
	ib_prio_mutex_t*	mutex,		/*!< in: pointer to mutex */
	const char*		file_name,	/*!< in: file name where mutex
						  requested */
	ulint			line)		/*!< in: line where
						  requested */
{
	return pfs_mutex_enter_nowait_func(&mutex->base_mutex, file_name,
					   line);
}

/******************************************************************//**
NOTE! Please use the corresponding macro mutex_exit(), not directly
this function!
A wrap function of mutex_exit_func() with performance schema instrumentation.
Unlocks a mutex owned by the current thread. */
UNIV_INLINE
void
pfs_mutex_exit_func(
/*================*/
	ib_mutex_t*	mutex)	/*!< in: pointer to mutex */
{
	if (mutex->pfs_psi != NULL) {
		PSI_MUTEX_CALL(unlock_mutex)(mutex->pfs_psi);
	}

	mutex_exit_func(mutex);
}

/******************************************************************//**
NOTE! Please use the corresponding macro mutex_exit(), not directly
this function!
A wrap function of mutex_exit_func() with peformance schema instrumentation.
Unlocks a priority mutex owned by the current thread. */
UNIV_INLINE
void
pfs_mutex_exit_func(
/*================*/
	ib_prio_mutex_t*	mutex)	/*!< in: pointer to mutex */
{
	if (mutex->base_mutex.pfs_psi != NULL) {
		PSI_MUTEX_CALL(unlock_mutex)(mutex->base_mutex.pfs_psi);
	}

	mutex_exit_func(mutex);
}


/******************************************************************//**
NOTE! Please use the corresponding macro mutex_create(), not directly
this function!
A wrapper function for mutex_create_func(), registers the mutex
with performance schema if "UNIV_PFS_MUTEX" is defined when
creating the mutex */
UNIV_INLINE
void
pfs_mutex_create_func(
/*==================*/
	mysql_pfs_key_t	key,		/*!< in: Performance Schema key */
	ib_mutex_t*	mutex,		/*!< in: pointer to memory */
# ifdef UNIV_DEBUG
#  ifdef UNIV_SYNC_DEBUG
	ulint		level,		/*!< in: level */
#  endif /* UNIV_SYNC_DEBUG */
# endif /* UNIV_DEBUG */
	const char*	cfile_name,	/*!< in: file name where created */
	ulint		cline,		/*!< in: file line where created */
	const char*	cmutex_name)	/*!< in: mutex name */
{
	mutex->pfs_psi = PSI_MUTEX_CALL(init_mutex)(key, mutex);

	mutex_create_func(mutex,
# ifdef UNIV_DEBUG
#  ifdef UNIV_SYNC_DEBUG
			  level,
#  endif /* UNIV_SYNC_DEBUG */
# endif /* UNIV_DEBUG */
			  cfile_name,
			  cline,
			  cmutex_name);
}

/******************************************************************//**
NOTE! Please use the corresponding macro mutex_create(), not directly
this function!
A wrapper function for mutex_create_func(), registers the mutex
with peformance schema if "UNIV_PFS_MUTEX" is defined when
creating the performance mutex */
UNIV_INLINE
void
pfs_mutex_create_func(
/*==================*/
	PSI_mutex_key		key,		/*!< in: Performance Schema
						key */
	ib_prio_mutex_t*	mutex,		/*!< in: pointer to memory */
# ifdef UNIV_DEBUG
#  ifdef UNIV_SYNC_DEBUG
	ulint			level,		/*!< in: level */
#  endif /* UNIV_SYNC_DEBUG */
# endif /* UNIV_DEBUG */
	const char*		cfile_name,	/*!< in: file name where
						created */
	ulint			cline,		/*!< in: file line where
						  created */
	const char*		cmutex_name)
{
	mutex->base_mutex.pfs_psi = PSI_MUTEX_CALL(init_mutex)(key, mutex);

	mutex_create_func(mutex,
# ifdef UNIV_DEBUG
#  ifdef UNIV_SYNC_DEBUG
			  level,
#  endif /* UNIV_SYNC_DEBUG */
# endif /* UNIV_DEBUG */
			  cfile_name,
			  cline,
			  cmutex_name);
}


/******************************************************************//**
NOTE! Please use the corresponding macro mutex_free(), not directly
this function!
Wrapper function for mutex_free_func(). Also destroys the performance
schema probes when freeing the mutex */
UNIV_INLINE
void
pfs_mutex_free_func(
/*================*/
	ib_mutex_t*	mutex)	/*!< in: mutex */
{
	if (mutex->pfs_psi != NULL) {
		PSI_MUTEX_CALL(destroy_mutex)(mutex->pfs_psi);
		mutex->pfs_psi = NULL;
	}

	mutex_free_func(mutex);
}

/******************************************************************//**
NOTE! Please use the corresponding macro mutex_free(), not directly
this function!
Wrapper function for mutex_free_func(). Also destroys the performance
schema probes when freeing the priority mutex */
UNIV_INLINE
void
pfs_mutex_free_func(
/*================*/
	ib_prio_mutex_t*	mutex)	/*!< in: mutex */
{
	if (mutex->base_mutex.pfs_psi != NULL) {
		PSI_MUTEX_CALL(destroy_mutex)(mutex->base_mutex.pfs_psi);
		mutex->base_mutex.pfs_psi = NULL;
	}

	mutex_free_func(mutex);
}


#endif /* UNIV_PFS_MUTEX */

#ifndef HAVE_ATOMIC_BUILTINS
/**********************************************************//**
Function that uses a mutex to decrement a variable atomically */
UNIV_INLINE
void
os_atomic_dec_ulint_func(
/*=====================*/
	ib_mutex_t*	mutex,		/*!< in: mutex guarding the dec */
	volatile ulint*	var,		/*!< in/out: variable to decrement */
	ulint		delta)		/*!< in: delta to decrement */
{
	mutex_enter(mutex);

	/* I don't think we will encounter a situation where
	this check will not be required. */
	ut_ad(*var >= delta);

	*var -= delta;

	mutex_exit(mutex);
}

/**********************************************************//**
Function that uses a mutex to increment a variable atomically */
UNIV_INLINE
void
os_atomic_inc_ulint_func(
/*=====================*/
	ib_mutex_t*	mutex,		/*!< in: mutex guarding the increment */
	volatile ulint*	var,		/*!< in/out: variable to increment */
	ulint		delta)		/*!< in: delta to increment */
{
	mutex_enter(mutex);

	*var += delta;

	mutex_exit(mutex);
}
#endif /* !HAVE_ATOMIC_BUILTINS */