diff options
Diffstat (limited to 'storage/innobase/include/sync0rw.ic')
| -rw-r--r-- | storage/innobase/include/sync0rw.ic | 492 |
1 files changed, 353 insertions, 139 deletions
diff --git a/storage/innobase/include/sync0rw.ic b/storage/innobase/include/sync0rw.ic index 27970188165..f76473ed202 100644 --- a/storage/innobase/include/sync0rw.ic +++ b/storage/innobase/include/sync0rw.ic @@ -30,12 +30,13 @@ The read-write lock (for threads) Created 9/11/1995 Heikki Tuuri *******************************************************/ +#include "os0event.h" + /******************************************************************//** 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), +the function spins a preset time (controlled by srv_n_spin_wait_rounds), waiting for the lock before suspending the thread. */ -UNIV_INTERN void rw_lock_s_lock_spin( /*================*/ @@ -44,10 +45,9 @@ rw_lock_s_lock_spin( 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 +#ifdef UNIV_DEBUG /******************************************************************//** Inserts the debug information for an rw-lock. */ -UNIV_INTERN void rw_lock_add_debug_info( /*===================*/ @@ -58,18 +58,17 @@ rw_lock_add_debug_info( ulint line); /*!< in: line where requested */ /******************************************************************//** Removes a debug information struct for an rw-lock. */ -UNIV_INTERN 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 */ +#endif /* UNIV_DEBUG */ /********************************************************************//** Check if there are threads waiting for the rw-lock. -@return 1 if waiters, 0 otherwise */ +@return 1 if waiters, 0 otherwise */ UNIV_INLINE ulint rw_lock_get_waiters( @@ -118,7 +117,7 @@ rw_lock_reset_waiter_flag( /******************************************************************//** Returns the write-status of the lock - this function made more sense with the old rw_lock implementation. -@return RW_LOCK_NOT_LOCKED, RW_LOCK_EX, RW_LOCK_WAIT_EX */ +@return RW_LOCK_NOT_LOCKED, RW_LOCK_X, RW_LOCK_X_WAIT, RW_LOCK_SX */ UNIV_INLINE ulint rw_lock_get_writer( @@ -126,21 +125,31 @@ rw_lock_get_writer( const rw_lock_t* lock) /*!< in: rw-lock */ { lint lock_word = lock->lock_word; - if (lock_word > 0) { + + ut_ad(lock_word <= X_LOCK_DECR); + if (lock_word > X_LOCK_HALF_DECR) { /* return NOT_LOCKED in s-lock state, like the writer member of the old lock implementation. */ return(RW_LOCK_NOT_LOCKED); - } else if ((lock_word == 0) || (lock_word <= -X_LOCK_DECR)) { - return(RW_LOCK_EX); + } else if (lock_word > 0) { + /* sx-locked, no x-locks */ + return(RW_LOCK_SX); + } else if (lock_word == 0 + || lock_word == -X_LOCK_HALF_DECR + || lock_word <= -X_LOCK_DECR) { + /* x-lock with sx-lock is also treated as RW_LOCK_EX */ + return(RW_LOCK_X); } else { - ut_ad(lock_word > -X_LOCK_DECR); - return(RW_LOCK_WAIT_EX); + /* x-waiter with sx-lock is also treated as RW_LOCK_WAIT_EX + e.g. -X_LOCK_HALF_DECR < lock_word < 0 : without sx + -X_LOCK_DECR < lock_word < -X_LOCK_HALF_DECR : with sx */ + return(RW_LOCK_X_WAIT); } } /******************************************************************//** -Returns the number of readers. -@return number of readers */ +Returns the number of readers (s-locks). +@return number of readers */ UNIV_INLINE ulint rw_lock_get_reader_count( @@ -148,13 +157,28 @@ rw_lock_get_reader_count( const rw_lock_t* lock) /*!< in: rw-lock */ { lint lock_word = lock->lock_word; - if (lock_word > 0) { - /* s-locked, no x-waiters */ + ut_ad(lock_word <= X_LOCK_DECR); + + if (lock_word > X_LOCK_HALF_DECR) { + /* s-locked, no x-waiter */ return(X_LOCK_DECR - lock_word); - } else if (lock_word < 0 && lock_word > -X_LOCK_DECR) { - /* s-locked, with x-waiters */ + } else if (lock_word > 0) { + /* s-locked, with sx-locks only */ + return(X_LOCK_HALF_DECR - lock_word); + } else if (lock_word == 0) { + /* x-locked */ + return(0); + } else if (lock_word > -X_LOCK_HALF_DECR) { + /* s-locked, with x-waiter */ return((ulint)(-lock_word)); + } else if (lock_word == -X_LOCK_HALF_DECR) { + /* x-locked with sx-locks */ + return(0); + } else if (lock_word > -X_LOCK_DECR) { + /* s-locked, with x-waiter and sx-lock */ + return((ulint)(-(lock_word + X_LOCK_HALF_DECR))); } + /* no s-locks */ return(0); } @@ -167,12 +191,12 @@ rw_lock_get_mutex( { return(&(lock->mutex)); } -#endif +#endif /* INNODB_RW_LOCKS_USE_ATOMICS */ /******************************************************************//** 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. -@return value of writer_count */ +@return value of writer_count */ UNIV_INLINE ulint rw_lock_get_x_lock_count( @@ -180,10 +204,54 @@ rw_lock_get_x_lock_count( const rw_lock_t* lock) /*!< in: rw-lock */ { lint lock_copy = lock->lock_word; - if ((lock_copy != 0) && (lock_copy > -X_LOCK_DECR)) { + ut_ad(lock_copy <= X_LOCK_DECR); + + if (lock_copy == 0 || lock_copy == -X_LOCK_HALF_DECR) { + /* "1 x-lock" or "1 x-lock + sx-locks" */ + return(1); + } else if (lock_copy > -X_LOCK_DECR) { + /* s-locks, one or more sx-locks if > 0, or x-waiter if < 0 */ return(0); + } else if (lock_copy > -(X_LOCK_DECR + X_LOCK_HALF_DECR)) { + /* no s-lock, no sx-lock, 2 or more x-locks. + First 2 x-locks are set with -X_LOCK_DECR, + all other recursive x-locks are set with -1 */ + return(2 - (lock_copy + X_LOCK_DECR)); + } else { + /* no s-lock, 1 or more sx-lock, 2 or more x-locks. + First 2 x-locks are set with -(X_LOCK_DECR + X_LOCK_HALF_DECR), + all other recursive x-locks are set with -1 */ + return(2 - (lock_copy + X_LOCK_DECR + X_LOCK_HALF_DECR)); + } +} + +/******************************************************************//** +Returns the number of sx-lock for the lock. Does not reserve the lock +mutex, so the caller must be sure it is not changed during the call. +@return value of sx-lock count */ +UNIV_INLINE +ulint +rw_lock_get_sx_lock_count( +/*======================*/ + const rw_lock_t* lock) /*!< in: rw-lock */ +{ +#ifdef UNIV_DEBUG + lint lock_copy = lock->lock_word; + + ut_ad(lock_copy <= X_LOCK_DECR); + + while (lock_copy < 0) { + lock_copy += X_LOCK_DECR; } - return((lock_copy == 0) ? 1 : (2 - (lock_copy + X_LOCK_DECR))); + + if (lock_copy > 0 && lock_copy <= X_LOCK_HALF_DECR) { + return(lock->sx_recursive); + } + + return(0); +#else /* UNIV_DEBUG */ + return(lock->sx_recursive); +#endif /* UNIV_DEBUG */ } /******************************************************************//** @@ -192,34 +260,35 @@ one for systems supporting atomic operations, one for others. This does does not support recusive x-locks: they should be handled by the caller and need not be atomic since they are performed by the current lock holder. Returns true if the decrement was made, false if not. -@return TRUE if decr occurs */ +@return true if decr occurs */ UNIV_INLINE -ibool +bool rw_lock_lock_word_decr( /*===================*/ rw_lock_t* lock, /*!< in/out: rw-lock */ - ulint amount) /*!< in: amount to decrement */ + ulint amount, /*!< in: amount to decrement */ + lint threshold) /*!< in: threshold of judgement */ { #ifdef INNODB_RW_LOCKS_USE_ATOMICS lint local_lock_word; os_rmb; local_lock_word = lock->lock_word; - while (local_lock_word > 0) { + while (local_lock_word > threshold) { if (os_compare_and_swap_lint(&lock->lock_word, local_lock_word, local_lock_word - amount)) { - return(TRUE); + return(true); } local_lock_word = lock->lock_word; } - return(FALSE); + return(false); #else /* INNODB_RW_LOCKS_USE_ATOMICS */ - ibool success = FALSE; + bool success = false; mutex_enter(&(lock->mutex)); - if (lock->lock_word > 0) { + if (lock->lock_word > threshold) { lock->lock_word -= amount; - success = TRUE; + success = true; } mutex_exit(&(lock->mutex)); return(success); @@ -228,7 +297,7 @@ rw_lock_lock_word_decr( /******************************************************************//** Increments lock_word the specified amount and returns new value. -@return lock->lock_word after increment */ +@return lock->lock_word after increment */ UNIV_INLINE lint rw_lock_lock_word_incr( @@ -266,7 +335,7 @@ void rw_lock_set_writer_id_and_recursion_flag( /*=====================================*/ rw_lock_t* lock, /*!< in/out: lock to work on */ - ibool recursive) /*!< in: TRUE if recursion + bool recursive) /*!< in: true if recursion allowed */ { os_thread_id_t curr_thread = os_thread_get_curr_id(); @@ -300,7 +369,7 @@ rw_lock_set_writer_id_and_recursion_flag( /******************************************************************//** Low-level function which tries to lock an rw-lock in s-mode. Performs no spinning. -@return TRUE if success */ +@return TRUE if success */ UNIV_INLINE ibool rw_lock_s_lock_low( @@ -312,24 +381,25 @@ rw_lock_s_lock_low( const char* file_name, /*!< in: file name where lock requested */ ulint line) /*!< in: line where requested */ { - if (!rw_lock_lock_word_decr(lock, 1)) { + if (!rw_lock_lock_word_decr(lock, 1, 0)) { /* Locking did not succeed */ return(FALSE); } -#ifdef UNIV_SYNC_DEBUG - rw_lock_add_debug_info(lock, pass, RW_LOCK_SHARED, file_name, line); -#endif + ut_d(rw_lock_add_debug_info(lock, pass, RW_LOCK_S, file_name, line)); + /* These debugging values are not set safely: they may be incorrect or even refer to a line that is invalid for the file name. */ lock->last_s_file_name = file_name; lock->last_s_line = line; + /* if (srv_instrument_semaphores) { lock->thread_id = os_thread_get_curr_id(); lock->file_name = file_name; lock->line = line; } + */ return(TRUE); /* locking succeeded */ } @@ -338,7 +408,7 @@ rw_lock_s_lock_low( 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 +function spins a preset time (controlled by srv_n_spin_wait_rounds), waiting for the lock, before suspending the thread. */ UNIV_INLINE void @@ -361,20 +431,14 @@ rw_lock_s_lock_func( 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 */ - ut_ad(!rw_lock_own(lock, RW_LOCK_EX)); -#endif /* UNIV_SYNC_DEBUG */ + ut_ad(!rw_lock_own(lock, RW_LOCK_S)); /* see NOTE above */ + ut_ad(!rw_lock_own(lock, RW_LOCK_X)); - if (rw_lock_s_lock_low(lock, pass, file_name, line)) { + if (!rw_lock_s_lock_low(lock, pass, file_name, line)) { - return; /* Success */ - } else { /* Did not succeed, try spin wait */ rw_lock_s_lock_spin(lock, pass, file_name, line); - - return; } } @@ -382,7 +446,7 @@ rw_lock_s_lock_func( 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. -@return TRUE if success */ +@return TRUE if success */ UNIV_INLINE ibool rw_lock_x_lock_func_nowait( @@ -412,7 +476,7 @@ rw_lock_x_lock_func_nowait( To achieve this we load it before os_compare_and_swap_lint(), which implies full memory barrier in current implementation. */ if (success) { - rw_lock_set_writer_id_and_recursion_flag(lock, TRUE); + rw_lock_set_writer_id_and_recursion_flag(lock, true); } else if (local_recursive && os_thread_eq(lock->writer_thread, @@ -420,10 +484,15 @@ rw_lock_x_lock_func_nowait( /* Relock: this lock_word modification is safe since no other threads can modify (lock, unlock, or reserve) lock_word while there is an exclusive writer and this is the writer thread. */ - if (lock->lock_word == 0) { - lock->lock_word = -X_LOCK_DECR; - } else { + if (lock->lock_word == 0 || lock->lock_word == -X_LOCK_HALF_DECR) { + /* There are 1 x-locks */ + lock->lock_word -= X_LOCK_DECR; + } else if (lock->lock_word <= -X_LOCK_DECR) { + /* There are 2 or more x-locks */ lock->lock_word--; + } else { + /* Failure */ + return(FALSE); } /* Watch for too many recursive locks */ @@ -433,15 +502,16 @@ rw_lock_x_lock_func_nowait( /* Failure */ return(FALSE); } -#ifdef UNIV_SYNC_DEBUG - rw_lock_add_debug_info(lock, 0, RW_LOCK_EX, file_name, line); -#endif + ut_d(rw_lock_add_debug_info(lock, 0, RW_LOCK_X, file_name, line)); + + /* if (srv_instrument_semaphores) { lock->thread_id = os_thread_get_curr_id(); lock->file_name = file_name; lock->line = line; } + */ lock->last_x_file_name = file_name; lock->last_x_line = line; @@ -457,22 +527,21 @@ UNIV_INLINE void rw_lock_s_unlock_func( /*==================*/ -#ifdef UNIV_SYNC_DEBUG +#ifdef UNIV_DEBUG ulint pass, /*!< in: pass value; != 0, if the lock may have been passed to another thread to unlock */ -#endif +#endif /* UNIV_DEBUG */ rw_lock_t* lock) /*!< in/out: rw-lock */ { ut_ad(lock->lock_word > -X_LOCK_DECR); ut_ad(lock->lock_word != 0); ut_ad(lock->lock_word < X_LOCK_DECR); -#ifdef UNIV_SYNC_DEBUG - rw_lock_remove_debug_info(lock, pass, RW_LOCK_SHARED); -#endif + ut_d(rw_lock_remove_debug_info(lock, pass, RW_LOCK_S)); /* Increment lock_word to indicate 1 less reader */ - if (rw_lock_lock_word_incr(lock, 1) == 0) { + lint lock_word = rw_lock_lock_word_incr(lock, 1); + if (lock_word == 0 || lock_word == -X_LOCK_HALF_DECR) { /* wait_ex waiter exists. It may not be asleep, but we signal anyway. We do not wake other waiters, because they can't @@ -483,10 +552,6 @@ rw_lock_s_unlock_func( } ut_ad(rw_lock_validate(lock)); - -#ifdef UNIV_SYNC_PERF_STAT - rw_s_exit_count++; -#endif } /******************************************************************//** @@ -495,13 +560,14 @@ UNIV_INLINE void rw_lock_x_unlock_func( /*==================*/ -#ifdef UNIV_SYNC_DEBUG +#ifdef UNIV_DEBUG ulint pass, /*!< in: pass value; != 0, if the lock may have been passed to another thread to unlock */ -#endif +#endif /* UNIV_DEBUG */ rw_lock_t* lock) /*!< in/out: rw-lock */ { - ut_ad(lock->lock_word == 0 || lock->lock_word <= -X_LOCK_DECR); + ut_ad(lock->lock_word == 0 || lock->lock_word == -X_LOCK_HALF_DECR + || lock->lock_word <= -X_LOCK_DECR); /* lock->recursive flag also indicates if lock->writer_thread is valid or stale. If we are the last of the recursive callers @@ -514,22 +580,18 @@ rw_lock_x_unlock_func( lock->recursive = FALSE; } -#ifdef UNIV_SYNC_DEBUG - rw_lock_remove_debug_info(lock, pass, RW_LOCK_EX); -#endif + ut_d(rw_lock_remove_debug_info(lock, pass, RW_LOCK_X)); - ulint x_lock_incr; - if (lock->lock_word == 0) { - x_lock_incr = X_LOCK_DECR; - } else if (lock->lock_word == -X_LOCK_DECR) { - x_lock_incr = X_LOCK_DECR; - } else { - ut_ad(lock->lock_word < -X_LOCK_DECR); - x_lock_incr = 1; - } + if (lock->lock_word == 0 || lock->lock_word == -X_LOCK_HALF_DECR) { + /* There is 1 x-lock */ + /* atomic increment is needed, because it is last */ + if (rw_lock_lock_word_incr(lock, X_LOCK_DECR) <= 0) { + ut_error; + } - if (rw_lock_lock_word_incr(lock, x_lock_incr) == X_LOCK_DECR) { - /* Lock is now free. May have to signal read/write waiters. + /* This no longer has an X-lock but it may still have + an SX-lock. So it is now free for S-locks by other threads. + We need to signal read/write waiters. We do not need to signal wait_ex waiters, since they cannot exist when there is a writer. */ if (lock->waiters) { @@ -537,13 +599,68 @@ rw_lock_x_unlock_func( os_event_set(lock->event); sync_array_object_signalled(); } + } else if (lock->lock_word == -X_LOCK_DECR + || lock->lock_word == -(X_LOCK_DECR + X_LOCK_HALF_DECR)) { + /* There are 2 x-locks */ + lock->lock_word += X_LOCK_DECR; + } else { + /* There are more than 2 x-locks. */ + ut_ad(lock->lock_word < -X_LOCK_DECR); + lock->lock_word += 1; } ut_ad(rw_lock_validate(lock)); +} -#ifdef UNIV_SYNC_PERF_STAT - rw_x_exit_count++; -#endif +/******************************************************************//** +Releases a sx mode lock. */ +UNIV_INLINE +void +rw_lock_sx_unlock_func( +/*===================*/ +#ifdef UNIV_DEBUG + ulint pass, /*!< in: pass value; != 0, if the lock may have + been passed to another thread to unlock */ +#endif /* UNIV_DEBUG */ + rw_lock_t* lock) /*!< in/out: rw-lock */ +{ + ut_ad(rw_lock_get_sx_lock_count(lock)); + ut_ad(lock->sx_recursive > 0); + + --lock->sx_recursive; + + ut_d(rw_lock_remove_debug_info(lock, pass, RW_LOCK_SX)); + + if (lock->sx_recursive == 0) { + /* Last caller in a possible recursive chain. */ + if (lock->lock_word > 0) { + lock->recursive = FALSE; + UNIV_MEM_INVALID(&lock->writer_thread, + sizeof lock->writer_thread); + + if (rw_lock_lock_word_incr(lock, X_LOCK_HALF_DECR) + <= X_LOCK_HALF_DECR) { + ut_error; + } + /* Lock is now free. May have to signal read/write + waiters. We do not need to signal wait_ex waiters, + since they cannot exist when there is an sx-lock + holder. */ + if (lock->waiters) { + rw_lock_reset_waiter_flag(lock); + os_event_set(lock->event); + sync_array_object_signalled(); + } + } else { + /* still has x-lock */ + ut_ad(lock->lock_word == -X_LOCK_HALF_DECR + || lock->lock_word <= -(X_LOCK_DECR + + X_LOCK_HALF_DECR)); + lock->lock_word += X_LOCK_HALF_DECR; + } + } + + ut_ad(rw_lock_validate(lock)); } #ifdef UNIV_PFS_RWLOCK @@ -558,26 +675,24 @@ pfs_rw_lock_create_func( /*====================*/ mysql_pfs_key_t key, /*!< in: key registered with performance schema */ - rw_lock_t* lock, /*!< in: pointer to memory */ + rw_lock_t* lock, /*!< in/out: pointer to memory */ # ifdef UNIV_DEBUG -# ifdef UNIV_SYNC_DEBUG - ulint level, /*!< in: level */ -# endif /* UNIV_SYNC_DEBUG */ + latch_level_t level, /*!< in: level */ # endif /* UNIV_DEBUG */ const char* cmutex_name, /*!< in: mutex name */ const char* cfile_name, /*!< in: file name where created */ ulint cline) /*!< in: file line where created */ { + ut_d(new(lock) rw_lock_t()); + /* Initialize the rwlock for performance schema */ lock->pfs_psi = PSI_RWLOCK_CALL(init_rwlock)(key, lock); /* The actual function to initialize an rwlock */ rw_lock_create_func(lock, -# ifdef UNIV_DEBUG -# ifdef UNIV_SYNC_DEBUG +#ifdef UNIV_DEBUG level, -# endif /* UNIV_SYNC_DEBUG */ -# endif /* UNIV_DEBUG */ +#endif /* UNIV_DEBUG */ cmutex_name, cfile_name, cline); @@ -596,14 +711,17 @@ pfs_rw_lock_x_lock_func( const char* file_name,/*!< in: file name where lock requested */ ulint line) /*!< in: line where requested */ { - if (lock->pfs_psi != NULL) - { + if (lock->pfs_psi != NULL) { PSI_rwlock_locker* locker; PSI_rwlock_locker_state state; - /* Record the entry of rw x lock request in performance schema */ + /* Record the acquisition of a read-write lock in exclusive + mode in performance schema */ +/* MySQL 5.7 New PSI */ +#define PSI_RWLOCK_EXCLUSIVELOCK PSI_RWLOCK_WRITELOCK + locker = PSI_RWLOCK_CALL(start_rwlock_wrwait)( - &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK, + &state, lock->pfs_psi, PSI_RWLOCK_EXCLUSIVELOCK, file_name, static_cast<uint>(line)); rw_lock_x_lock_func( @@ -612,9 +730,7 @@ pfs_rw_lock_x_lock_func( if (locker != NULL) { PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, 0); } - } - else - { + } else { rw_lock_x_lock_func(lock, pass, file_name, line); } } @@ -623,7 +739,7 @@ Performance schema instrumented wrap function for rw_lock_x_lock_func_nowait() NOTE! Please use the corresponding macro rw_lock_x_lock_func(), not directly this function! -@return TRUE if success */ +@return TRUE if success */ UNIV_INLINE ibool pfs_rw_lock_x_lock_func_nowait( @@ -633,16 +749,18 @@ pfs_rw_lock_x_lock_func_nowait( requested */ ulint line) /*!< in: line where requested */ { - ibool ret; + ibool ret; - if (lock->pfs_psi != NULL) - { + if (lock->pfs_psi != NULL) { PSI_rwlock_locker* locker; - PSI_rwlock_locker_state state; + PSI_rwlock_locker_state state; - /* Record the entry of rw x lock request in performance schema */ + /* Record the acquisition of a read-write trylock in exclusive + mode in performance schema */ + +#define PSI_RWLOCK_TRYEXCLUSIVELOCK PSI_RWLOCK_TRYWRITELOCK locker = PSI_RWLOCK_CALL(start_rwlock_wrwait)( - &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK, + &state, lock->pfs_psi, PSI_RWLOCK_TRYEXCLUSIVELOCK, file_name, static_cast<uint>(line)); ret = rw_lock_x_lock_func_nowait(lock, file_name, line); @@ -651,9 +769,7 @@ pfs_rw_lock_x_lock_func_nowait( PSI_RWLOCK_CALL(end_rwlock_wrwait)( locker, static_cast<int>(ret)); } - } - else - { + } else { ret = rw_lock_x_lock_func_nowait(lock, file_name, line); } @@ -669,8 +785,7 @@ pfs_rw_lock_free_func( /*==================*/ rw_lock_t* lock) /*!< in: pointer to rw-lock */ { - if (lock->pfs_psi != NULL) - { + if (lock->pfs_psi != NULL) { PSI_RWLOCK_CALL(destroy_rwlock)(lock->pfs_psi); lock->pfs_psi = NULL; } @@ -693,14 +808,14 @@ pfs_rw_lock_s_lock_func( requested */ ulint line) /*!< in: line where requested */ { - if (lock->pfs_psi != NULL) - { + if (lock->pfs_psi != NULL) { PSI_rwlock_locker* locker; PSI_rwlock_locker_state state; +#define PSI_RWLOCK_SHAREDLOCK PSI_RWLOCK_READLOCK /* Instrumented to inform we are aquiring a shared rwlock */ locker = PSI_RWLOCK_CALL(start_rwlock_rdwait)( - &state, lock->pfs_psi, PSI_RWLOCK_READLOCK, + &state, lock->pfs_psi, PSI_RWLOCK_SHAREDLOCK, file_name, static_cast<uint>(line)); rw_lock_s_lock_func(lock, pass, file_name, line); @@ -708,19 +823,50 @@ pfs_rw_lock_s_lock_func( if (locker != NULL) { PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, 0); } - } - else - { + } else { rw_lock_s_lock_func(lock, pass, file_name, line); } +} +/******************************************************************//** +Performance schema instrumented wrap function for rw_lock_sx_lock_func() +NOTE! Please use the corresponding macro rw_lock_sx_lock(), not +directly this function! */ +UNIV_INLINE +void +pfs_rw_lock_sx_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 */ +{ + if (lock->pfs_psi != NULL) { + PSI_rwlock_locker* locker; + PSI_rwlock_locker_state state; + +#define PSI_RWLOCK_SHAREDEXCLUSIVELOCK PSI_RWLOCK_WRITELOCK + /* Instrumented to inform we are aquiring a shared rwlock */ + locker = PSI_RWLOCK_CALL(start_rwlock_wrwait)( + &state, lock->pfs_psi, PSI_RWLOCK_SHAREDEXCLUSIVELOCK, + file_name, static_cast<uint>(line)); - return; + rw_lock_sx_lock_func(lock, pass, file_name, line); + + if (locker != NULL) { + PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, 0); + } + } else { + rw_lock_sx_lock_func(lock, pass, file_name, line); + } } /******************************************************************//** Performance schema instrumented wrap function for rw_lock_s_lock_func() NOTE! Please use the corresponding macro rw_lock_s_lock(), not directly this function! -@return TRUE if success */ +@return TRUE if success */ UNIV_INLINE ibool pfs_rw_lock_s_lock_low( @@ -732,16 +878,16 @@ pfs_rw_lock_s_lock_low( const char* file_name, /*!< in: file name where lock requested */ ulint line) /*!< in: line where requested */ { - ibool ret; + ibool ret; - if (lock->pfs_psi != NULL) - { + if (lock->pfs_psi != NULL) { PSI_rwlock_locker* locker; PSI_rwlock_locker_state state; +#define PSI_RWLOCK_TRYSHAREDLOCK PSI_RWLOCK_TRYREADLOCK /* Instrumented to inform we are aquiring a shared rwlock */ locker = PSI_RWLOCK_CALL(start_rwlock_rdwait)( - &state, lock->pfs_psi, PSI_RWLOCK_READLOCK, + &state, lock->pfs_psi, PSI_RWLOCK_TRYSHAREDLOCK, file_name, static_cast<uint>(line)); ret = rw_lock_s_lock_low(lock, pass, file_name, line); @@ -750,15 +896,54 @@ pfs_rw_lock_s_lock_low( PSI_RWLOCK_CALL(end_rwlock_rdwait)( locker, static_cast<int>(ret)); } - } - else - { + } else { ret = rw_lock_s_lock_low(lock, pass, file_name, line); } return(ret); } +/******************************************************************//** +Performance schema instrumented wrap function for rw_lock_sx_lock_nowait() +NOTE! Please use the corresponding macro, not +directly this function! +@return TRUE if success */ +UNIV_INLINE +ibool +pfs_rw_lock_sx_lock_low( +/*====================*/ + 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 */ +{ + ibool ret; + if (lock->pfs_psi != NULL) { + PSI_rwlock_locker* locker; + PSI_rwlock_locker_state state; + +#define PSI_RWLOCK_TRYSHAREDEXCLUSIVELOCK PSI_RWLOCK_TRYWRITELOCK + /* Instrumented to inform we are aquiring a shared + exclusive rwlock */ + locker = PSI_RWLOCK_CALL(start_rwlock_rdwait)( + &state, lock->pfs_psi, + PSI_RWLOCK_TRYSHAREDEXCLUSIVELOCK, + file_name, static_cast<uint>(line)); + + ret = rw_lock_sx_lock_low(lock, pass, file_name, line); + + if (locker != NULL) { + PSI_RWLOCK_CALL(end_rwlock_rdwait)( + locker, static_cast<int>(ret)); + } + } else { + ret = rw_lock_sx_lock_low(lock, pass, file_name, line); + } + + return(ret); +} /******************************************************************//** Performance schema instrumented wrap function for rw_lock_x_unlock_func() NOTE! Please use the corresponding macro rw_lock_x_unlock(), not directly @@ -767,21 +952,49 @@ UNIV_INLINE void pfs_rw_lock_x_unlock_func( /*======================*/ -#ifdef UNIV_SYNC_DEBUG +#ifdef UNIV_DEBUG ulint pass, /*!< in: pass value; != 0, if the lock may have been passed to another thread to unlock */ -#endif +#endif /* UNIV_DEBUG */ rw_lock_t* lock) /*!< in/out: rw-lock */ { /* Inform performance schema we are unlocking the lock */ - if (lock->pfs_psi != NULL) + if (lock->pfs_psi != NULL) { PSI_RWLOCK_CALL(unlock_rwlock)(lock->pfs_psi); + } rw_lock_x_unlock_func( -#ifdef UNIV_SYNC_DEBUG +#ifdef UNIV_DEBUG pass, -#endif +#endif /* UNIV_DEBUG */ + lock); +} + +/******************************************************************//** +Performance schema instrumented wrap function for rw_lock_sx_unlock_func() +NOTE! Please use the corresponding macro rw_lock_sx_unlock(), not directly +this function! */ +UNIV_INLINE +void +pfs_rw_lock_sx_unlock_func( +/*======================*/ +#ifdef UNIV_DEBUG + ulint pass, /*!< in: pass value; != 0, if the + lock may have been passed to another + thread to unlock */ +#endif /* UNIV_DEBUG */ + rw_lock_t* lock) /*!< in/out: rw-lock */ +{ + /* Inform performance schema we are unlocking the lock */ + if (lock->pfs_psi != NULL) { + PSI_RWLOCK_CALL(unlock_rwlock)(lock->pfs_psi); + } + + rw_lock_sx_unlock_func( +#ifdef UNIV_DEBUG + pass, +#endif /* UNIV_DEBUG */ lock); } @@ -793,21 +1006,22 @@ UNIV_INLINE void pfs_rw_lock_s_unlock_func( /*======================*/ -#ifdef UNIV_SYNC_DEBUG +#ifdef UNIV_DEBUG ulint pass, /*!< in: pass value; != 0, if the lock may have been passed to another thread to unlock */ -#endif +#endif /* UNIV_DEBUG */ rw_lock_t* lock) /*!< in/out: rw-lock */ { /* Inform performance schema we are unlocking the lock */ - if (lock->pfs_psi != NULL) + if (lock->pfs_psi != NULL) { PSI_RWLOCK_CALL(unlock_rwlock)(lock->pfs_psi); + } rw_lock_s_unlock_func( -#ifdef UNIV_SYNC_DEBUG +#ifdef UNIV_DEBUG pass, -#endif +#endif /* UNIV_DEBUG */ lock); } |