Marc Alff
16 years ago
18 changed files with 3857 additions and 23 deletions
-
9Makefile.am
-
10include/Makefile.am
-
12include/my_global.h
-
13include/my_no_pthread.h
-
12include/my_pthread.h
-
12include/my_sys.h
-
1398include/mysql/psi/mysql_file.h
-
884include/mysql/psi/mysql_thread.h
-
1086include/mysql/psi/psi.h
-
26include/mysql/psi/psi_abi_v1.h
-
242include/mysql/psi/psi_abi_v1.h.pp
-
26include/mysql/psi/psi_abi_v2.h
-
92include/mysql/psi/psi_abi_v2.h.pp
-
6libmysql/Makefile.am
-
5libmysql/Makefile.shared
-
28mysys/my_static.c
-
6mysys/my_winthread.c
-
13strings/Makefile.am
1398
include/mysql/psi/mysql_file.h
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View 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
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View 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" |
|||
|
|||
@ -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 |
|||
@ -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" |
|||
|
|||
@ -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 |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue