mirror of
https://github.com/MariaDB/server.git
synced 2025-07-29 05:21:33 +03:00
WL#2360 Performance schema
Part 1: Instrumentation interface
This commit is contained in:
Marc Alff
1398
include/mysql/psi/mysql_file.h
Normal file
1398
include/mysql/psi/mysql_file.h
Normal file
File diff suppressed because it is too large
Load Diff
884
include/mysql/psi/mysql_thread.h
Normal file
884
include/mysql/psi/mysql_thread.h
Normal file
@ -0,0 +1,884 @@
|
||||
/* Copyright (C) 2008-2009 Sun Microsystems, Inc
|
||||
|
||||
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 */
|
||||
|
||||
#ifndef MYSQL_THREAD_H
|
||||
#define MYSQL_THREAD_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_thread.h
|
||||
Instrumentation helpers for mysys threads, mutexes,
|
||||
read write locks and conditions.
|
||||
This header file provides the necessary declarations
|
||||
to use the mysys thread API with the performance schema instrumentation.
|
||||
In some compilers (SunStudio), 'static inline' functions, when declared
|
||||
but not used, are not optimized away (because they are unused) by default,
|
||||
so that including a static inline function from a header file does
|
||||
create unwanted dependencies, causing unresolved symbols at link time.
|
||||
Other compilers, like gcc, optimize these dependencies by default.
|
||||
|
||||
Since the instrumented APIs declared here are wrapper on top
|
||||
of my_pthread / safemutex / etc APIs,
|
||||
including mysql/psi/mysql_thread.h assumes that
|
||||
the dependency on my_pthread and safemutex already exists.
|
||||
*/
|
||||
/*
|
||||
Note: there are several orthogonal dimensions here.
|
||||
|
||||
Dimension 1: Instrumentation
|
||||
HAVE_PSI_INTERFACE is defined when the instrumentation is compiled in.
|
||||
This may happen both in debug or production builds.
|
||||
|
||||
Dimension 2: Debug
|
||||
SAFE_MUTEX is defined when debug is compiled in.
|
||||
This may happen both with and without instrumentation.
|
||||
|
||||
Dimension 3: Platform
|
||||
Mutexes are implemented with one of:
|
||||
- the pthread library
|
||||
- fast mutexes
|
||||
- window apis
|
||||
This is implemented by various macro definitions in my_pthread.h
|
||||
|
||||
This causes complexity with '#ifdef'-ery that can't be avoided.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
/**
|
||||
@defgroup Thread_instrumentation Thread Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
An instrumented mutex structure.
|
||||
@sa mysql_mutex_t
|
||||
*/
|
||||
struct st_mysql_mutex
|
||||
{
|
||||
/** The real mutex. */
|
||||
pthread_mutex_t m_mutex;
|
||||
/**
|
||||
The instrumentation hook.
|
||||
Note that this hook is not conditionally defined,
|
||||
for binary compatibility of the @c mysql_mutex_t interface.
|
||||
*/
|
||||
struct PSI_mutex *m_psi;
|
||||
};
|
||||
|
||||
/**
|
||||
Type of an instrumented mutex.
|
||||
@c mysql_mutex_t is a drop-in replacement for @c pthread_mutex_t.
|
||||
@sa mysql_mutex_assert_owner
|
||||
@sa mysql_mutex_assert_not_owner
|
||||
@sa mysql_mutex_init
|
||||
@sa mysql_mutex_lock
|
||||
@sa mysql_mutex_unlock
|
||||
@sa mysql_mutex_destroy
|
||||
*/
|
||||
typedef struct st_mysql_mutex mysql_mutex_t;
|
||||
|
||||
/**
|
||||
An instrumented rwlock structure.
|
||||
@sa mysql_rwlock_t
|
||||
*/
|
||||
struct st_mysql_rwlock
|
||||
{
|
||||
/** The real rwlock */
|
||||
rw_lock_t m_rwlock;
|
||||
/**
|
||||
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.
|
||||
@sa mysql_rwlock_init
|
||||
@sa mysql_rwlock_rdlock
|
||||
@sa mysql_rwlock_tryrdlock
|
||||
@sa mysql_rwlock_wrlock
|
||||
@sa mysql_rwlock_trywrlock
|
||||
@sa mysql_rwlock_unlock
|
||||
@sa mysql_rwlock_destroy
|
||||
*/
|
||||
typedef struct st_mysql_rwlock mysql_rwlock_t;
|
||||
|
||||
/**
|
||||
An instrumented cond structure.
|
||||
@sa mysql_cond_t
|
||||
*/
|
||||
struct st_mysql_cond
|
||||
{
|
||||
/** The real condition */
|
||||
pthread_cond_t m_cond;
|
||||
/**
|
||||
The instrumentation hook.
|
||||
Note that this hook is not conditionally defined,
|
||||
for binary compatibility of the @c mysql_cond_t interface.
|
||||
*/
|
||||
struct PSI_cond *m_psi;
|
||||
};
|
||||
|
||||
/**
|
||||
Type of an instrumented condition.
|
||||
@c mysql_cond_t is a drop-in replacement for @c pthread_cond_t.
|
||||
@sa mysql_cond_init
|
||||
@sa mysql_cond_wait
|
||||
@sa mysql_cond_timedwait
|
||||
@sa mysql_cond_signal
|
||||
@sa mysql_cond_broadcast
|
||||
@sa mysql_cond_destroy
|
||||
*/
|
||||
typedef struct st_mysql_cond mysql_cond_t;
|
||||
|
||||
/*
|
||||
Consider the following code:
|
||||
static inline void foo() { bar(); }
|
||||
when foo() is never called.
|
||||
|
||||
With gcc, foo() is a local static function, so the dependencies
|
||||
are optimized away at compile time, and there is no dependency on bar().
|
||||
With other compilers (HP, Sun Studio), the function foo() implementation
|
||||
is compiled, and bar() needs to be present to link.
|
||||
|
||||
Due to the existing header dependencies in MySQL code, this header file
|
||||
is sometime used when it is not needed, which in turn cause link failures
|
||||
on some platforms.
|
||||
The proper fix would be to cut these extra dependencies in the calling code.
|
||||
DISABLE_MYSQL_THREAD_H is a work around to limit dependencies.
|
||||
*/
|
||||
#ifndef DISABLE_MYSQL_THREAD_H
|
||||
|
||||
/**
|
||||
@def mysql_mutex_assert_owner(M)
|
||||
Wrapper, to use safe_mutex_assert_owner with instrumented mutexes.
|
||||
@c mysql_mutex_assert_owner is a drop-in replacement
|
||||
for @c safe_mutex_assert_owner.
|
||||
*/
|
||||
#define mysql_mutex_assert_owner(M) \
|
||||
safe_mutex_assert_owner(&(M)->m_mutex)
|
||||
|
||||
/**
|
||||
@def mysql_mutex_assert_not_owner(M)
|
||||
Wrapper, to use safe_mutex_assert_not_owner with instrumented mutexes.
|
||||
@c mysql_mutex_assert_not_owner is a drop-in replacement
|
||||
for @c safe_mutex_assert_not_owner.
|
||||
*/
|
||||
#define mysql_mutex_assert_not_owner(M) \
|
||||
safe_mutex_assert_not_owner(&(M)->m_mutex)
|
||||
|
||||
/**
|
||||
@def mysql_mutex_init(K, M, A)
|
||||
Instrumented mutex_init.
|
||||
@c mysql_mutex_init is a replacement for @c pthread_mutex_init.
|
||||
@param K The PSI_mutex_key for this instrumented mutex
|
||||
@param M The mutex to initialize
|
||||
@param A Mutex attributes
|
||||
*/
|
||||
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#ifdef SAFE_MUTEX
|
||||
#define mysql_mutex_init(K, M, A) \
|
||||
inline_mysql_mutex_init(K, M, A, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_mutex_init(K, M, A) \
|
||||
inline_mysql_mutex_init(K, M, A)
|
||||
#endif
|
||||
#else
|
||||
#ifdef SAFE_MUTEX
|
||||
#define mysql_mutex_init(K, M, A) \
|
||||
inline_mysql_mutex_init(M, A, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_mutex_init(K, M, A) \
|
||||
inline_mysql_mutex_init(M, A)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_mutex_destroy(M)
|
||||
Instrumented mutex_destroy.
|
||||
@c mysql_mutex_destroy is a drop-in replacement
|
||||
for @c pthread_mutex_destroy.
|
||||
*/
|
||||
#ifdef SAFE_MUTEX
|
||||
#define mysql_mutex_destroy(M) \
|
||||
inline_mysql_mutex_destroy(M, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_mutex_destroy(M) \
|
||||
inline_mysql_mutex_destroy(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_mutex_lock(M)
|
||||
Instrumented mutex_lock.
|
||||
@c mysql_mutex_lock is a drop-in replacement for @c pthread_mutex_lock.
|
||||
@param M The mutex to lock
|
||||
*/
|
||||
|
||||
#if defined(SAFE_MUTEX) || defined (HAVE_PSI_INTERFACE)
|
||||
#define mysql_mutex_lock(M) \
|
||||
inline_mysql_mutex_lock(M, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_mutex_lock(M) \
|
||||
inline_mysql_mutex_lock(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_mutex_trylock(M)
|
||||
Instrumented mutex_lock.
|
||||
@c mysql_mutex_trylock is a drop-in replacement
|
||||
for @c pthread_mutex_trylock.
|
||||
*/
|
||||
|
||||
#if defined(SAFE_MUTEX) || defined (HAVE_PSI_INTERFACE)
|
||||
#define mysql_mutex_trylock(M) \
|
||||
inline_mysql_mutex_trylock(M, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_mutex_trylock(M) \
|
||||
inline_mysql_mutex_trylock(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_mutex_unlock(M)
|
||||
Instrumented mutex_unlock.
|
||||
@c mysql_mutex_unlock is a drop-in replacement for @c pthread_mutex_unlock.
|
||||
*/
|
||||
#ifdef SAFE_MUTEX
|
||||
#define mysql_mutex_unlock(M) \
|
||||
inline_mysql_mutex_unlock(M, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_mutex_unlock(M) \
|
||||
inline_mysql_mutex_unlock(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_init(K, RW)
|
||||
Instrumented rwlock_init.
|
||||
@c mysql_rwlock_init is a replacement for @c pthread_rwlock_init.
|
||||
Note that pthread_rwlockattr_t is not supported in MySQL.
|
||||
@param K The PSI_rwlock_key for this instrumented rwlock
|
||||
@param RW The rwlock to initialize
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_rwlock_init(K, RW) inline_mysql_rwlock_init(K, RW)
|
||||
#else
|
||||
#define mysql_rwlock_init(K, RW) inline_mysql_rwlock_init(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_destroy(RW)
|
||||
Instrumented rwlock_destroy.
|
||||
@c mysql_rwlock_destroy is a drop-in replacement
|
||||
for @c pthread_rwlock_destroy.
|
||||
*/
|
||||
#define mysql_rwlock_destroy(RW) inline_mysql_rwlock_destroy(RW)
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_rdlock(RW)
|
||||
Instrumented rwlock_rdlock.
|
||||
@c mysql_rwlock_rdlock is a drop-in replacement
|
||||
for @c pthread_rwlock_rdlock.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_rwlock_rdlock(RW) \
|
||||
inline_mysql_rwlock_rdlock(RW, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_rwlock_rdlock(RW) \
|
||||
inline_mysql_rwlock_rdlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_wrlock(RW)
|
||||
Instrumented rwlock_wrlock.
|
||||
@c mysql_rwlock_wrlock is a drop-in replacement
|
||||
for @c pthread_rwlock_wrlock.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_rwlock_wrlock(RW) \
|
||||
inline_mysql_rwlock_wrlock(RW, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_rwlock_wrlock(RW) \
|
||||
inline_mysql_rwlock_wrlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_tryrdlock(RW)
|
||||
Instrumented rwlock_tryrdlock.
|
||||
@c mysql_rwlock_tryrdlock is a drop-in replacement
|
||||
for @c pthread_rwlock_tryrdlock.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_rwlock_tryrdlock(RW) \
|
||||
inline_mysql_rwlock_tryrdlock(RW, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_rwlock_tryrdlock(RW) \
|
||||
inline_mysql_rwlock_tryrdlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_trywrlock(RW)
|
||||
Instrumented rwlock_trywrlock.
|
||||
@c mysql_rwlock_trywrlock is a drop-in replacement
|
||||
for @c pthread_rwlock_trywrlock.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_rwlock_trywrlock(RW) \
|
||||
inline_mysql_rwlock_trywrlock(RW, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_rwlock_trywrlock(RW) \
|
||||
inline_mysql_rwlock_trywrlock(RW)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_rwlock_unlock(RW)
|
||||
Instrumented rwlock_unlock.
|
||||
@c mysql_rwlock_unlock is a drop-in replacement
|
||||
for @c pthread_rwlock_unlock.
|
||||
*/
|
||||
#define mysql_rwlock_unlock(RW) inline_mysql_rwlock_unlock(RW)
|
||||
|
||||
/**
|
||||
@def mysql_cond_init(K, C, A)
|
||||
Instrumented rwlock_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
|
||||
@param A Condition attributes
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_cond_init(K, C, A) inline_mysql_cond_init(K, C, A)
|
||||
#else
|
||||
#define mysql_cond_init(K, C, A) inline_mysql_cond_init(C, A)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_cond_destroy(C)
|
||||
Instrumented cond_destroy.
|
||||
@c mysql_cond_destroy is a drop-in replacement for @c pthread_cond_destroy.
|
||||
*/
|
||||
#define mysql_cond_destroy(C) inline_mysql_cond_destroy(C)
|
||||
|
||||
/**
|
||||
@def mysql_cond_wait(C)
|
||||
Instrumented cond_wait.
|
||||
@c mysql_cond_wait is a drop-in replacement for @c pthread_cond_wait.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_cond_wait(C, M) \
|
||||
inline_mysql_cond_wait(C, M, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_cond_wait(C, M) \
|
||||
inline_mysql_cond_wait(C, M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_cond_timedwait(C, M, W)
|
||||
Instrumented cond_timedwait.
|
||||
@c mysql_cond_timedwait is a drop-in replacement
|
||||
for @c pthread_cond_timedwait.
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_cond_timedwait(C, M, W) \
|
||||
inline_mysql_cond_timedwait(C, M, W, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_cond_timedwait(C, M, W) \
|
||||
inline_mysql_cond_timedwait(C, M, W)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_cond_signal(C)
|
||||
Instrumented cond_signal.
|
||||
@c mysql_cond_signal is a drop-in replacement for @c pthread_cond_signal.
|
||||
*/
|
||||
#define mysql_cond_signal(C) inline_mysql_cond_signal(C)
|
||||
|
||||
/**
|
||||
@def mysql_cond_broadcast(C)
|
||||
Instrumented cond_broadcast.
|
||||
@c mysql_cond_broadcast is a drop-in replacement
|
||||
for @c pthread_cond_broadcast.
|
||||
*/
|
||||
#define mysql_cond_broadcast(C) inline_mysql_cond_broadcast(C)
|
||||
|
||||
|
||||
/**
|
||||
@def mysql_thread_create(K, P1, P2, P3, P4)
|
||||
Instrumented pthread_create.
|
||||
This function creates both the thread instrumentation and a thread.
|
||||
@c mysql_thread_create is a replacement for @c pthread_create.
|
||||
The parameter P4 (or, if it is NULL, P1) will be used as the
|
||||
instrumented thread "indentity".
|
||||
Providing a P1 / P4 parameter with a different value for each call
|
||||
will on average improve performances, since this thread identity value
|
||||
is used internally to randomize access to data and prevent contention.
|
||||
This is optional, and the improvement is not guaranteed, only statistical.
|
||||
@param K The PSI_thread_key for this instrumented thread
|
||||
@param P1 pthread_create parameter 1
|
||||
@param P2 pthread_create parameter 2
|
||||
@param P3 pthread_create parameter 3
|
||||
@param P4 pthread_create parameter 4
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_thread_create(K, P1, P2, P3, P4) \
|
||||
inline_mysql_thread_create(K, P1, P2, P3, P4)
|
||||
#else
|
||||
#define mysql_thread_create(K, P1, P2, P3, P4) \
|
||||
pthread_create(P1, P2, P3, P4)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_thread_set_psi_id(I)
|
||||
Set the thread indentifier for the instrumentation.
|
||||
@param I The thread identifier
|
||||
*/
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#define mysql_thread_set_psi_id(I) inline_mysql_thread_set_psi_id(I)
|
||||
#else
|
||||
#define mysql_thread_set_psi_id(I) do {} while (0)
|
||||
#endif
|
||||
|
||||
static inline int inline_mysql_mutex_init(
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
PSI_mutex_key key,
|
||||
#endif
|
||||
mysql_mutex_t *that,
|
||||
const pthread_mutexattr_t *attr
|
||||
#ifdef SAFE_MUTEX
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
that->m_psi= PSI_server ? PSI_server->init_mutex(key, &that->m_mutex)
|
||||
: NULL;
|
||||
#else
|
||||
that->m_psi= NULL;
|
||||
#endif
|
||||
#ifdef SAFE_MUTEX
|
||||
return safe_mutex_init(&that->m_mutex, attr, src_file, src_line);
|
||||
#else
|
||||
return pthread_mutex_init(&that->m_mutex, attr);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int inline_mysql_mutex_destroy(
|
||||
mysql_mutex_t *that
|
||||
#ifdef SAFE_MUTEX
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
PSI_server->destroy_mutex(that->m_psi);
|
||||
that->m_psi= NULL;
|
||||
}
|
||||
#endif
|
||||
#ifdef SAFE_MUTEX
|
||||
return safe_mutex_destroy(&that->m_mutex, src_file, src_line);
|
||||
#else
|
||||
return pthread_mutex_destroy(&that->m_mutex);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline int inline_mysql_mutex_lock(
|
||||
mysql_mutex_t *that
|
||||
#if defined(SAFE_MUTEX) || defined (HAVE_PSI_INTERFACE)
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
int result;
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
struct PSI_mutex_locker *locker= NULL;
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
locker= PSI_server->get_thread_mutex_locker(that->m_psi, PSI_MUTEX_LOCK);
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->start_mutex_wait(locker, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
#ifdef SAFE_MUTEX
|
||||
result= safe_mutex_lock(&that->m_mutex, FALSE, src_file, src_line);
|
||||
#else
|
||||
result= pthread_mutex_lock(&that->m_mutex);
|
||||
#endif
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->end_mutex_wait(locker, result);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_mutex_trylock(
|
||||
mysql_mutex_t *that
|
||||
#if defined(SAFE_MUTEX) || defined (HAVE_PSI_INTERFACE)
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
int result;
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
struct PSI_mutex_locker *locker= NULL;
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
locker= PSI_server->get_thread_mutex_locker(that->m_psi, PSI_MUTEX_TRYLOCK);
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->start_mutex_wait(locker, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
#ifdef SAFE_MUTEX
|
||||
result= safe_mutex_lock(&that->m_mutex, TRUE, src_file, src_line);
|
||||
#else
|
||||
result= pthread_mutex_trylock(&that->m_mutex);
|
||||
#endif
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->end_mutex_wait(locker, result);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_mutex_unlock(
|
||||
mysql_mutex_t *that
|
||||
#ifdef SAFE_MUTEX
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
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_mutex(thread, that->m_psi);
|
||||
}
|
||||
#endif
|
||||
#ifdef SAFE_MUTEX
|
||||
result= safe_mutex_unlock(&that->m_mutex, src_file, src_line);
|
||||
#else
|
||||
result= pthread_mutex_unlock(&that->m_mutex);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_rwlock_init(
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
PSI_rwlock_key key,
|
||||
#endif
|
||||
mysql_rwlock_t *that)
|
||||
{
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
that->m_psi= (PSI_server ? PSI_server->init_rwlock(key, &that->m_rwlock)
|
||||
: NULL);
|
||||
#else
|
||||
that->m_psi= NULL;
|
||||
#endif
|
||||
/*
|
||||
pthread_rwlockattr_t is not used in MySQL.
|
||||
*/
|
||||
return my_rwlock_init(&that->m_rwlock, NULL);
|
||||
}
|
||||
|
||||
static inline int inline_mysql_rwlock_destroy(
|
||||
mysql_rwlock_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 rwlock_destroy(&that->m_rwlock);
|
||||
}
|
||||
|
||||
static inline int inline_mysql_rwlock_rdlock(
|
||||
mysql_rwlock_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_rdlock(&that->m_rwlock);
|
||||
#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
|
||||
, 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_wrlock(&that->m_rwlock);
|
||||
#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
|
||||
, 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_tryrdlock(&that->m_rwlock);
|
||||
#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
|
||||
, 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_trywrlock(&that->m_rwlock);
|
||||
#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)
|
||||
{
|
||||
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_unlock(&that->m_rwlock);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_cond_init(
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
PSI_cond_key key,
|
||||
#endif
|
||||
mysql_cond_t *that,
|
||||
const pthread_condattr_t *attr)
|
||||
{
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
that->m_psi= (PSI_server ? PSI_server->init_cond(key, &that->m_cond)
|
||||
: NULL);
|
||||
#else
|
||||
that->m_psi= NULL;
|
||||
#endif
|
||||
return pthread_cond_init(&that->m_cond, attr);
|
||||
}
|
||||
|
||||
static inline int inline_mysql_cond_destroy(
|
||||
mysql_cond_t *that)
|
||||
{
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
PSI_server->destroy_cond(that->m_psi);
|
||||
that->m_psi= NULL;
|
||||
}
|
||||
#endif
|
||||
return pthread_cond_destroy(&that->m_cond);
|
||||
}
|
||||
|
||||
static inline int inline_mysql_cond_wait(
|
||||
mysql_cond_t *that,
|
||||
mysql_mutex_t *mutex
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
int result;
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
struct PSI_cond_locker *locker= NULL;
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
locker= PSI_server->get_thread_cond_locker(that->m_psi, mutex->m_psi,
|
||||
PSI_COND_WAIT);
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->start_cond_wait(locker, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
result= pthread_cond_wait(&that->m_cond, &mutex->m_mutex);
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->end_cond_wait(locker, result);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_cond_timedwait(
|
||||
mysql_cond_t *that,
|
||||
mysql_mutex_t *mutex,
|
||||
struct timespec *abstime
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
, const char *src_file, uint src_line
|
||||
#endif
|
||||
)
|
||||
{
|
||||
int result;
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
struct PSI_cond_locker *locker= NULL;
|
||||
if (likely(PSI_server && that->m_psi))
|
||||
{
|
||||
locker= PSI_server->get_thread_cond_locker(that->m_psi, mutex->m_psi,
|
||||
PSI_COND_TIMEDWAIT);
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->start_cond_wait(locker, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
result= pthread_cond_timedwait(&that->m_cond, &mutex->m_mutex, abstime);
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
if (likely(locker != NULL))
|
||||
PSI_server->end_cond_wait(locker, result);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_cond_signal(
|
||||
mysql_cond_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->signal_cond(thread, that->m_psi);
|
||||
}
|
||||
#endif
|
||||
result= pthread_cond_signal(&that->m_cond);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline int inline_mysql_cond_broadcast(
|
||||
mysql_cond_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->broadcast_cond(thread, that->m_psi);
|
||||
}
|
||||
#endif
|
||||
result= pthread_cond_broadcast(&that->m_cond);
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
static inline int inline_mysql_thread_create(
|
||||
PSI_thread_key key,
|
||||
pthread_t *thread, const pthread_attr_t *attr,
|
||||
void *(*start_routine)(void*), void *arg)
|
||||
{
|
||||
int result;
|
||||
if (likely(PSI_server != NULL))
|
||||
result= PSI_server->spawn_thread(key, thread, attr, start_routine, arg);
|
||||
else
|
||||
result= pthread_create(thread, attr, start_routine, arg);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void inline_mysql_thread_set_psi_id(ulong id)
|
||||
{
|
||||
if (likely(PSI_server != NULL))
|
||||
{
|
||||
struct PSI_thread *psi= PSI_server->get_thread();
|
||||
if (likely(psi != NULL))
|
||||
PSI_server->set_thread_id(psi, id);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* DISABLE_MYSQL_THREAD_H */
|
||||
|
||||
/** @} (end of group Thread_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
||||
1086
include/mysql/psi/psi.h
Normal file
1086
include/mysql/psi/psi.h
Normal file
File diff suppressed because it is too large
Load Diff
26
include/mysql/psi/psi_abi_v1.h
Normal file
26
include/mysql/psi/psi_abi_v1.h
Normal file
@ -0,0 +1,26 @@
|
||||
/* Copyright (C) 2008-2009 Sun Microsystems, Inc
|
||||
|
||||
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 mysql/psi/psi_abi_v1.h
|
||||
ABI check for mysql/psi/psi.h, when using PSI_VERSION_1.
|
||||
This file is only used to automate detection of changes between versions.
|
||||
Do not include this file, include mysql/psi/psi.h instead.
|
||||
*/
|
||||
#define USE_PSI_1
|
||||
#define HAVE_PSI_INTERFACE
|
||||
#define _global_h
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
242
include/mysql/psi/psi_abi_v1.h.pp
Normal file
242
include/mysql/psi/psi_abi_v1.h.pp
Normal file
@ -0,0 +1,242 @@
|
||||
#include "mysql/psi/psi.h"
|
||||
C_MODE_START
|
||||
struct PSI_mutex;
|
||||
struct PSI_rwlock;
|
||||
struct PSI_cond;
|
||||
struct PSI_table_share;
|
||||
struct PSI_table;
|
||||
struct PSI_thread;
|
||||
struct PSI_file;
|
||||
struct PSI_bootstrap
|
||||
{
|
||||
void* (*get_interface)(int version);
|
||||
};
|
||||
struct PSI_mutex_locker;
|
||||
struct PSI_rwlock_locker;
|
||||
struct PSI_cond_locker;
|
||||
struct PSI_file_locker;
|
||||
enum PSI_mutex_operation
|
||||
{
|
||||
PSI_MUTEX_LOCK= 0,
|
||||
PSI_MUTEX_TRYLOCK= 1
|
||||
};
|
||||
enum PSI_rwlock_operation
|
||||
{
|
||||
PSI_RWLOCK_READLOCK= 0,
|
||||
PSI_RWLOCK_WRITELOCK= 1,
|
||||
PSI_RWLOCK_TRYREADLOCK= 2,
|
||||
PSI_RWLOCK_TRYWRITELOCK= 3
|
||||
};
|
||||
enum PSI_cond_operation
|
||||
{
|
||||
PSI_COND_WAIT= 0,
|
||||
PSI_COND_TIMEDWAIT= 1
|
||||
};
|
||||
enum PSI_file_operation
|
||||
{
|
||||
PSI_FILE_CREATE= 0,
|
||||
PSI_FILE_CREATE_TMP= 1,
|
||||
PSI_FILE_OPEN= 2,
|
||||
PSI_FILE_STREAM_OPEN= 3,
|
||||
PSI_FILE_CLOSE= 4,
|
||||
PSI_FILE_STREAM_CLOSE= 5,
|
||||
PSI_FILE_READ= 6,
|
||||
PSI_FILE_WRITE= 7,
|
||||
PSI_FILE_SEEK= 8,
|
||||
PSI_FILE_TELL= 9,
|
||||
PSI_FILE_FLUSH= 10,
|
||||
PSI_FILE_STAT= 11,
|
||||
PSI_FILE_FSTAT= 12,
|
||||
PSI_FILE_CHSIZE= 13,
|
||||
PSI_FILE_DELETE= 14,
|
||||
PSI_FILE_RENAME= 15,
|
||||
PSI_FILE_SYNC= 16
|
||||
};
|
||||
struct PSI_table_locker;
|
||||
typedef unsigned int PSI_mutex_key;
|
||||
typedef unsigned int PSI_rwlock_key;
|
||||
typedef unsigned int PSI_cond_key;
|
||||
typedef unsigned int PSI_thread_key;
|
||||
typedef unsigned int PSI_file_key;
|
||||
struct PSI_mutex_info_v1
|
||||
{
|
||||
PSI_mutex_key *m_key;
|
||||
const char *m_name;
|
||||
int m_flags;
|
||||
};
|
||||
struct PSI_rwlock_info_v1
|
||||
{
|
||||
PSI_rwlock_key *m_key;
|
||||
const char *m_name;
|
||||
int m_flags;
|
||||
};
|
||||
struct PSI_cond_info_v1
|
||||
{
|
||||
PSI_cond_key *m_key;
|
||||
const char *m_name;
|
||||
int m_flags;
|
||||
};
|
||||
struct PSI_thread_info_v1
|
||||
{
|
||||
PSI_thread_key *m_key;
|
||||
const char *m_name;
|
||||
int m_flags;
|
||||
};
|
||||
struct PSI_file_info_v1
|
||||
{
|
||||
PSI_file_key *m_key;
|
||||
const char *m_name;
|
||||
int m_flags;
|
||||
};
|
||||
typedef void (*register_mutex_v1_t)
|
||||
(const char *category, struct PSI_mutex_info_v1 *info, int count);
|
||||
typedef void (*register_rwlock_v1_t)
|
||||
(const char *category, struct PSI_rwlock_info_v1 *info, int count);
|
||||
typedef void (*register_cond_v1_t)
|
||||
(const char *category, struct PSI_cond_info_v1 *info, int count);
|
||||
typedef void (*register_thread_v1_t)
|
||||
(const char *category, struct PSI_thread_info_v1 *info, int count);
|
||||
typedef void (*register_file_v1_t)
|
||||
(const char *category, struct PSI_file_info_v1 *info, int count);
|
||||
typedef struct PSI_mutex* (*init_mutex_v1_t)
|
||||
(PSI_mutex_key key, const void *identity);
|
||||
typedef void (*destroy_mutex_v1_t)(struct PSI_mutex *mutex);
|
||||
typedef struct PSI_rwlock* (*init_rwlock_v1_t)
|
||||
(PSI_rwlock_key key, const void *identity);
|
||||
typedef void (*destroy_rwlock_v1_t)(struct PSI_rwlock *rwlock);
|
||||
typedef struct PSI_cond* (*init_cond_v1_t)
|
||||
(PSI_cond_key key, const void *identity);
|
||||
typedef void (*destroy_cond_v1_t)(struct PSI_cond *cond);
|
||||
typedef struct PSI_table_share* (*get_table_share_v1_t)
|
||||
(const char *schema_name, int schema_name_length, const char *table_name,
|
||||
int table_name_length, const void *identity);
|
||||
typedef void (*release_table_share_v1_t)(struct PSI_table_share *share);
|
||||
typedef struct PSI_table* (*open_table_v1_t)
|
||||
(struct PSI_table_share *share, const void *identity);
|
||||
typedef void (*close_table_v1_t)(struct PSI_table *table);
|
||||
typedef void (*create_file_v1_t)(PSI_file_key key, const char *name,
|
||||
File file);
|
||||
typedef int (*spawn_thread_v1_t)(PSI_thread_key key,
|
||||
pthread_t *thread,
|
||||
const pthread_attr_t *attr,
|
||||
void *(*start_routine)(void*), void *arg);
|
||||
typedef struct PSI_thread* (*new_thread_v1_t)
|
||||
(PSI_thread_key key, const void *identity, ulong thread_id);
|
||||
typedef void (*set_thread_id_v1_t)(struct PSI_thread *thread,
|
||||
unsigned long id);
|
||||
typedef struct PSI_thread* (*get_thread_v1_t)(void);
|
||||
typedef void (*set_thread_v1_t)(struct PSI_thread *thread);
|
||||
typedef void (*delete_current_thread_v1_t)(void);
|
||||
typedef struct PSI_mutex_locker* (*get_thread_mutex_locker_v1_t)
|
||||
(struct PSI_mutex *mutex, enum PSI_mutex_operation op);
|
||||
typedef struct PSI_rwlock_locker* (*get_thread_rwlock_locker_v1_t)
|
||||
(struct PSI_rwlock *rwlock, enum PSI_rwlock_operation op);
|
||||
typedef struct PSI_cond_locker* (*get_thread_cond_locker_v1_t)
|
||||
(struct PSI_cond *cond, struct PSI_mutex *mutex,
|
||||
enum PSI_cond_operation op);
|
||||
typedef struct PSI_table_locker* (*get_thread_table_locker_v1_t)
|
||||
(struct PSI_table *table);
|
||||
typedef struct PSI_file_locker* (*get_thread_file_name_locker_v1_t)
|
||||
(PSI_file_key key, enum PSI_file_operation op, const char *name,
|
||||
const void *identity);
|
||||
typedef struct PSI_file_locker* (*get_thread_file_stream_locker_v1_t)
|
||||
(struct PSI_file *file, enum PSI_file_operation op);
|
||||
typedef struct PSI_file_locker* (*get_thread_file_descriptor_locker_v1_t)
|
||||
(File file, enum PSI_file_operation op);
|
||||
typedef void (*unlock_mutex_v1_t)
|
||||
(struct PSI_thread *thread, struct PSI_mutex *mutex);
|
||||
typedef void (*unlock_rwlock_v1_t)
|
||||
(struct PSI_thread *thread, struct PSI_rwlock *rwlock);
|
||||
typedef void (*signal_cond_v1_t)
|
||||
(struct PSI_thread *thread, struct PSI_cond *cond);
|
||||
typedef void (*broadcast_cond_v1_t)
|
||||
(struct PSI_thread *thread, struct PSI_cond *cond);
|
||||
typedef void (*start_mutex_wait_v1_t)
|
||||
(struct PSI_mutex_locker *locker, const char *src_file, uint src_line);
|
||||
typedef void (*end_mutex_wait_v1_t)
|
||||
(struct PSI_mutex_locker *locker, int rc);
|
||||
typedef void (*start_rwlock_rdwait_v1_t)
|
||||
(struct PSI_rwlock_locker *locker, const char *src_file, uint src_line);
|
||||
typedef void (*end_rwlock_rdwait_v1_t)
|
||||
(struct PSI_rwlock_locker *locker, int rc);
|
||||
typedef void (*start_rwlock_wrwait_v1_t)
|
||||
(struct PSI_rwlock_locker *locker, const char *src_file, uint src_line);
|
||||
typedef void (*end_rwlock_wrwait_v1_t)
|
||||
(struct PSI_rwlock_locker *locker, int rc);
|
||||
typedef void (*start_cond_wait_v1_t)
|
||||
(struct PSI_cond_locker *locker, const char *src_file, uint src_line);
|
||||
typedef void (*end_cond_wait_v1_t)
|
||||
(struct PSI_cond_locker *locker, int rc);
|
||||
typedef void (*start_table_wait_v1_t)
|
||||
(struct PSI_table_locker *locker, const char *src_file, uint src_line);
|
||||
typedef void (*end_table_wait_v1_t)(struct PSI_table_locker *locker);
|
||||
typedef struct PSI_file* (*start_file_open_wait_v1_t)
|
||||
(struct PSI_file_locker *locker, const char *src_file, uint src_line);
|
||||
typedef void (*end_file_open_wait_v1_t)(struct PSI_file_locker *locker);
|
||||
typedef void (*end_file_open_wait_and_bind_to_descriptor_v1_t)
|
||||
(struct PSI_file_locker *locker, File file);
|
||||
typedef void (*start_file_wait_v1_t)
|
||||
(struct PSI_file_locker *locker, size_t count,
|
||||
const char *src_file, uint src_line);
|
||||
typedef void (*end_file_wait_v1_t)
|
||||
(struct PSI_file_locker *locker, size_t count);
|
||||
struct PSI_v1
|
||||
{
|
||||
register_mutex_v1_t register_mutex;
|
||||
register_rwlock_v1_t register_rwlock;
|
||||
register_cond_v1_t register_cond;
|
||||
register_thread_v1_t register_thread;
|
||||
register_file_v1_t register_file;
|
||||
init_mutex_v1_t init_mutex;
|
||||
destroy_mutex_v1_t destroy_mutex;
|
||||
init_rwlock_v1_t init_rwlock;
|
||||
destroy_rwlock_v1_t destroy_rwlock;
|
||||
init_cond_v1_t init_cond;
|
||||
destroy_cond_v1_t destroy_cond;
|
||||
get_table_share_v1_t get_table_share;
|
||||
release_table_share_v1_t release_table_share;
|
||||
open_table_v1_t open_table;
|
||||
close_table_v1_t close_table;
|
||||
create_file_v1_t create_file;
|
||||
spawn_thread_v1_t spawn_thread;
|
||||
new_thread_v1_t new_thread;
|
||||
set_thread_id_v1_t set_thread_id;
|
||||
get_thread_v1_t get_thread;
|
||||
set_thread_v1_t set_thread;
|
||||
delete_current_thread_v1_t delete_current_thread;
|
||||
get_thread_mutex_locker_v1_t get_thread_mutex_locker;
|
||||
get_thread_rwlock_locker_v1_t get_thread_rwlock_locker;
|
||||
get_thread_cond_locker_v1_t get_thread_cond_locker;
|
||||
get_thread_table_locker_v1_t get_thread_table_locker;
|
||||
get_thread_file_name_locker_v1_t get_thread_file_name_locker;
|
||||
get_thread_file_stream_locker_v1_t get_thread_file_stream_locker;
|
||||
get_thread_file_descriptor_locker_v1_t get_thread_file_descriptor_locker;
|
||||
unlock_mutex_v1_t unlock_mutex;
|
||||
unlock_rwlock_v1_t unlock_rwlock;
|
||||
signal_cond_v1_t signal_cond;
|
||||
broadcast_cond_v1_t broadcast_cond;
|
||||
start_mutex_wait_v1_t start_mutex_wait;
|
||||
end_mutex_wait_v1_t end_mutex_wait;
|
||||
start_rwlock_rdwait_v1_t start_rwlock_rdwait;
|
||||
end_rwlock_rdwait_v1_t end_rwlock_rdwait;
|
||||
start_rwlock_wrwait_v1_t start_rwlock_wrwait;
|
||||
end_rwlock_wrwait_v1_t end_rwlock_wrwait;
|
||||
start_cond_wait_v1_t start_cond_wait;
|
||||
end_cond_wait_v1_t end_cond_wait;
|
||||
start_table_wait_v1_t start_table_wait;
|
||||
end_table_wait_v1_t end_table_wait;
|
||||
start_file_open_wait_v1_t start_file_open_wait;
|
||||
end_file_open_wait_v1_t end_file_open_wait;
|
||||
end_file_open_wait_and_bind_to_descriptor_v1_t
|
||||
end_file_open_wait_and_bind_to_descriptor;
|
||||
start_file_wait_v1_t start_file_wait;
|
||||
end_file_wait_v1_t end_file_wait;
|
||||
};
|
||||
typedef struct PSI_v1 PSI;
|
||||
typedef struct PSI_mutex_info_v1 PSI_mutex_info;
|
||||
typedef struct PSI_rwlock_info_v1 PSI_rwlock_info;
|
||||
typedef struct PSI_cond_info_v1 PSI_cond_info;
|
||||
typedef struct PSI_thread_info_v1 PSI_thread_info;
|
||||
typedef struct PSI_file_info_v1 PSI_file_info;
|
||||
extern MYSQL_PLUGIN_IMPORT PSI *PSI_server;
|
||||
C_MODE_END
|
||||
26
include/mysql/psi/psi_abi_v2.h
Normal file
26
include/mysql/psi/psi_abi_v2.h
Normal file
@ -0,0 +1,26 @@
|
||||
/* Copyright (C) 2008-2009 Sun Microsystems, Inc
|
||||
|
||||
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 mysql/psi/psi_abi_v1.h
|
||||
ABI check for mysql/psi/psi.h, when using PSI_VERSION_2.
|
||||
This file is only used to automate detection of changes between versions.
|
||||
Do not include this file, include mysql/psi/psi.h instead.
|
||||
*/
|
||||
#define USE_PSI_2
|
||||
#define HAVE_PSI_INTERFACE
|
||||
#define _global_h
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
92
include/mysql/psi/psi_abi_v2.h.pp
Normal file
92
include/mysql/psi/psi_abi_v2.h.pp
Normal file
@ -0,0 +1,92 @@
|
||||
#include "mysql/psi/psi.h"
|
||||
C_MODE_START
|
||||
struct PSI_mutex;
|
||||
struct PSI_rwlock;
|
||||
struct PSI_cond;
|
||||
struct PSI_table_share;
|
||||
struct PSI_table;
|
||||
struct PSI_thread;
|
||||
struct PSI_file;
|
||||
struct PSI_bootstrap
|
||||
{
|
||||
void* (*get_interface)(int version);
|
||||
};
|
||||
struct PSI_mutex_locker;
|
||||
struct PSI_rwlock_locker;
|
||||
struct PSI_cond_locker;
|
||||
struct PSI_file_locker;
|
||||
enum PSI_mutex_operation
|
||||
{
|
||||
PSI_MUTEX_LOCK= 0,
|
||||
PSI_MUTEX_TRYLOCK= 1
|
||||
};
|
||||
enum PSI_rwlock_operation
|
||||
{
|
||||
PSI_RWLOCK_READLOCK= 0,
|
||||
PSI_RWLOCK_WRITELOCK= 1,
|
||||
PSI_RWLOCK_TRYREADLOCK= 2,
|
||||
PSI_RWLOCK_TRYWRITELOCK= 3
|
||||
};
|
||||
enum PSI_cond_operation
|
||||
{
|
||||
PSI_COND_WAIT= 0,
|
||||
PSI_COND_TIMEDWAIT= 1
|
||||
};
|
||||
enum PSI_file_operation
|
||||
{
|
||||
PSI_FILE_CREATE= 0,
|
||||
PSI_FILE_CREATE_TMP= 1,
|
||||
PSI_FILE_OPEN= 2,
|
||||
PSI_FILE_STREAM_OPEN= 3,
|
||||
PSI_FILE_CLOSE= 4,
|
||||
PSI_FILE_STREAM_CLOSE= 5,
|
||||
PSI_FILE_READ= 6,
|
||||
PSI_FILE_WRITE= 7,
|
||||
PSI_FILE_SEEK= 8,
|
||||
PSI_FILE_TELL= 9,
|
||||
PSI_FILE_FLUSH= 10,
|
||||
PSI_FILE_STAT= 11,
|
||||
PSI_FILE_FSTAT= 12,
|
||||
PSI_FILE_CHSIZE= 13,
|
||||
PSI_FILE_DELETE= 14,
|
||||
PSI_FILE_RENAME= 15,
|
||||
PSI_FILE_SYNC= 16
|
||||
};
|
||||
struct PSI_table_locker;
|
||||
typedef unsigned int PSI_mutex_key;
|
||||
typedef unsigned int PSI_rwlock_key;
|
||||
typedef unsigned int PSI_cond_key;
|
||||
typedef unsigned int PSI_thread_key;
|
||||
typedef unsigned int PSI_file_key;
|
||||
struct PSI_v2
|
||||
{
|
||||
int placeholder;
|
||||
};
|
||||
struct PSI_mutex_info_v2
|
||||
{
|
||||
int placeholder;
|
||||
};
|
||||
struct PSI_rwlock_info_v2
|
||||
{
|
||||
int placeholder;
|
||||
};
|
||||
struct PSI_cond_info_v2
|
||||
{
|
||||
int placeholder;
|
||||
};
|
||||
struct PSI_thread_info_v2
|
||||
{
|
||||
int placeholder;
|
||||
};
|
||||
struct PSI_file_info_v2
|
||||
{
|
||||
int placeholder;
|
||||
};
|
||||
typedef struct PSI_v2 PSI;
|
||||
typedef struct PSI_mutex_info_v2 PSI_mutex_info;
|
||||
typedef struct PSI_rwlock_info_v2 PSI_rwlock_info;
|
||||
typedef struct PSI_cond_info_v2 PSI_cond_info;
|
||||
typedef struct PSI_thread_info_v2 PSI_thread_info;
|
||||
typedef struct PSI_file_info_v2 PSI_file_info;
|
||||
extern MYSQL_PLUGIN_IMPORT PSI *PSI_server;
|
||||
C_MODE_END
|
||||
Reference in New Issue
Block a user