Initial commit
This commit is contained in:
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,96 @@
|
||||
/* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_IDLE_H
|
||||
#define MYSQL_IDLE_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_idle.h
|
||||
Instrumentation helpers for idle waits.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_IDLE_CALL
|
||||
#define PSI_IDLE_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Idle_instrumentation Idle Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def MYSQL_START_IDLE_WAIT
|
||||
Instrumentation helper for table io_waits.
|
||||
This instrumentation marks the start of a wait event.
|
||||
@param LOCKER the locker
|
||||
@param STATE the locker state
|
||||
@sa MYSQL_END_IDLE_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_IDLE_INTERFACE
|
||||
#define MYSQL_START_IDLE_WAIT(LOCKER, STATE) \
|
||||
LOCKER= inline_mysql_start_idle_wait(STATE, __FILE__, __LINE__)
|
||||
#else
|
||||
#define MYSQL_START_IDLE_WAIT(LOCKER, STATE) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def MYSQL_END_IDLE_WAIT
|
||||
Instrumentation helper for idle waits.
|
||||
This instrumentation marks the end of a wait event.
|
||||
@param LOCKER the locker
|
||||
@sa MYSQL_START_IDLE_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_IDLE_INTERFACE
|
||||
#define MYSQL_END_IDLE_WAIT(LOCKER) \
|
||||
inline_mysql_end_idle_wait(LOCKER)
|
||||
#else
|
||||
#define MYSQL_END_IDLE_WAIT(LOCKER) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_IDLE_INTERFACE
|
||||
/**
|
||||
Instrumentation calls for MYSQL_START_IDLE_WAIT.
|
||||
@sa MYSQL_END_IDLE_WAIT.
|
||||
*/
|
||||
static inline struct PSI_idle_locker *
|
||||
inline_mysql_start_idle_wait(PSI_idle_locker_state *state,
|
||||
const char *src_file, int src_line)
|
||||
{
|
||||
struct PSI_idle_locker *locker;
|
||||
locker= PSI_IDLE_CALL(start_idle_wait)(state, src_file, src_line);
|
||||
return locker;
|
||||
}
|
||||
|
||||
/**
|
||||
Instrumentation calls for MYSQL_END_IDLE_WAIT.
|
||||
@sa MYSQL_START_IDLE_WAIT.
|
||||
*/
|
||||
static inline void
|
||||
inline_mysql_end_idle_wait(struct PSI_idle_locker *locker)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_IDLE_CALL(end_idle_wait)(locker);
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Idle_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,121 @@
|
||||
/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_MDL_H
|
||||
#define MYSQL_MDL_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_mdl.h
|
||||
Instrumentation helpers for metadata locks.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_METADATA_CALL
|
||||
#define PSI_METADATA_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Thread_instrumentation Metadata Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def mysql_mdl_create(K, M, A)
|
||||
Instrumented metadata lock creation.
|
||||
@param I Metadata lock identity
|
||||
@param K Metadata key
|
||||
@param T Metadata lock type
|
||||
@param D Metadata lock duration
|
||||
@param S Metadata lock status
|
||||
@param F request source file
|
||||
@param L request source line
|
||||
*/
|
||||
|
||||
#ifdef HAVE_PSI_METADATA_INTERFACE
|
||||
#define mysql_mdl_create(I, K, T, D, S, F, L) \
|
||||
inline_mysql_mdl_create(I, K, T, D, S, F, L)
|
||||
#else
|
||||
#define mysql_mdl_create(I, K, T, D, S, F, L) NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_METADATA_INTERFACE
|
||||
#define mysql_mdl_set_status(L, S) \
|
||||
inline_mysql_mdl_set_status(L, S)
|
||||
#else
|
||||
#define mysql_mdl_set_status(L, S) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
@def mysql_mdl_destroy(M)
|
||||
Instrumented metadata lock destruction.
|
||||
@param M Metadata lock
|
||||
*/
|
||||
#ifdef HAVE_PSI_METADATA_INTERFACE
|
||||
#define mysql_mdl_destroy(M) \
|
||||
inline_mysql_mdl_destroy(M, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_mdl_destroy(M) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_METADATA_INTERFACE
|
||||
|
||||
static inline PSI_metadata_lock *
|
||||
inline_mysql_mdl_create(void *identity,
|
||||
const MDL_key *mdl_key,
|
||||
enum_mdl_type mdl_type,
|
||||
enum_mdl_duration mdl_duration,
|
||||
MDL_ticket::enum_psi_status mdl_status,
|
||||
const char *src_file, uint src_line)
|
||||
{
|
||||
PSI_metadata_lock *result;
|
||||
|
||||
/* static_cast: Fit a round C++ enum peg into a square C int hole ... */
|
||||
result= PSI_METADATA_CALL(create_metadata_lock)
|
||||
(identity,
|
||||
mdl_key,
|
||||
static_cast<opaque_mdl_type> (mdl_type),
|
||||
static_cast<opaque_mdl_duration> (mdl_duration),
|
||||
static_cast<opaque_mdl_status> (mdl_status),
|
||||
src_file, src_line);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void inline_mysql_mdl_set_status(
|
||||
PSI_metadata_lock *psi,
|
||||
MDL_ticket::enum_psi_status mdl_status)
|
||||
{
|
||||
if (psi != NULL)
|
||||
PSI_METADATA_CALL(set_metadata_lock_status)(psi, mdl_status);
|
||||
}
|
||||
|
||||
static inline void inline_mysql_mdl_destroy(
|
||||
PSI_metadata_lock *psi,
|
||||
const char *src_file, uint src_line)
|
||||
{
|
||||
if (psi != NULL)
|
||||
PSI_METADATA_CALL(destroy_metadata_lock)(psi);
|
||||
}
|
||||
#endif /* HAVE_PSI_METADATA_INTERFACE */
|
||||
|
||||
/** @} (end of group Metadata_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
/* Copyright (c) 2012, 2016, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_MEMORY_H
|
||||
#define MYSQL_MEMORY_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_memory.h
|
||||
Instrumentation helpers for memory allocation.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_MEMORY_CALL
|
||||
#define PSI_MEMORY_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Memory_instrumentation Memory Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def mysql_memory_register(P1, P2, P3)
|
||||
Memory registration.
|
||||
*/
|
||||
#define mysql_memory_register(P1, P2, P3) \
|
||||
inline_mysql_memory_register(P1, P2, P3)
|
||||
|
||||
static inline void inline_mysql_memory_register(
|
||||
#ifdef HAVE_PSI_MEMORY_INTERFACE
|
||||
const char *category,
|
||||
PSI_memory_info *info,
|
||||
int count)
|
||||
#else
|
||||
const char *category MY_ATTRIBUTE((unused)),
|
||||
void *info MY_ATTRIBUTE((unused)),
|
||||
int count MY_ATTRIBUTE((unused)))
|
||||
#endif
|
||||
{
|
||||
#ifdef HAVE_PSI_MEMORY_INTERFACE
|
||||
PSI_MEMORY_CALL(register_memory)(category, info, count);
|
||||
#endif
|
||||
}
|
||||
|
||||
/** @} (end of group Memory_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
/* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_PS_H
|
||||
#define MYSQL_PS_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_ps.h
|
||||
Instrumentation helpers for prepared statements.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_PS_CALL
|
||||
#define PSI_PS_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_PS_INTERFACE
|
||||
#define MYSQL_CREATE_PS(IDENTITY, ID, LOCKER, NAME, NAME_LENGTH, SQLTEXT, SQLTEXT_LENGTH) \
|
||||
inline_mysql_create_prepared_stmt(IDENTITY, ID, LOCKER, NAME, NAME_LENGTH, SQLTEXT, SQLTEXT_LENGTH)
|
||||
#define MYSQL_EXECUTE_PS(LOCKER, PREPARED_STMT) \
|
||||
inline_mysql_execute_prepared_stmt(LOCKER, PREPARED_STMT)
|
||||
#define MYSQL_DESTROY_PS(PREPARED_STMT) \
|
||||
inline_mysql_destroy_prepared_stmt(PREPARED_STMT)
|
||||
#define MYSQL_REPREPARE_PS(PREPARED_STMT) \
|
||||
inline_mysql_reprepare_prepared_stmt(PREPARED_STMT)
|
||||
#else
|
||||
#define MYSQL_CREATE_PS(IDENTITY, ID, LOCKER, NAME, NAME_LENGTH, SQLTEXT, SQLTEXT_LENGTH) \
|
||||
NULL
|
||||
#define MYSQL_EXECUTE_PS(LOCKER, PREPARED_STMT) \
|
||||
do {} while (0)
|
||||
#define MYSQL_DESTROY_PS(PREPARED_STMT) \
|
||||
do {} while (0)
|
||||
#define MYSQL_REPREPARE_PS(PREPARED_STMT) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_PS_INTERFACE
|
||||
static inline struct PSI_prepared_stmt*
|
||||
inline_mysql_create_prepared_stmt(void *identity, uint stmt_id,
|
||||
PSI_statement_locker *locker,
|
||||
const char *stmt_name, size_t stmt_name_length,
|
||||
const char *sqltext, size_t sqltext_length)
|
||||
{
|
||||
if (locker == NULL)
|
||||
return NULL;
|
||||
return PSI_PS_CALL(create_prepared_stmt)(identity, stmt_id,
|
||||
locker,
|
||||
stmt_name, stmt_name_length,
|
||||
sqltext, sqltext_length);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_execute_prepared_stmt(PSI_statement_locker *locker,
|
||||
PSI_prepared_stmt* prepared_stmt)
|
||||
{
|
||||
if (prepared_stmt != NULL && locker != NULL)
|
||||
PSI_PS_CALL(execute_prepared_stmt)(locker, prepared_stmt);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_destroy_prepared_stmt(PSI_prepared_stmt *prepared_stmt)
|
||||
{
|
||||
if (prepared_stmt != NULL)
|
||||
PSI_PS_CALL(destroy_prepared_stmt)(prepared_stmt);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_reprepare_prepared_stmt(PSI_prepared_stmt *prepared_stmt)
|
||||
{
|
||||
if (prepared_stmt != NULL)
|
||||
PSI_PS_CALL(reprepare_prepared_stmt)(prepared_stmt);
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,97 @@
|
||||
/* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_SP_H
|
||||
#define MYSQL_SP_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_sp.h
|
||||
Instrumentation helpers for stored programs.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_SP_CALL
|
||||
#define PSI_SP_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
#define MYSQL_START_SP(STATE, SP_SHARE) \
|
||||
inline_mysql_start_sp(STATE, SP_SHARE)
|
||||
#else
|
||||
#define MYSQL_START_SP(STATE, SP_SHARE) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
#define MYSQL_END_SP(LOCKER) \
|
||||
inline_mysql_end_sp(LOCKER)
|
||||
#else
|
||||
#define MYSQL_END_SP(LOCKER) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
#define MYSQL_DROP_SP(OT, SN, SNL, ON, ONL) \
|
||||
inline_mysql_drop_sp(OT, SN, SNL, ON, ONL)
|
||||
#else
|
||||
#define MYSQL_DROP_SP(OT, SN, SNL, ON, ONL) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
#define MYSQL_GET_SP_SHARE(OT, SN, SNL, ON, ONL) \
|
||||
inline_mysql_get_sp_share(OT, SN, SNL, ON, ONL)
|
||||
#else
|
||||
#define MYSQL_GET_SP_SHARE(OT, SN, SNL, ON, ONL) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_SP_INTERFACE
|
||||
static inline struct PSI_sp_locker*
|
||||
inline_mysql_start_sp(PSI_sp_locker_state *state, PSI_sp_share *sp_share)
|
||||
{
|
||||
return PSI_SP_CALL(start_sp)(state, sp_share);
|
||||
}
|
||||
|
||||
static inline void inline_mysql_end_sp(PSI_sp_locker *locker)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_SP_CALL(end_sp)(locker);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_drop_sp(uint sp_type,
|
||||
const char* schema_name, uint shcema_name_length,
|
||||
const char* object_name, uint object_name_length)
|
||||
{
|
||||
PSI_SP_CALL(drop_sp)(sp_type,
|
||||
schema_name, shcema_name_length,
|
||||
object_name, object_name_length);
|
||||
}
|
||||
|
||||
static inline PSI_sp_share*
|
||||
inline_mysql_get_sp_share(uint sp_type,
|
||||
const char* schema_name, uint shcema_name_length,
|
||||
const char* object_name, uint object_name_length)
|
||||
{
|
||||
return PSI_SP_CALL(get_sp_share)(sp_type,
|
||||
schema_name, shcema_name_length,
|
||||
object_name, object_name_length);
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,198 @@
|
||||
/* Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_STAGE_H
|
||||
#define MYSQL_STAGE_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_stage.h
|
||||
Instrumentation helpers for stages.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_STAGE_CALL
|
||||
#define PSI_STAGE_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Stage_instrumentation Stage Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def mysql_stage_register(P1, P2, P3)
|
||||
Stage registration.
|
||||
*/
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_stage_register(P1, P2, P3) \
|
||||
inline_mysql_stage_register(P1, P2, P3)
|
||||
#else
|
||||
#define mysql_stage_register(P1, P2, P3) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def MYSQL_SET_STAGE
|
||||
Set the current stage.
|
||||
Use this API when the file and line
|
||||
is passed from the caller.
|
||||
@param K the stage key
|
||||
@param F the source file name
|
||||
@param L the source file line
|
||||
@return the current stage progress
|
||||
*/
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define MYSQL_SET_STAGE(K, F, L) \
|
||||
inline_mysql_set_stage(K, F, L)
|
||||
#else
|
||||
#define MYSQL_SET_STAGE(K, F, L) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_set_stage
|
||||
Set the current stage.
|
||||
@param K the stage key
|
||||
@return the current stage progress
|
||||
*/
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_set_stage(K) \
|
||||
inline_mysql_set_stage(K, __FILE__, __LINE__)
|
||||
#else
|
||||
#define mysql_set_stage(K) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def mysql_end_stage
|
||||
End the last stage
|
||||
*/
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_end_stage \
|
||||
inline_mysql_end_stage
|
||||
#else
|
||||
#define mysql_end_stage \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void inline_mysql_stage_register(
|
||||
const char *category, PSI_stage_info **info, int count)
|
||||
{
|
||||
PSI_STAGE_CALL(register_stage)(category, info, count);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline PSI_stage_progress*
|
||||
inline_mysql_set_stage(PSI_stage_key key,
|
||||
const char *src_file, int src_line)
|
||||
{
|
||||
return PSI_STAGE_CALL(start_stage)(key, src_file, src_line);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_end_stage()
|
||||
{
|
||||
PSI_STAGE_CALL(end_stage)();
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_stage_set_work_completed(P1, P2) \
|
||||
inline_mysql_stage_set_work_completed(P1, P2)
|
||||
|
||||
#define mysql_stage_get_work_completed(P1) \
|
||||
inline_mysql_stage_get_work_completed(P1)
|
||||
#else
|
||||
#define mysql_stage_set_work_completed(P1, P2) \
|
||||
do {} while (0)
|
||||
|
||||
#define mysql_stage_get_work_completed(P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_stage_inc_work_completed(P1, P2) \
|
||||
inline_mysql_stage_inc_work_completed(P1, P2)
|
||||
#else
|
||||
#define mysql_stage_inc_work_completed(P1, P2) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
#define mysql_stage_set_work_estimated(P1, P2) \
|
||||
inline_mysql_stage_set_work_estimated(P1, P2)
|
||||
|
||||
#define mysql_stage_get_work_estimated(P1) \
|
||||
inline_mysql_stage_get_work_estimated(P1)
|
||||
#else
|
||||
#define mysql_stage_set_work_estimated(P1, P2) \
|
||||
do {} while (0)
|
||||
|
||||
#define mysql_stage_get_work_estimated(P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_stage_set_work_completed(PSI_stage_progress *progress,
|
||||
ulonglong val)
|
||||
{
|
||||
if (progress != NULL)
|
||||
progress->m_work_completed= val;
|
||||
}
|
||||
|
||||
static inline ulonglong
|
||||
inline_mysql_stage_get_work_completed(PSI_stage_progress *progress)
|
||||
{
|
||||
return progress->m_work_completed;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_stage_inc_work_completed(PSI_stage_progress *progress,
|
||||
ulonglong val)
|
||||
{
|
||||
if (progress != NULL)
|
||||
progress->m_work_completed+= val;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STAGE_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_stage_set_work_estimated(PSI_stage_progress *progress,
|
||||
ulonglong val)
|
||||
{
|
||||
if (progress != NULL)
|
||||
progress->m_work_estimated= val;
|
||||
}
|
||||
|
||||
static inline ulonglong
|
||||
inline_mysql_stage_get_work_estimated(PSI_stage_progress *progress)
|
||||
{
|
||||
return progress->m_work_estimated;
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Stage_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,235 @@
|
||||
/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_STATEMENT_H
|
||||
#define MYSQL_STATEMENT_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_statement.h
|
||||
Instrumentation helpers for statements.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
class Diagnostics_area;
|
||||
typedef struct charset_info_st CHARSET_INFO;
|
||||
|
||||
#ifndef PSI_STATEMENT_CALL
|
||||
#define PSI_STATEMENT_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
#ifndef PSI_DIGEST_CALL
|
||||
#define PSI_DIGEST_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Statement_instrumentation Statement Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def mysql_statement_register(P1, P2, P3)
|
||||
Statement registration.
|
||||
*/
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define mysql_statement_register(P1, P2, P3) \
|
||||
inline_mysql_statement_register(P1, P2, P3)
|
||||
#else
|
||||
#define mysql_statement_register(P1, P2, P3) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
|
||||
#define MYSQL_DIGEST_START(LOCKER) \
|
||||
inline_mysql_digest_start(LOCKER)
|
||||
#else
|
||||
#define MYSQL_DIGEST_START(LOCKER) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
|
||||
#define MYSQL_DIGEST_END(LOCKER, DIGEST) \
|
||||
inline_mysql_digest_end(LOCKER, DIGEST)
|
||||
#else
|
||||
#define MYSQL_DIGEST_END(LOCKER, DIGEST) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_START_STATEMENT(STATE, K, DB, DB_LEN, CS, SPS) \
|
||||
inline_mysql_start_statement(STATE, K, DB, DB_LEN, CS, SPS, __FILE__, __LINE__)
|
||||
#else
|
||||
#define MYSQL_START_STATEMENT(STATE, K, DB, DB_LEN, CS, SPS) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_REFINE_STATEMENT(LOCKER, K) \
|
||||
inline_mysql_refine_statement(LOCKER, K)
|
||||
#else
|
||||
#define MYSQL_REFINE_STATEMENT(LOCKER, K) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_SET_STATEMENT_TEXT(LOCKER, P1, P2) \
|
||||
inline_mysql_set_statement_text(LOCKER, P1, P2)
|
||||
#else
|
||||
#define MYSQL_SET_STATEMENT_TEXT(LOCKER, P1, P2) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_SET_STATEMENT_LOCK_TIME(LOCKER, P1) \
|
||||
inline_mysql_set_statement_lock_time(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_STATEMENT_LOCK_TIME(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_SET_STATEMENT_ROWS_SENT(LOCKER, P1) \
|
||||
inline_mysql_set_statement_rows_sent(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_STATEMENT_ROWS_SENT(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_SET_STATEMENT_ROWS_EXAMINED(LOCKER, P1) \
|
||||
inline_mysql_set_statement_rows_examined(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_STATEMENT_ROWS_EXAMINED(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
#define MYSQL_END_STATEMENT(LOCKER, DA) \
|
||||
inline_mysql_end_statement(LOCKER, DA)
|
||||
#else
|
||||
#define MYSQL_END_STATEMENT(LOCKER, DA) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_INTERFACE
|
||||
static inline void inline_mysql_statement_register(
|
||||
const char *category, PSI_statement_info *info, int count)
|
||||
{
|
||||
PSI_STATEMENT_CALL(register_statement)(category, info, count);
|
||||
}
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
|
||||
static inline struct PSI_digest_locker *
|
||||
inline_mysql_digest_start(PSI_statement_locker *locker)
|
||||
{
|
||||
PSI_digest_locker* digest_locker= NULL;
|
||||
|
||||
if (likely(locker != NULL))
|
||||
digest_locker= PSI_DIGEST_CALL(digest_start)(locker);
|
||||
return digest_locker;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
|
||||
static inline void
|
||||
inline_mysql_digest_end(PSI_digest_locker *locker, const sql_digest_storage *digest)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_DIGEST_CALL(digest_end)(locker, digest);
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline struct PSI_statement_locker *
|
||||
inline_mysql_start_statement(PSI_statement_locker_state *state,
|
||||
PSI_statement_key key,
|
||||
const char *db, uint db_len,
|
||||
const CHARSET_INFO *charset,
|
||||
PSI_sp_share *sp_share,
|
||||
const char *src_file, int src_line)
|
||||
{
|
||||
PSI_statement_locker *locker;
|
||||
locker= PSI_STATEMENT_CALL(get_thread_statement_locker)(state, key, charset,
|
||||
sp_share);
|
||||
if (likely(locker != NULL))
|
||||
PSI_STATEMENT_CALL(start_statement)(locker, db, db_len, src_file, src_line);
|
||||
return locker;
|
||||
}
|
||||
|
||||
static inline struct PSI_statement_locker *
|
||||
inline_mysql_refine_statement(PSI_statement_locker *locker,
|
||||
PSI_statement_key key)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
locker= PSI_STATEMENT_CALL(refine_statement)(locker, key);
|
||||
}
|
||||
return locker;
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_statement_text(PSI_statement_locker *locker,
|
||||
const char *text, uint text_len)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
PSI_STATEMENT_CALL(set_statement_text)(locker, text, text_len);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_statement_lock_time(PSI_statement_locker *locker,
|
||||
ulonglong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
PSI_STATEMENT_CALL(set_statement_lock_time)(locker, count);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_statement_rows_sent(PSI_statement_locker *locker,
|
||||
ulonglong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
PSI_STATEMENT_CALL(set_statement_rows_sent)(locker, count);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_statement_rows_examined(PSI_statement_locker *locker,
|
||||
ulonglong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
{
|
||||
PSI_STATEMENT_CALL(set_statement_rows_examined)(locker, count);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_end_statement(struct PSI_statement_locker *locker,
|
||||
Diagnostics_area *stmt_da)
|
||||
{
|
||||
PSI_STAGE_CALL(end_stage)();
|
||||
if (likely(locker != NULL))
|
||||
PSI_STATEMENT_CALL(end_statement)(locker, stmt_da);
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Statement_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,142 @@
|
||||
/* Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_TABLE_H
|
||||
#define MYSQL_TABLE_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_table.h
|
||||
Instrumentation helpers for table io.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_TABLE_CALL
|
||||
#define PSI_TABLE_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Table_instrumentation Table Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
@def MYSQL_TABLE_WAIT_VARIABLES
|
||||
Instrumentation helper for table waits.
|
||||
This instrumentation declares local variables.
|
||||
Do not use a ';' after this macro
|
||||
@param LOCKER the locker
|
||||
@param STATE the locker state
|
||||
@sa MYSQL_START_TABLE_IO_WAIT.
|
||||
@sa MYSQL_END_TABLE_IO_WAIT.
|
||||
@sa MYSQL_START_TABLE_LOCK_WAIT.
|
||||
@sa MYSQL_END_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
#define MYSQL_TABLE_WAIT_VARIABLES(LOCKER, STATE) \
|
||||
struct PSI_table_locker* LOCKER; \
|
||||
PSI_table_locker_state STATE;
|
||||
#else
|
||||
#define MYSQL_TABLE_WAIT_VARIABLES(LOCKER, STATE)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def MYSQL_START_TABLE_LOCK_WAIT
|
||||
Instrumentation helper for table lock waits.
|
||||
This instrumentation marks the start of a wait event.
|
||||
@param LOCKER the locker
|
||||
@param STATE the locker state
|
||||
@param PSI the instrumented table
|
||||
@param OP the table operation to be performed
|
||||
@param FLAGS per table operation flags.
|
||||
@sa MYSQL_END_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
#define MYSQL_START_TABLE_LOCK_WAIT(LOCKER, STATE, PSI, OP, FLAGS) \
|
||||
LOCKER= inline_mysql_start_table_lock_wait(STATE, PSI, \
|
||||
OP, FLAGS, __FILE__, __LINE__)
|
||||
#else
|
||||
#define MYSQL_START_TABLE_LOCK_WAIT(LOCKER, STATE, PSI, OP, FLAGS) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@def MYSQL_END_TABLE_LOCK_WAIT
|
||||
Instrumentation helper for table lock waits.
|
||||
This instrumentation marks the end of a wait event.
|
||||
@param LOCKER the locker
|
||||
@sa MYSQL_START_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
#define MYSQL_END_TABLE_LOCK_WAIT(LOCKER) \
|
||||
inline_mysql_end_table_lock_wait(LOCKER)
|
||||
#else
|
||||
#define MYSQL_END_TABLE_LOCK_WAIT(LOCKER) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
#define MYSQL_UNLOCK_TABLE(T) \
|
||||
inline_mysql_unlock_table(T)
|
||||
#else
|
||||
#define MYSQL_UNLOCK_TABLE(T) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TABLE_INTERFACE
|
||||
/**
|
||||
Instrumentation calls for MYSQL_START_TABLE_LOCK_WAIT.
|
||||
@sa MYSQL_END_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
static inline struct PSI_table_locker *
|
||||
inline_mysql_start_table_lock_wait(PSI_table_locker_state *state,
|
||||
struct PSI_table *psi,
|
||||
enum PSI_table_lock_operation op,
|
||||
ulong flags, const char *src_file, int src_line)
|
||||
{
|
||||
if (psi != NULL)
|
||||
{
|
||||
struct PSI_table_locker *locker;
|
||||
locker= PSI_TABLE_CALL(start_table_lock_wait)
|
||||
(state, psi, op, flags, src_file, src_line);
|
||||
return locker;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
Instrumentation calls for MYSQL_END_TABLE_LOCK_WAIT.
|
||||
@sa MYSQL_START_TABLE_LOCK_WAIT.
|
||||
*/
|
||||
static inline void
|
||||
inline_mysql_end_table_lock_wait(struct PSI_table_locker *locker)
|
||||
{
|
||||
if (locker != NULL)
|
||||
PSI_TABLE_CALL(end_table_lock_wait)(locker);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_unlock_table(struct PSI_table *table)
|
||||
{
|
||||
if (table != NULL)
|
||||
PSI_TABLE_CALL(unlock_table)(table);
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Table_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,213 @@
|
||||
/* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
||||
|
||||
#ifndef MYSQL_TRANSACTION_H
|
||||
#define MYSQL_TRANSACTION_H
|
||||
|
||||
/**
|
||||
@file mysql/psi/mysql_transaction.h
|
||||
Instrumentation helpers for transactions.
|
||||
*/
|
||||
|
||||
#include "mysql/psi/psi.h"
|
||||
|
||||
#ifndef PSI_TRANSACTION_CALL
|
||||
#define PSI_TRANSACTION_CALL(M) PSI_DYNAMIC_CALL(M)
|
||||
#endif
|
||||
|
||||
/**
|
||||
@defgroup Transaction_instrumentation Transaction Instrumentation
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_START_TRANSACTION(STATE, XID, TRXID, ISO, RO, AC) \
|
||||
inline_mysql_start_transaction(STATE, XID, TRXID, ISO, RO, AC, __FILE__, __LINE__)
|
||||
#else
|
||||
#define MYSQL_START_TRANSACTION(STATE, XID, TRXID, ISO, RO, AC) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_SET_TRANSACTION_GTID(LOCKER, P1, P2) \
|
||||
inline_mysql_set_transaction_gtid(LOCKER, P1, P2)
|
||||
#else
|
||||
#define MYSQL_SET_TRANSACTION_GTID(LOCKER, P1, P2) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_SET_TRANSACTION_XID(LOCKER, P1, P2) \
|
||||
inline_mysql_set_transaction_xid(LOCKER, P1, P2)
|
||||
#else
|
||||
#define MYSQL_SET_TRANSACTION_XID(LOCKER, P1, P2) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_SET_TRANSACTION_XA_STATE(LOCKER, P1) \
|
||||
inline_mysql_set_transaction_xa_state(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_TRANSACTION_XA_STATE(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_SET_TRANSACTION_TRXID(LOCKER, P1) \
|
||||
inline_mysql_set_transaction_trxid(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_SET_TRANSACTION_TRXID(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_INC_TRANSACTION_SAVEPOINTS(LOCKER, P1) \
|
||||
inline_mysql_inc_transaction_savepoints(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_INC_TRANSACTION_SAVEPOINTS(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_INC_TRANSACTION_ROLLBACK_TO_SAVEPOINT(LOCKER, P1) \
|
||||
inline_mysql_inc_transaction_rollback_to_savepoint(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_INC_TRANSACTION_ROLLBACK_TO_SAVEPOINT(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_INC_TRANSACTION_RELEASE_SAVEPOINT(LOCKER, P1) \
|
||||
inline_mysql_inc_transaction_release_savepoint(LOCKER, P1)
|
||||
#else
|
||||
#define MYSQL_INC_TRANSACTION_RELEASE_SAVEPOINT(LOCKER, P1) \
|
||||
do {} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_ROLLBACK_TRANSACTION(LOCKER) \
|
||||
inline_mysql_rollback_transaction(LOCKER)
|
||||
#else
|
||||
#define MYSQL_ROLLBACK_TRANSACTION(LOCKER) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
#define MYSQL_COMMIT_TRANSACTION(LOCKER) \
|
||||
inline_mysql_commit_transaction(LOCKER)
|
||||
#else
|
||||
#define MYSQL_COMMIT_TRANSACTION(LOCKER) \
|
||||
NULL
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
|
||||
static inline struct PSI_transaction_locker *
|
||||
inline_mysql_start_transaction(PSI_transaction_locker_state *state,
|
||||
const void *xid,
|
||||
const ulonglong *trxid,
|
||||
int isolation_level,
|
||||
my_bool read_only,
|
||||
my_bool autocommit,
|
||||
const char *src_file, int src_line)
|
||||
{
|
||||
PSI_transaction_locker *locker;
|
||||
locker= PSI_TRANSACTION_CALL(get_thread_transaction_locker)(state,
|
||||
xid, trxid,
|
||||
isolation_level,
|
||||
read_only,
|
||||
autocommit);
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(start_transaction)(locker, src_file, src_line);
|
||||
return locker;
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_transaction_gtid(PSI_transaction_locker *locker,
|
||||
const void *sid,
|
||||
const void *gtid_spec)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(set_transaction_gtid)(locker, sid, gtid_spec);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_transaction_xid(PSI_transaction_locker *locker,
|
||||
const void *xid,
|
||||
int xa_state)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(set_transaction_xid)(locker, xid, xa_state);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_transaction_xa_state(PSI_transaction_locker *locker,
|
||||
int xa_state)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(set_transaction_xa_state)(locker, xa_state);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_set_transaction_trxid(PSI_transaction_locker *locker,
|
||||
const ulonglong *trxid)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(set_transaction_trxid)(locker, trxid);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_inc_transaction_savepoints(PSI_transaction_locker *locker,
|
||||
ulong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(inc_transaction_savepoints)(locker, count);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_inc_transaction_rollback_to_savepoint(PSI_transaction_locker *locker,
|
||||
ulong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(inc_transaction_rollback_to_savepoint)(locker, count);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_inc_transaction_release_savepoint(PSI_transaction_locker *locker,
|
||||
ulong count)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(inc_transaction_release_savepoint)(locker, count);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_rollback_transaction(struct PSI_transaction_locker *locker)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(end_transaction)(locker, false);
|
||||
}
|
||||
|
||||
static inline void
|
||||
inline_mysql_commit_transaction(struct PSI_transaction_locker *locker)
|
||||
{
|
||||
if (likely(locker != NULL))
|
||||
PSI_TRANSACTION_CALL(end_transaction)(locker, true);
|
||||
}
|
||||
#endif
|
||||
|
||||
/** @} (end of group Transaction_instrumentation) */
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,155 @@
|
||||
/* Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_PSI_BASE_H
|
||||
#define MYSQL_PSI_BASE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
@file mysql/psi/psi_base.h
|
||||
Performance schema instrumentation interface.
|
||||
|
||||
@defgroup Instrumentation_interface Instrumentation Interface
|
||||
@ingroup Performance_schema
|
||||
@{
|
||||
*/
|
||||
|
||||
#define PSI_INSTRUMENT_ME 0
|
||||
|
||||
#define PSI_NOT_INSTRUMENTED 0
|
||||
|
||||
/**
|
||||
Global flag.
|
||||
This flag indicate that an instrumentation point is a global variable,
|
||||
or a singleton.
|
||||
*/
|
||||
#define PSI_FLAG_GLOBAL (1 << 0)
|
||||
|
||||
/**
|
||||
Mutable flag.
|
||||
This flag indicate that an instrumentation point is a general placeholder,
|
||||
that can mutate into a more specific instrumentation point.
|
||||
*/
|
||||
#define PSI_FLAG_MUTABLE (1 << 1)
|
||||
|
||||
#define PSI_FLAG_THREAD (1 << 2)
|
||||
|
||||
/**
|
||||
Stage progress flag.
|
||||
This flag apply to the stage instruments only.
|
||||
It indicates the instrumentation provides progress data.
|
||||
*/
|
||||
#define PSI_FLAG_STAGE_PROGRESS (1 << 3)
|
||||
|
||||
/**
|
||||
Shared Exclusive flag.
|
||||
Indicates that rwlock support the shared exclusive state.
|
||||
*/
|
||||
#define PSI_RWLOCK_FLAG_SX (1 << 4)
|
||||
|
||||
/**
|
||||
Transferable flag.
|
||||
This flag indicate that an instrumented object can
|
||||
be created by a thread and destroyed by another thread.
|
||||
*/
|
||||
#define PSI_FLAG_TRANSFER (1 << 5)
|
||||
|
||||
/**
|
||||
Volatility flag.
|
||||
This flag indicate that an instrumented object
|
||||
has a volatility (life cycle) comparable
|
||||
to the volatility of a session.
|
||||
*/
|
||||
#define PSI_FLAG_VOLATILITY_SESSION (1 << 6)
|
||||
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
|
||||
/**
|
||||
@def PSI_VERSION_1
|
||||
Performance Schema Interface number for version 1.
|
||||
This version is supported.
|
||||
*/
|
||||
#define PSI_VERSION_1 1
|
||||
|
||||
/**
|
||||
@def PSI_VERSION_2
|
||||
Performance Schema Interface number for version 2.
|
||||
This version is not implemented, it's a placeholder.
|
||||
*/
|
||||
#define PSI_VERSION_2 2
|
||||
|
||||
/**
|
||||
@def PSI_CURRENT_VERSION
|
||||
Performance Schema Interface number for the most recent version.
|
||||
The most current version is @c PSI_VERSION_1
|
||||
*/
|
||||
#define PSI_CURRENT_VERSION 1
|
||||
|
||||
/**
|
||||
@def USE_PSI_1
|
||||
Define USE_PSI_1 to use the interface version 1.
|
||||
*/
|
||||
|
||||
/**
|
||||
@def USE_PSI_2
|
||||
Define USE_PSI_2 to use the interface version 2.
|
||||
*/
|
||||
|
||||
/**
|
||||
@def HAVE_PSI_1
|
||||
Define HAVE_PSI_1 if the interface version 1 needs to be compiled in.
|
||||
*/
|
||||
|
||||
/**
|
||||
@def HAVE_PSI_2
|
||||
Define HAVE_PSI_2 if the interface version 2 needs to be compiled in.
|
||||
*/
|
||||
|
||||
#ifndef USE_PSI_2
|
||||
#ifndef USE_PSI_1
|
||||
#define USE_PSI_1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef USE_PSI_1
|
||||
#define HAVE_PSI_1
|
||||
#endif
|
||||
|
||||
#ifdef USE_PSI_2
|
||||
#define HAVE_PSI_2
|
||||
#endif
|
||||
|
||||
/*
|
||||
Allow to override PSI_XXX_CALL at compile time
|
||||
with more efficient implementations, if available.
|
||||
If nothing better is available,
|
||||
make a dynamic call using the PSI_server function pointer.
|
||||
*/
|
||||
|
||||
#define PSI_DYNAMIC_CALL(M) PSI_server->M
|
||||
|
||||
#endif /* HAVE_PSI_INTERFACE */
|
||||
|
||||
/** @} */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* MYSQL_PSI_BASE_H */
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software 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,
|
||||
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
|
||||
|
||||
#ifndef MYSQL_PSI_MEMORY_H
|
||||
#define MYSQL_PSI_MEMORY_H
|
||||
|
||||
#include "psi_base.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
@file mysql/psi/psi_memory.h
|
||||
Performance schema instrumentation interface.
|
||||
|
||||
@defgroup Instrumentation_interface Instrumentation Interface
|
||||
@ingroup Performance_schema
|
||||
@{
|
||||
*/
|
||||
|
||||
#ifdef HAVE_PSI_INTERFACE
|
||||
#ifndef DISABLE_ALL_PSI
|
||||
#ifndef DISABLE_PSI_MEMORY
|
||||
#define HAVE_PSI_MEMORY_INTERFACE
|
||||
#endif /* DISABLE_PSI_MEMORY */
|
||||
#endif /* DISABLE_ALL_PSI */
|
||||
#endif /* HAVE_PSI_INTERFACE */
|
||||
|
||||
struct PSI_thread;
|
||||
|
||||
/**
|
||||
Instrumented memory key.
|
||||
To instrument memory, a memory key must be obtained using @c register_memory.
|
||||
Using a zero key always disable the instrumentation.
|
||||
*/
|
||||
typedef unsigned int PSI_memory_key;
|
||||
|
||||
#ifdef HAVE_PSI_1
|
||||
|
||||
/**
|
||||
@defgroup Group_PSI_v1 Application Binary Interface, version 1
|
||||
@ingroup Instrumentation_interface
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
Memory instrument information.
|
||||
@since PSI_VERSION_1
|
||||
This structure is used to register instrumented memory.
|
||||
*/
|
||||
struct PSI_memory_info_v1
|
||||
{
|
||||
/** Pointer to the key assigned to the registered memory. */
|
||||
PSI_memory_key *m_key;
|
||||
/** The name of the memory instrument to register. */
|
||||
const char *m_name;
|
||||
/**
|
||||
The flags of the socket instrument to register.
|
||||
@sa PSI_FLAG_GLOBAL
|
||||
*/
|
||||
int m_flags;
|
||||
};
|
||||
typedef struct PSI_memory_info_v1 PSI_memory_info_v1;
|
||||
|
||||
/**
|
||||
Memory registration API.
|
||||
@param category a category name (typically a plugin name)
|
||||
@param info an array of memory info to register
|
||||
@param count the size of the info array
|
||||
*/
|
||||
typedef void (*register_memory_v1_t)
|
||||
(const char *category, struct PSI_memory_info_v1 *info, int count);
|
||||
|
||||
/**
|
||||
Instrument memory allocation.
|
||||
@param key the memory instrument key
|
||||
@param size the size of memory allocated
|
||||
@param[out] owner the memory owner
|
||||
@return the effective memory instrument key
|
||||
*/
|
||||
typedef PSI_memory_key (*memory_alloc_v1_t)
|
||||
(PSI_memory_key key, size_t size, struct PSI_thread ** owner);
|
||||
|
||||
/**
|
||||
Instrument memory re allocation.
|
||||
@param key the memory instrument key
|
||||
@param old_size the size of memory previously allocated
|
||||
@param new_size the size of memory re allocated
|
||||
@param[in, out] owner the memory owner
|
||||
@return the effective memory instrument key
|
||||
*/
|
||||
typedef PSI_memory_key (*memory_realloc_v1_t)
|
||||
(PSI_memory_key key, size_t old_size, size_t new_size, struct PSI_thread ** owner);
|
||||
|
||||
/**
|
||||
Instrument memory claim.
|
||||
@param key the memory instrument key
|
||||
@param size the size of memory allocated
|
||||
@param[in, out] owner the memory owner
|
||||
@return the effective memory instrument key
|
||||
*/
|
||||
typedef PSI_memory_key (*memory_claim_v1_t)
|
||||
(PSI_memory_key key, size_t size, struct PSI_thread ** owner);
|
||||
|
||||
/**
|
||||
Instrument memory free.
|
||||
@param key the memory instrument key
|
||||
@param size the size of memory allocated
|
||||
@param owner the memory owner
|
||||
*/
|
||||
typedef void (*memory_free_v1_t)
|
||||
(PSI_memory_key key, size_t size, struct PSI_thread * owner);
|
||||
|
||||
/** @} (end of group Group_PSI_v1) */
|
||||
|
||||
#endif /* HAVE_PSI_1 */
|
||||
|
||||
#ifdef HAVE_PSI_2
|
||||
struct PSI_memory_info_v2
|
||||
{
|
||||
int placeholder;
|
||||
};
|
||||
|
||||
#endif /* HAVE_PSI_2 */
|
||||
|
||||
#ifdef USE_PSI_1
|
||||
typedef struct PSI_memory_info_v1 PSI_memory_info;
|
||||
#endif
|
||||
|
||||
#ifdef USE_PSI_2
|
||||
typedef struct PSI_memory_info_v2 PSI_memory_info;
|
||||
#endif
|
||||
|
||||
/** @} (end of group Instrumentation_interface) */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* MYSQL_PSI_MEMORY_H */
|
||||
|
||||
Reference in New Issue
Block a user