mirror of
https://github.com/MariaDB/server.git
synced 2025-07-30 16:24:05 +03:00
Bug#51295 Build warnings in mdl.cc
Before this fix, the performance schema instrumentation in mdl.h / mdl.cc was incomplete, causing: - build warnings, - no data collection for the performance schema This fix: - added instrumentation helpers for the new preferred reader read write lock, mysql_prlock_* - implemented completely the performance schema instrumentation of mdl.h / mdl.cc
This commit is contained in:
@ -106,6 +106,22 @@ struct st_mysql_rwlock
|
||||
struct PSI_rwlock *m_psi;
|
||||
};
|
||||
|
||||
/**
|
||||
An instrumented prlock structure.
|
||||
@sa mysql_prlock_t
|
||||
*/
|
||||
struct st_mysql_prlock
|
||||
{
|
||||
/** The real prlock */
|
||||
rw_pr_lock_t m_prlock;
|
||||
/**
|
||||
The instrumentation hook.
|
||||
Note that this hook is not conditionally defined,
|
||||
for binary compatibility of the @c mysql_rwlock_t interface.
|
||||
*/
|
||||
struct PSI_rwlock *m_psi;
|
||||
};
|
||||
|
||||
/**
|
||||
Type of an instrumented rwlock.
|
||||
@c mysql_rwlock_t is a drop-in replacement for @c pthread_rwlock_t.
|
||||
@ -119,6 +135,20 @@ struct st_mysql_rwlock
|
||||
*/
|
||||
typedef struct st_mysql_rwlock mysql_rwlock_t;
|
||||
|
||||
/**
|
||||
Type of an instrumented prlock.
|
||||
A prlock is a read write lock that 'prefers readers' (pr).
|
||||
@c mysql_prlock_t is a drop-in replacement for @c rw_pr_lock_t.
|
||||
@sa mysql_prlock_init
|
||||
@sa mysql_prlock_rdlock
|
||||
@sa mysql_prlock_tryrdlock
|
||||
@sa mysql_prlock_wrlock
|
||||
@sa mysql_prlock_trywrlock
|
||||
@sa mysql_prlock_unlock
|
||||
@sa mysql_prlock_destroy
|
||||
*/
|
||||
typedef struct st_mysql_prlock mysql_prlock_t;
|
||||
|
||||
/**
|
||||
An instrumented cond structure.
|
||||
@sa mysql_cond_t
|
||||
@ -281,6 +311,19 @@ typedef struct st_mysql_cond mysql_cond_t;
|
||||
#define mysql_rwlock_init(K, RW) inline_mysql_rwlock_init(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_prlock_init(K, RW)
|
||||
Instrumented rw_pr_init.
|
||||
@c mysql_prlock_init is a replacement for @c rw_pr_init.
|
||||
@param K The PSI_rwlock_key for this instrumented prlock
|
||||
@param RW The prlock to initialize
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_prlock_init(K, RW) inline_mysql_prlock_init(K, RW)
|
||||
#else
|
||||
#define mysql_prlock_init(K, RW) inline_mysql_prlock_init(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_destroy(RW)
|
||||
Instrumented rwlock_destroy.
|
||||
@ -289,6 +332,14 @@ typedef struct st_mysql_cond mysql_cond_t;
|
||||
*/
|
||||
#define mysql_rwlock_destroy(RW) inline_mysql_rwlock_destroy(RW)
|
||||
|
||||
/**
|
||||
@def mysql_prlock_destroy(RW)
|
||||
Instrumented rw_pr_destroy.
|
||||
@c mysql_prlock_destroy is a drop-in replacement
|
||||
for @c rw_pr_destroy.
|
||||
*/
|
||||
#define mysql_prlock_destroy(RW) inline_mysql_prlock_destroy(RW)
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_rdlock(RW)
|
||||
Instrumented rwlock_rdlock.
|
||||
@ -303,6 +354,20 @@ typedef struct st_mysql_cond mysql_cond_t;
|
||||
inline_mysql_rwlock_rdlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_prlock_rdlock(RW)
|
||||
Instrumented rw_pr_rdlock.
|
||||
@c mysql_prlock_rdlock is a drop-in replacement
|
||||
for @c rw_pr_rdlock.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_prlock_rdlock(RW) \
|
||||
inline_mysql_prlock_rdlock(RW, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_prlock_rdlock(RW) \
|
||||
inline_mysql_prlock_rdlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_wrlock(RW)
|
||||
Instrumented rwlock_wrlock.
|
||||
@ -317,6 +382,20 @@ typedef struct st_mysql_cond mysql_cond_t;
|
||||
inline_mysql_rwlock_wrlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_prlock_wrlock(RW)
|
||||
Instrumented rw_pr_wrlock.
|
||||
@c mysql_prlock_wrlock is a drop-in replacement
|
||||
for @c rw_pr_wrlock.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_prlock_wrlock(RW) \
|
||||
inline_mysql_prlock_wrlock(RW, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_prlock_wrlock(RW) \
|
||||
inline_mysql_prlock_wrlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_tryrdlock(RW)
|
||||
Instrumented rwlock_tryrdlock.
|
||||
@ -331,6 +410,20 @@ typedef struct st_mysql_cond mysql_cond_t;
|
||||
inline_mysql_rwlock_tryrdlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_prlock_tryrdlock(RW)
|
||||
Instrumented rw_pr_tryrdlock.
|
||||
@c mysql_prlock_tryrdlock is a drop-in replacement
|
||||
for @c rw_pr_tryrdlock.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_prlock_tryrdlock(RW) \
|
||||
inline_mysql_prlock_tryrdlock(RW, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_prlock_tryrdlock(RW) \
|
||||
inline_mysql_prlock_tryrdlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_trywrlock(RW)
|
||||
Instrumented rwlock_trywrlock.
|
||||
@ -345,6 +438,20 @@ typedef struct st_mysql_cond mysql_cond_t;
|
||||
inline_mysql_rwlock_trywrlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_prlock_trywrlock(RW)
|
||||
Instrumented rw_pr_trywrlock.
|
||||
@c mysql_prlock_trywrlock is a drop-in replacement
|
||||
for @c rw_pr_trywrlock.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_prlock_trywrlock(RW) \
|
||||
inline_mysql_prlock_trywrlock(RW, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_prlock_trywrlock(RW) \
|
||||
inline_mysql_prlock_trywrlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_unlock(RW)
|
||||
Instrumented rwlock_unlock.
|
||||
@ -353,9 +460,17 @@ typedef struct st_mysql_cond mysql_cond_t;
|
||||
*/
|
||||
#define mysql_rwlock_unlock(RW) inline_mysql_rwlock_unlock(RW)
|
||||
|
||||
/**
|
||||
@def mysql_prlock_unlock(RW)
|
||||
Instrumented rw_pr_unlock.
|
||||
@c mysql_prlock_unlock is a drop-in replacement
|
||||
for @c rw_pr_unlock.
|
||||
*/
|
||||
#define mysql_prlock_unlock(RW) inline_mysql_prlock_unlock(RW)
|
||||
|
||||
/**
|
||||
@def mysql_cond_init(K, C, A)
|
||||
Instrumented rwlock_init.
|
||||
Instrumented cond_init.
|
||||
@c mysql_cond_init is a replacement for @c pthread_cond_init.
|
||||
@param C The cond to initialize
|
||||
@param K The PSI_cond_key for this instrumented cond
|
||||
@ -599,6 +714,21 @@ static inline int inline_mysql_rwlock_init(
|
||||
return my_rwlock_init(&that->m_rwlock, NULL);
|
||||
}
|
||||
|
||||
static inline int inline_mysql_prlock_init(
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
PSI_rwlock_key key,
|
||||
#endif
|
||||
mysql_prlock_t *that)
|
||||
{
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
that->m_psi= (PSI_server ? PSI_server->init_rwlock(key, &that->m_prlock)
|
||||
: NULL);
|
||||
#else
|
||||
that->m_psi= NULL;
|
||||
#endif
|
||||
return rw_pr_init(&that->m_prlock);
|
||||
}
|
||||
|
||||
static inline int inline_mysql_rwlock_destroy(
|
||||
mysql_rwlock_t *that)
|
||||
{
|
||||
@ -612,6 +742,19 @@ static inline int inline_mysql_rwlock_destroy(
|
||||
return rwlock_destroy(&that->m_rwlock);
|
||||
}
|
||||
|
||||
static inline int inline_mysql_prlock_destroy(
|
||||
mysql_prlock_t *that)
|
||||
{
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
PSI_server->destroy_rwlock(that->m_psi);
|
||||
that->m_psi= NULL;
|
||||
}
|
||||
#endif
|
||||
return rw_pr_destroy(&that->m_prlock);
|
||||
}
|
||||
|
||||
static inline int inline_mysql_rwlock_rdlock(
|
||||
mysql_rwlock_t *that
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
@ -638,6 +781,32 @@ static inline int inline_mysql_rwlock_rdlock(
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_prlock_rdlock(
|
||||
mysql_prlock_t *that
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
int result;
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
struct PSI_rwlock_locker *locker= NULL;
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
|
||||
PSI_RWLOCK_READLOCK);
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->start_rwlock_rdwait(locker, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
result= rw_pr_rdlock(&that->m_prlock);
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->end_rwlock_rdwait(locker, result);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_rwlock_wrlock(
|
||||
mysql_rwlock_t *that
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
@ -664,6 +833,32 @@ static inline int inline_mysql_rwlock_wrlock(
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_prlock_wrlock(
|
||||
mysql_prlock_t *that
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
int result;
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
struct PSI_rwlock_locker *locker= NULL;
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
|
||||
PSI_RWLOCK_WRITELOCK);
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->start_rwlock_wrwait(locker, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
result= rw_pr_wrlock(&that->m_prlock);
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->end_rwlock_wrwait(locker, result);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_rwlock_tryrdlock(
|
||||
mysql_rwlock_t *that
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
@ -690,6 +885,32 @@ static inline int inline_mysql_rwlock_tryrdlock(
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_prlock_tryrdlock(
|
||||
mysql_prlock_t *that
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
int result;
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
struct PSI_rwlock_locker *locker= NULL;
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
|
||||
PSI_RWLOCK_TRYREADLOCK);
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->start_rwlock_rdwait(locker, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
result= rw_pr_tryrdlock(&that->m_prlock);
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->end_rwlock_rdwait(locker, result);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_rwlock_trywrlock(
|
||||
mysql_rwlock_t *that
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
@ -716,6 +937,32 @@ static inline int inline_mysql_rwlock_trywrlock(
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_prlock_trywrlock(
|
||||
mysql_prlock_t *that
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
int result;
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
struct PSI_rwlock_locker *locker= NULL;
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
|
||||
PSI_RWLOCK_TRYWRITELOCK);
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->start_rwlock_wrwait(locker, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
result= rw_pr_trywrlock(&that->m_prlock);
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->end_rwlock_wrwait(locker, result);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_rwlock_unlock(
|
||||
mysql_rwlock_t *that)
|
||||
{
|
||||
@ -733,6 +980,23 @@ static inline int inline_mysql_rwlock_unlock(
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_prlock_unlock(
|
||||
mysql_prlock_t *that)
|
||||
{
|
||||
int result;
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
struct PSI_thread *thread;
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
thread= PSI_server->get_thread();
|
||||
if (likely(thread != NULL))
|
||||
PSI_server->unlock_rwlock(thread, that->m_psi);
|
||||
}
|
||||
#endif
|
||||
result= rw_pr_unlock(&that->m_prlock);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_cond_init(
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
PSI_cond_key key,
|
||||
|
@ -25,9 +25,10 @@ wait/synch/rwlock/sql/LOCK_system_variables_hash YES YES
|
||||
wait/synch/rwlock/sql/LOCK_sys_init_connect YES YES
|
||||
wait/synch/rwlock/sql/LOCK_sys_init_slave YES YES
|
||||
wait/synch/rwlock/sql/LOGGER::LOCK_logger YES YES
|
||||
wait/synch/rwlock/sql/MDL_context::waiting_for_lock YES YES
|
||||
wait/synch/rwlock/sql/MDL_lock::rwlock YES YES
|
||||
wait/synch/rwlock/sql/Query_cache_query::lock YES YES
|
||||
wait/synch/rwlock/sql/THR_LOCK_servers YES YES
|
||||
wait/synch/rwlock/sql/THR_LOCK_udf YES YES
|
||||
select * from performance_schema.SETUP_INSTRUMENTS
|
||||
where name like 'Wait/Synch/Cond/sql/%'
|
||||
and name not in (
|
||||
|
127
sql/mdl.cc
127
sql/mdl.cc
@ -19,6 +19,54 @@
|
||||
#include <hash.h>
|
||||
#include <mysqld_error.h>
|
||||
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
static PSI_mutex_key key_MDL_map_mutex;
|
||||
static PSI_mutex_key key_MDL_context_signal_mutex;
|
||||
|
||||
static PSI_mutex_info all_mdl_mutexes[]=
|
||||
{
|
||||
{ &key_MDL_map_mutex, "MDL_map::mutex", PSI_FLAG_GLOBAL},
|
||||
{ &key_MDL_context_signal_mutex, "MDL_context::signal", 0}
|
||||
};
|
||||
|
||||
static PSI_rwlock_key key_MDL_lock_rwlock;
|
||||
static PSI_rwlock_key key_MDL_context_waiting_for_rwlock;
|
||||
|
||||
static PSI_rwlock_info all_mdl_rwlocks[]=
|
||||
{
|
||||
{ &key_MDL_lock_rwlock, "MDL_lock::rwlock", 0},
|
||||
{ &key_MDL_context_waiting_for_rwlock, "MDL_context::waiting_for_lock", 0}
|
||||
};
|
||||
|
||||
static PSI_cond_key key_MDL_context_signal_cond;
|
||||
|
||||
static PSI_cond_info all_mdl_conds[]=
|
||||
{
|
||||
{ &key_MDL_context_signal_cond, "MDL_context::signal", 0}
|
||||
};
|
||||
|
||||
/**
|
||||
Initialise all the performance schema instrumentation points
|
||||
used by the MDL subsystem.
|
||||
*/
|
||||
static void init_mdl_psi_keys(void)
|
||||
{
|
||||
const char *category= "sql";
|
||||
int count;
|
||||
|
||||
if (PSI_server == NULL)
|
||||
return;
|
||||
|
||||
count= array_elements(all_mdl_mutexes);
|
||||
PSI_server->register_mutex(category, all_mdl_mutexes, count);
|
||||
|
||||
count= array_elements(all_mdl_rwlocks);
|
||||
PSI_server->register_rwlock(category, all_mdl_rwlocks, count);
|
||||
|
||||
count= array_elements(all_mdl_conds);
|
||||
PSI_server->register_cond(category, all_mdl_conds, count);
|
||||
}
|
||||
#endif /* HAVE_PSI_INTERFACE */
|
||||
|
||||
void notify_shared_lock(THD *thd, MDL_ticket *conflicting_ticket);
|
||||
|
||||
@ -178,7 +226,7 @@ public:
|
||||
If m_wrlock prefers readers (actually ignoring pending writers is
|
||||
enough) ctxA and ctxB will continue and no deadlock will occur.
|
||||
*/
|
||||
rw_pr_lock_t m_rwlock;
|
||||
mysql_prlock_t m_rwlock;
|
||||
|
||||
bool is_empty() const
|
||||
{
|
||||
@ -240,12 +288,12 @@ public:
|
||||
m_ref_release(0),
|
||||
m_is_destroyed(FALSE)
|
||||
{
|
||||
rw_pr_init(&m_rwlock);
|
||||
mysql_prlock_init(key_MDL_lock_rwlock, &m_rwlock);
|
||||
}
|
||||
|
||||
virtual ~MDL_lock()
|
||||
{
|
||||
rw_pr_destroy(&m_rwlock);
|
||||
mysql_prlock_destroy(&m_rwlock);
|
||||
}
|
||||
inline static void destroy(MDL_lock *lock);
|
||||
public:
|
||||
@ -368,6 +416,11 @@ void mdl_init()
|
||||
{
|
||||
DBUG_ASSERT(! mdl_initialized);
|
||||
mdl_initialized= TRUE;
|
||||
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
init_mdl_psi_keys();
|
||||
#endif
|
||||
|
||||
mdl_locks.init();
|
||||
}
|
||||
|
||||
@ -393,7 +446,7 @@ void mdl_destroy()
|
||||
|
||||
void MDL_map::init()
|
||||
{
|
||||
mysql_mutex_init(NULL /* pfs key */,&m_mutex, NULL);
|
||||
mysql_mutex_init(key_MDL_map_mutex, &m_mutex, NULL);
|
||||
my_hash_init(&m_locks, &my_charset_bin, 16 /* FIXME */, 0, 0,
|
||||
mdl_locks_key, 0, 0);
|
||||
}
|
||||
@ -507,7 +560,7 @@ bool MDL_map::move_from_hash_to_lock_mutex(MDL_lock *lock)
|
||||
lock->m_ref_usage++;
|
||||
mysql_mutex_unlock(&m_mutex);
|
||||
|
||||
rw_pr_wrlock(&lock->m_rwlock);
|
||||
mysql_prlock_wrlock(&lock->m_rwlock);
|
||||
lock->m_ref_release++;
|
||||
if (unlikely(lock->m_is_destroyed))
|
||||
{
|
||||
@ -522,7 +575,7 @@ bool MDL_map::move_from_hash_to_lock_mutex(MDL_lock *lock)
|
||||
*/
|
||||
uint ref_usage= lock->m_ref_usage;
|
||||
uint ref_release= lock->m_ref_release;
|
||||
rw_pr_unlock(&lock->m_rwlock);
|
||||
mysql_prlock_unlock(&lock->m_rwlock);
|
||||
if (ref_usage == ref_release)
|
||||
MDL_lock::destroy(lock);
|
||||
return TRUE;
|
||||
@ -565,7 +618,7 @@ void MDL_map::remove(MDL_lock *lock)
|
||||
lock->m_is_destroyed= TRUE;
|
||||
ref_usage= lock->m_ref_usage;
|
||||
ref_release= lock->m_ref_release;
|
||||
rw_pr_unlock(&lock->m_rwlock);
|
||||
mysql_prlock_unlock(&lock->m_rwlock);
|
||||
mysql_mutex_unlock(&m_mutex);
|
||||
if (ref_usage == ref_release)
|
||||
MDL_lock::destroy(lock);
|
||||
@ -586,9 +639,9 @@ MDL_context::MDL_context()
|
||||
m_deadlock_weight(0),
|
||||
m_signal(NO_WAKE_UP)
|
||||
{
|
||||
rw_pr_init(&m_waiting_for_lock);
|
||||
mysql_mutex_init(NULL /* pfs key */, &m_signal_lock, NULL);
|
||||
mysql_cond_init(NULL /* pfs key */, &m_signal_cond, NULL);
|
||||
mysql_prlock_init(key_MDL_context_waiting_for_rwlock, &m_waiting_for_lock);
|
||||
mysql_mutex_init(key_MDL_context_signal_mutex, &m_signal_lock, NULL);
|
||||
mysql_cond_init(key_MDL_context_signal_mutex, &m_signal_cond, NULL);
|
||||
}
|
||||
|
||||
|
||||
@ -608,7 +661,7 @@ void MDL_context::destroy()
|
||||
{
|
||||
DBUG_ASSERT(m_tickets.is_empty());
|
||||
|
||||
rw_pr_destroy(&m_waiting_for_lock);
|
||||
mysql_prlock_destroy(&m_waiting_for_lock);
|
||||
mysql_mutex_destroy(&m_signal_lock);
|
||||
mysql_cond_destroy(&m_signal_cond);
|
||||
}
|
||||
@ -1098,7 +1151,7 @@ MDL_lock::can_grant_lock(enum_mdl_type type_arg,
|
||||
|
||||
void MDL_lock::remove_ticket(Ticket_list MDL_lock::*list, MDL_ticket *ticket)
|
||||
{
|
||||
rw_pr_wrlock(&m_rwlock);
|
||||
mysql_prlock_wrlock(&m_rwlock);
|
||||
(this->*list).remove_ticket(ticket);
|
||||
if (is_empty())
|
||||
mdl_locks.remove(this);
|
||||
@ -1109,7 +1162,7 @@ void MDL_lock::remove_ticket(Ticket_list MDL_lock::*list, MDL_ticket *ticket)
|
||||
which now might be able to do it. Wake them up!
|
||||
*/
|
||||
wake_up_waiters();
|
||||
rw_pr_unlock(&m_rwlock);
|
||||
mysql_prlock_unlock(&m_rwlock);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1129,9 +1182,9 @@ bool MDL_lock::has_pending_conflicting_lock(enum_mdl_type type)
|
||||
|
||||
mysql_mutex_assert_not_owner(&LOCK_open);
|
||||
|
||||
rw_pr_rdlock(&m_rwlock);
|
||||
mysql_prlock_rdlock(&m_rwlock);
|
||||
result= (m_waiting.bitmap() & incompatible_granted_types_bitmap()[type]);
|
||||
rw_pr_unlock(&m_rwlock);
|
||||
mysql_prlock_unlock(&m_rwlock);
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -1325,7 +1378,7 @@ MDL_context::try_acquire_lock(MDL_request *mdl_request)
|
||||
{
|
||||
ticket->m_lock= lock;
|
||||
lock->m_granted.add_ticket(ticket);
|
||||
rw_pr_unlock(&lock->m_rwlock);
|
||||
mysql_prlock_unlock(&lock->m_rwlock);
|
||||
|
||||
m_tickets.push_front(ticket);
|
||||
|
||||
@ -1335,7 +1388,7 @@ MDL_context::try_acquire_lock(MDL_request *mdl_request)
|
||||
{
|
||||
/* We can't get here if we allocated a new lock. */
|
||||
DBUG_ASSERT(! lock->is_empty());
|
||||
rw_pr_unlock(&lock->m_rwlock);
|
||||
mysql_prlock_unlock(&lock->m_rwlock);
|
||||
MDL_ticket::destroy(ticket);
|
||||
}
|
||||
|
||||
@ -1376,9 +1429,9 @@ MDL_context::clone_ticket(MDL_request *mdl_request)
|
||||
ticket->m_lock= mdl_request->ticket->m_lock;
|
||||
mdl_request->ticket= ticket;
|
||||
|
||||
rw_pr_wrlock(&ticket->m_lock->m_rwlock);
|
||||
mysql_prlock_wrlock(&ticket->m_lock->m_rwlock);
|
||||
ticket->m_lock->m_granted.add_ticket(ticket);
|
||||
rw_pr_unlock(&ticket->m_lock->m_rwlock);
|
||||
mysql_prlock_unlock(&ticket->m_lock->m_rwlock);
|
||||
|
||||
m_tickets.push_front(ticket);
|
||||
|
||||
@ -1484,7 +1537,7 @@ bool MDL_context::acquire_lock_impl(MDL_request *mdl_request,
|
||||
if (ticket->is_upgradable_or_exclusive())
|
||||
lock->notify_shared_locks(this);
|
||||
|
||||
rw_pr_unlock(&lock->m_rwlock);
|
||||
mysql_prlock_unlock(&lock->m_rwlock);
|
||||
|
||||
set_deadlock_weight(mdl_request->get_deadlock_weight());
|
||||
will_wait_for(ticket);
|
||||
@ -1519,7 +1572,7 @@ bool MDL_context::acquire_lock_impl(MDL_request *mdl_request,
|
||||
my_error(ER_LOCK_WAIT_TIMEOUT, MYF(0));
|
||||
return TRUE;
|
||||
}
|
||||
rw_pr_wrlock(&lock->m_rwlock);
|
||||
mysql_prlock_wrlock(&lock->m_rwlock);
|
||||
}
|
||||
|
||||
lock->m_waiting.remove_ticket(ticket);
|
||||
@ -1529,7 +1582,7 @@ bool MDL_context::acquire_lock_impl(MDL_request *mdl_request,
|
||||
(*lock->cached_object_release_hook)(lock->cached_object);
|
||||
lock->cached_object= NULL;
|
||||
|
||||
rw_pr_unlock(&lock->m_rwlock);
|
||||
mysql_prlock_unlock(&lock->m_rwlock);
|
||||
|
||||
m_tickets.push_front(ticket);
|
||||
|
||||
@ -1674,7 +1727,7 @@ MDL_context::upgrade_shared_lock_to_exclusive(MDL_ticket *mdl_ticket,
|
||||
is_new_ticket= ! has_lock(mdl_svp, mdl_xlock_request.ticket);
|
||||
|
||||
/* Merge the acquired and the original lock. @todo: move to a method. */
|
||||
rw_pr_wrlock(&mdl_ticket->m_lock->m_rwlock);
|
||||
mysql_prlock_wrlock(&mdl_ticket->m_lock->m_rwlock);
|
||||
if (is_new_ticket)
|
||||
mdl_ticket->m_lock->m_granted.remove_ticket(mdl_xlock_request.ticket);
|
||||
/*
|
||||
@ -1686,7 +1739,7 @@ MDL_context::upgrade_shared_lock_to_exclusive(MDL_ticket *mdl_ticket,
|
||||
mdl_ticket->m_type= MDL_EXCLUSIVE;
|
||||
mdl_ticket->m_lock->m_granted.add_ticket(mdl_ticket);
|
||||
|
||||
rw_pr_unlock(&mdl_ticket->m_lock->m_rwlock);
|
||||
mysql_prlock_unlock(&mdl_ticket->m_lock->m_rwlock);
|
||||
|
||||
if (is_new_ticket)
|
||||
{
|
||||
@ -1704,7 +1757,7 @@ bool MDL_lock::find_deadlock(MDL_ticket *waiting_ticket,
|
||||
MDL_ticket *ticket;
|
||||
bool result= FALSE;
|
||||
|
||||
rw_pr_rdlock(&m_rwlock);
|
||||
mysql_prlock_rdlock(&m_rwlock);
|
||||
|
||||
Ticket_iterator granted_it(m_granted);
|
||||
Ticket_iterator waiting_it(m_waiting);
|
||||
@ -1756,7 +1809,7 @@ bool MDL_lock::find_deadlock(MDL_ticket *waiting_ticket,
|
||||
}
|
||||
|
||||
end:
|
||||
rw_pr_unlock(&m_rwlock);
|
||||
mysql_prlock_unlock(&m_rwlock);
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -1765,7 +1818,7 @@ bool MDL_context::find_deadlock(Deadlock_detection_context *deadlock_ctx)
|
||||
{
|
||||
bool result= FALSE;
|
||||
|
||||
rw_pr_rdlock(&m_waiting_for_lock);
|
||||
mysql_prlock_rdlock(&m_waiting_for_lock);
|
||||
|
||||
if (m_waiting_for)
|
||||
{
|
||||
@ -1794,14 +1847,14 @@ bool MDL_context::find_deadlock(Deadlock_detection_context *deadlock_ctx)
|
||||
deadlock_ctx->victim= this;
|
||||
else if (deadlock_ctx->victim->m_deadlock_weight >= m_deadlock_weight)
|
||||
{
|
||||
rw_pr_unlock(&deadlock_ctx->victim->m_waiting_for_lock);
|
||||
mysql_prlock_unlock(&deadlock_ctx->victim->m_waiting_for_lock);
|
||||
deadlock_ctx->victim= this;
|
||||
}
|
||||
else
|
||||
rw_pr_unlock(&m_waiting_for_lock);
|
||||
mysql_prlock_unlock(&m_waiting_for_lock);
|
||||
}
|
||||
else
|
||||
rw_pr_unlock(&m_waiting_for_lock);
|
||||
mysql_prlock_unlock(&m_waiting_for_lock);
|
||||
|
||||
return result;
|
||||
}
|
||||
@ -1827,7 +1880,7 @@ bool MDL_context::find_deadlock()
|
||||
if (deadlock_ctx.victim != this)
|
||||
{
|
||||
deadlock_ctx.victim->awake(VICTIM_WAKE_UP);
|
||||
rw_pr_unlock(&deadlock_ctx.victim->m_waiting_for_lock);
|
||||
mysql_prlock_unlock(&deadlock_ctx.victim->m_waiting_for_lock);
|
||||
/*
|
||||
After adding new arc to waiting graph we found that it participates
|
||||
in some loop (i.e. there is a deadlock). We decided to destroy this
|
||||
@ -1840,7 +1893,7 @@ bool MDL_context::find_deadlock()
|
||||
else
|
||||
{
|
||||
DBUG_ASSERT(&deadlock_ctx.victim->m_waiting_for_lock == &m_waiting_for_lock);
|
||||
rw_pr_unlock(&deadlock_ctx.victim->m_waiting_for_lock);
|
||||
mysql_prlock_unlock(&deadlock_ctx.victim->m_waiting_for_lock);
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
@ -1897,14 +1950,14 @@ MDL_context::wait_for_lock(MDL_request *mdl_request, ulong lock_wait_timeout)
|
||||
|
||||
if (lock->can_grant_lock(mdl_request->type, this))
|
||||
{
|
||||
rw_pr_unlock(&lock->m_rwlock);
|
||||
mysql_prlock_unlock(&lock->m_rwlock);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
MDL_ticket *pending_ticket;
|
||||
if (! (pending_ticket= MDL_ticket::create(this, mdl_request->type)))
|
||||
{
|
||||
rw_pr_unlock(&lock->m_rwlock);
|
||||
mysql_prlock_unlock(&lock->m_rwlock);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@ -1913,7 +1966,7 @@ MDL_context::wait_for_lock(MDL_request *mdl_request, ulong lock_wait_timeout)
|
||||
lock->m_waiting.add_ticket(pending_ticket);
|
||||
|
||||
wait_reset();
|
||||
rw_pr_unlock(&lock->m_rwlock);
|
||||
mysql_prlock_unlock(&lock->m_rwlock);
|
||||
|
||||
set_deadlock_weight(MDL_DEADLOCK_WEIGHT_DML);
|
||||
will_wait_for(pending_ticket);
|
||||
@ -2064,7 +2117,7 @@ void MDL_ticket::downgrade_exclusive_lock(enum_mdl_type type)
|
||||
if (m_type != MDL_EXCLUSIVE)
|
||||
return;
|
||||
|
||||
rw_pr_wrlock(&m_lock->m_rwlock);
|
||||
mysql_prlock_wrlock(&m_lock->m_rwlock);
|
||||
/*
|
||||
To update state of MDL_lock object correctly we need to temporarily
|
||||
exclude ticket from the granted queue and then include it back.
|
||||
@ -2073,7 +2126,7 @@ void MDL_ticket::downgrade_exclusive_lock(enum_mdl_type type)
|
||||
m_type= type;
|
||||
m_lock->m_granted.add_ticket(this);
|
||||
m_lock->wake_up_waiters();
|
||||
rw_pr_unlock(&m_lock->m_rwlock);
|
||||
mysql_prlock_unlock(&m_lock->m_rwlock);
|
||||
}
|
||||
|
||||
|
||||
|
10
sql/mdl.h
10
sql/mdl.h
@ -628,7 +628,7 @@ private:
|
||||
important as deadlock detector won't work correctly
|
||||
otherwise. @sa Comment for MDL_lock::m_rwlock.
|
||||
*/
|
||||
rw_pr_lock_t m_waiting_for_lock;
|
||||
mysql_prlock_t m_waiting_for_lock;
|
||||
MDL_ticket *m_waiting_for;
|
||||
uint m_deadlock_weight;
|
||||
/**
|
||||
@ -652,9 +652,9 @@ private:
|
||||
|
||||
void will_wait_for(MDL_ticket *pending_ticket)
|
||||
{
|
||||
rw_pr_wrlock(&m_waiting_for_lock);
|
||||
mysql_prlock_wrlock(&m_waiting_for_lock);
|
||||
m_waiting_for= pending_ticket;
|
||||
rw_pr_unlock(&m_waiting_for_lock);
|
||||
mysql_prlock_unlock(&m_waiting_for_lock);
|
||||
}
|
||||
|
||||
void set_deadlock_weight(uint weight)
|
||||
@ -670,9 +670,9 @@ private:
|
||||
|
||||
void stop_waiting()
|
||||
{
|
||||
rw_pr_wrlock(&m_waiting_for_lock);
|
||||
mysql_prlock_wrlock(&m_waiting_for_lock);
|
||||
m_waiting_for= NULL;
|
||||
rw_pr_unlock(&m_waiting_for_lock);
|
||||
mysql_prlock_unlock(&m_waiting_for_lock);
|
||||
}
|
||||
|
||||
void wait_reset()
|
||||
|
Reference in New Issue
Block a user