diff options
Diffstat (limited to 'storage/innobase/include/os0sync.ic')
| -rw-r--r-- | storage/innobase/include/os0sync.ic | 198 |
1 files changed, 187 insertions, 11 deletions
diff --git a/storage/innobase/include/os0sync.ic b/storage/innobase/include/os0sync.ic index c33f13aaad6..0d907b31366 100644 --- a/storage/innobase/include/os0sync.ic +++ b/storage/innobase/include/os0sync.ic @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved. +Copyright (c) 1995, 2011, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -11,8 +11,8 @@ 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 +this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA *****************************************************************************/ @@ -36,14 +36,10 @@ os_fast_mutex_trylock( /*==================*/ os_fast_mutex_t* fast_mutex) /*!< in: mutex to acquire */ { -#ifdef __WIN__ - if (TryEnterCriticalSection(fast_mutex)) { - - return(0); - } else { + fast_mutex_t* mutex = &fast_mutex->mutex; - return(1); - } +#ifdef __WIN__ + return(!TryEnterCriticalSection(mutex)); #else /* NOTE that the MySQL my_pthread.h redefines pthread_mutex_trylock so that it returns 0 on success. In the operating system @@ -51,6 +47,186 @@ os_fast_mutex_trylock( returns 1 on success (but MySQL remaps that to 0), while Linux, FreeBSD, Solaris, AIX, Tru64 Unix, HP-UX-11.0 return 0 on success. */ - return((ulint) pthread_mutex_trylock(fast_mutex)); + return((ulint) pthread_mutex_trylock(mutex)); +#endif +} + +#ifdef UNIV_PFS_MUTEX +/*********************************************************//** +NOTE! Please use the corresponding macro os_fast_mutex_init(), not directly +this function! +A wrapper function for os_fast_mutex_init_func(). Initializes an operating +system fast mutex semaphore. */ +UNIV_INLINE +void +pfs_os_fast_mutex_init( +/*===================*/ + PSI_mutex_key key, /*!< in: Performance Schema + key */ + os_fast_mutex_t* fast_mutex) /*!< out: fast mutex */ +{ +#ifdef HAVE_PSI_MUTEX_INTERFACE + fast_mutex->pfs_psi = PSI_CALL(init_mutex)(key, &fast_mutex->mutex); +#else + fast_mutex->pfs_psi = NULL; +#endif + + os_fast_mutex_init_func(&fast_mutex->mutex); +} +/******************************************************************//** +NOTE! Please use the corresponding macro os_fast_mutex_free(), not directly +this function! +Wrapper function for pfs_os_fast_mutex_free(). Also destroys the performance +schema probes when freeing the mutex */ +UNIV_INLINE +void +pfs_os_fast_mutex_free( +/*===================*/ + os_fast_mutex_t* fast_mutex) /*!< in/out: mutex */ +{ +#ifdef HAVE_PSI_MUTEX_INTERFACE + if (fast_mutex->pfs_psi != NULL) + PSI_CALL(destroy_mutex)(fast_mutex->pfs_psi); #endif + fast_mutex->pfs_psi = NULL; + + os_fast_mutex_free_func(&fast_mutex->mutex); } +/**********************************************************//** +NOTE! Please use the corresponding macro os_fast_mutex_lock, not directly +this function! +Wrapper function of os_fast_mutex_lock_func. Acquires ownership of a fast +mutex. */ +UNIV_INLINE +void +pfs_os_fast_mutex_lock( +/*===================*/ + os_fast_mutex_t* fast_mutex, /*!< in/out: mutex to acquire */ + const char* file_name, /*!< in: file name where + locked */ + ulint line) /*!< in: line where locked */ +{ +#ifdef HAVE_PSI_MUTEX_INTERFACE + if (fast_mutex->pfs_psi != NULL) + { + PSI_mutex_locker* locker; + PSI_mutex_locker_state state; + + locker = PSI_CALL(start_mutex_wait)(&state, fast_mutex->pfs_psi, + PSI_MUTEX_LOCK, file_name, line); + + os_fast_mutex_lock_func(&fast_mutex->mutex); + + if (locker != NULL) + PSI_CALL(end_mutex_wait)(locker, 0); + } + else +#endif + { + os_fast_mutex_lock_func(&fast_mutex->mutex); + } + + return; +} +/**********************************************************//** +NOTE! Please use the corresponding macro os_fast_mutex_unlock, not directly +this function! +Wrapper function of os_fast_mutex_unlock_func. Releases ownership of a +fast mutex. */ +UNIV_INLINE +void +pfs_os_fast_mutex_unlock( +/*=====================*/ + os_fast_mutex_t* fast_mutex) /*!< in/out: mutex to release */ +{ +#ifdef HAVE_PSI_MUTEX_INTERFACE + if (fast_mutex->pfs_psi != NULL) + PSI_CALL(unlock_mutex)(fast_mutex->pfs_psi); +#endif + + os_fast_mutex_unlock_func(&fast_mutex->mutex); +} +#endif /* UNIV_PFS_MUTEX */ + +#ifdef HAVE_WINDOWS_ATOMICS + +/* Use inline functions to make 64 and 32 bit versions of windows atomic +functions so that typecasts are evaluated at compile time. Take advantage +that lint is either __int64 or long int and windows atomic functions work +on __int64 and LONG */ + +/**********************************************************//** +Atomic compare and exchange of unsigned integers. +@return value found before the exchange. +If it is not equal to old_value the exchange did not happen. */ +UNIV_INLINE +lint +win_cmp_and_xchg_lint( +/*==================*/ + volatile lint* ptr, /*!< in/out: source/destination */ + lint new_val, /*!< in: exchange value */ + lint old_val) /*!< in: value to compare to */ +{ +# ifdef _WIN64 + return(InterlockedCompareExchange64(ptr, new_val, old_val)); +# else + return(InterlockedCompareExchange(ptr, new_val, old_val)); +# endif +} + +/**********************************************************//** +Atomic addition of signed integers. +@return Initial value of the variable pointed to by ptr */ +UNIV_INLINE +lint +win_xchg_and_add( +/*=============*/ + volatile lint* ptr, /*!< in/out: address of destination */ + lint val) /*!< in: number to be added */ +{ +#ifdef _WIN64 + return(InterlockedExchangeAdd64(ptr, val)); +#else + return(InterlockedExchangeAdd(ptr, val)); +#endif +} + +/**********************************************************//** +Atomic compare and exchange of unsigned integers. +@return value found before the exchange. +If it is not equal to old_value the exchange did not happen. */ +UNIV_INLINE +ulint +win_cmp_and_xchg_ulint( +/*===================*/ + volatile ulint* ptr, /*!< in/out: source/destination */ + ulint new_val, /*!< in: exchange value */ + ulint old_val) /*!< in: value to compare to */ +{ + return((ulint) win_cmp_and_xchg_lint( + (volatile lint*) ptr, + (lint) new_val, + (lint) old_val)); +} + +/**********************************************************//** +Atomic compare and exchange of 32-bit unsigned integers. +@return value found before the exchange. +If it is not equal to old_value the exchange did not happen. */ +UNIV_INLINE +DWORD +win_cmp_and_xchg_dword( +/*===================*/ + volatile DWORD* ptr, /*!< in/out: source/destination */ + DWORD new_val, /*!< in: exchange value */ + DWORD old_val) /*!< in: value to compare to */ +{ + ut_ad(sizeof(DWORD) == sizeof(LONG)); /* We assume this. */ + return(InterlockedCompareExchange( + (volatile LONG*) ptr, + (LONG) new_val, + (LONG) old_val)); +} + +#endif /* HAVE_WINDOWS_ATOMICS */ + |