mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-17 20:42:30 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/storage/perfschema/pfs_instr.h
Oleksandr Byelkin ade89fc898 Merge branch '10.2' into 10.3
2020-01-21 09:11:14 +01:00

705 lines
21 KiB
C++
Raw Blame History

/* Copyright (c) 2008, 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, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
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, version 2.0, 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, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef PFS_INSTR_H
#define PFS_INSTR_H
/**
@file storage/perfschema/pfs_instr.h
Performance schema instruments (declarations).
*/
struct PFS_mutex_class;
struct PFS_rwlock_class;
struct PFS_cond_class;
struct PFS_file_class;
struct PFS_table_share;
struct PFS_thread_class;
struct PFS_socket_class;
#include "my_global.h"
#ifdef __WIN__
#include <winsock2.h>
#else
#include <arpa/inet.h>
#endif
#include "my_compiler.h"
#include "pfs_lock.h"
#include "pfs_stat.h"
#include "pfs_instr_class.h"
#include "pfs_events_waits.h"
#include "pfs_events_stages.h"
#include "pfs_events_statements.h"
#include "pfs_server.h"
#include "lf.h"
#include "pfs_con_slice.h"
/**
@addtogroup Performance_schema_buffers
@{
*/
struct PFS_thread;
struct PFS_host;
struct PFS_user;
struct PFS_account;
/** Base structure for wait instruments. */
struct PFS_instr
{
/** Internal lock. */
pfs_lock m_lock;
/** Enabled flag. */
bool m_enabled;
/** Timed flag. */
bool m_timed;
};
/** Instrumented mutex implementation. @see PSI_mutex. */
struct PFS_ALIGNED PFS_mutex : public PFS_instr
{
/** Mutex identity, typically a pthread_mutex_t. */
const void *m_identity;
/** Mutex class. */
PFS_mutex_class *m_class;
/** Instrument statistics. */
PFS_mutex_stat m_mutex_stat;
/** Current owner. */
PFS_thread *m_owner;
/**
Timestamp of the last lock.
This statistic is not exposed in user visible tables yet.
*/
ulonglong m_last_locked;
};
/** Instrumented rwlock implementation. @see PSI_rwlock. */
struct PFS_ALIGNED PFS_rwlock : public PFS_instr
{
/** RWLock identity, typically a pthread_rwlock_t. */
const void *m_identity;
/** RWLock class. */
PFS_rwlock_class *m_class;
/** Instrument statistics. */
PFS_rwlock_stat m_rwlock_stat;
/** Current writer thread. */
PFS_thread *m_writer;
/** Current count of readers. */
uint m_readers;
/**
Timestamp of the last write.
This statistic is not exposed in user visible tables yet.
*/
ulonglong m_last_written;
/**
Timestamp of the last read.
This statistic is not exposed in user visible tables yet.
*/
ulonglong m_last_read;
};
/** Instrumented cond implementation. @see PSI_cond. */
struct PFS_ALIGNED PFS_cond : public PFS_instr
{
/** Condition identity, typically a pthread_cond_t. */
const void *m_identity;
/** Condition class. */
PFS_cond_class *m_class;
/** Instrument wait statistics. */
PFS_single_stat m_wait_stat;
/** Condition instance usage statistics. */
PFS_cond_stat m_cond_stat;
};
/** Instrumented File and FILE implementation. @see PSI_file. */
struct PFS_ALIGNED PFS_file : public PFS_instr
{
uint32 get_version()
{ return m_lock.get_version(); }
/** File identity */
const void *m_identity;
/** File name. */
char m_filename[FN_REFLEN];
/** File name length in bytes. */
uint m_filename_length;
/** File class. */
PFS_file_class *m_class;
/** File usage statistics. */
PFS_file_stat m_file_stat;
};
/** Instrumented table implementation. @see PSI_table. */
struct PFS_ALIGNED PFS_table
{
/**
True if table io instrumentation is enabled.
This flag is computed.
*/
bool m_io_enabled;
/**
True if table lock instrumentation is enabled.
This flag is computed.
*/
bool m_lock_enabled;
/**
True if table io instrumentation is timed.
This flag is computed.
*/
bool m_io_timed;
/**
True if table lock instrumentation is timed.
This flag is computed.
*/
bool m_lock_timed;
/** True if table io statistics have been collected. */
bool m_has_io_stats;
/** True if table lock statistics have been collected. */
bool m_has_lock_stats;
public:
/**
Aggregate this table handle statistics to the parents.
Only use this method for handles owned by the calling code.
@sa sanitized_aggregate.
*/
void aggregate(void)
{
if (m_has_io_stats && m_has_lock_stats)
{
safe_aggregate(& m_table_stat, m_share);
m_has_io_stats= false;
m_has_lock_stats= false;
}
else if (m_has_io_stats)
{
safe_aggregate_io(& m_table_stat, m_share);
m_has_io_stats= false;
}
else if (m_has_lock_stats)
{
safe_aggregate_lock(& m_table_stat, m_share);
m_has_lock_stats= false;
}
}
/**
Aggregate this table handle statistics to the parents.
This method is safe to call on handles not owned by the calling code.
@sa aggregate
@sa sanitized_aggregate_io
@sa sanitized_aggregate_lock
*/
void sanitized_aggregate(void);
/**
Aggregate this table handle io statistics to the parents.
This method is safe to call on handles not owned by the calling code.
*/
void sanitized_aggregate_io(void);
/**
Aggregate this table handle lock statistics to the parents.
This method is safe to call on handles not owned by the calling code.
*/
void sanitized_aggregate_lock(void);
/** Internal lock. */
pfs_lock m_lock;
/** Owner. */
PFS_thread *m_thread_owner;
/** Table share. */
PFS_table_share *m_share;
/** Table identity, typically a handler. */
const void *m_identity;
/** Table statistics. */
PFS_table_stat m_table_stat;
private:
static void safe_aggregate(PFS_table_stat *stat,
PFS_table_share *safe_share);
static void safe_aggregate_io(PFS_table_stat *stat,
PFS_table_share *safe_share);
static void safe_aggregate_lock(PFS_table_stat *stat,
PFS_table_share *safe_share);
};
/** Instrumented socket implementation. @see PSI_socket. */
struct PFS_ALIGNED PFS_socket : public PFS_instr
{
uint32 get_version()
{ return m_lock.get_version(); }
/** Socket identity, typically int */
const void *m_identity;
/** Owning thread, if applicable */
PFS_thread *m_thread_owner;
/** Socket file descriptor */
uint m_fd;
/** Raw socket address */
struct sockaddr_storage m_sock_addr;
/** Length of address */
socklen_t m_addr_len;
/** Idle flag. */
bool m_idle;
/** Socket class. */
PFS_socket_class *m_class;
/** Socket usage statistics. */
PFS_socket_stat m_socket_stat;
};
/**
@def WAIT_STACK_LOGICAL_SIZE
Maximum number of nested waits.
Some waits, such as:
- "wait/io/table/sql/handler"
- "wait/lock/table/sql/handler"
are implemented by calling code in a storage engine,
that can cause nested waits (file io, mutex, ...)
Because of partitioned tables, a table io event (on the whole table)
can contain a nested table io event (on a partition).
Because of additional debug instrumentation,
waiting on what looks like a "mutex" (safe_mutex, innodb sync0sync, ...)
can cause nested waits to be recorded.
For example, a wait on innodb mutexes can lead to:
- wait/sync/mutex/innobase/some_mutex
- wait/sync/mutex/innobase/sync0sync
- wait/sync/mutex/innobase/os0sync
The max depth of the event stack must be sufficient
for these low level details to be visible.
*/
#define WAIT_STACK_LOGICAL_SIZE 5
/**
@def WAIT_STACK_BOTTOM
Maximum number dummy waits records.
One dummy record is reserved for the parent stage / statement,
at the bottom of the wait stack.
*/
#define WAIT_STACK_BOTTOM 1
/**
@def WAIT_STACK_SIZE
Physical size of the waits stack
*/
#define WAIT_STACK_SIZE (WAIT_STACK_BOTTOM + WAIT_STACK_LOGICAL_SIZE)
/** Max size of the statements stack. */
extern uint statement_stack_max;
/** Max size of the digests token array. */
extern size_t pfs_max_digest_length;
/**
@def PFS_MAX_ALLOC_RETRY
Maximum number of times the code attempts to allocate an item
from internal buffers, before giving up.
*/
#define PFS_MAX_ALLOC_RETRY 1000
/** The maximun number of passes in @sa PFS_scan. */
#define PFS_MAX_SCAN_PASS 2
/**
Helper to scan circular buffers.
Given a buffer of size [0, max_size - 1],
and a random starting point in the buffer,
this helper returns up to two [first, last -1] intervals that:
- fit into the [0, max_size - 1] range,
- have a maximum combined length of at most PFS_MAX_ALLOC_RETRY.
*/
struct PFS_scan
{
public:
/**
Initialize a new scan.
@param random a random index to start from
@param max_size the max size of the interval to scan
*/
void init(uint random, uint max_size);
/**
Predicate, has a next pass.
@return true if there is a next pass to perform.
*/
bool has_pass() const
{ return (m_pass < m_pass_max); }
/**
Iterator, proceed to the next pass.
*/
void next_pass()
{ m_pass++; }
/** First index for this pass. */
uint first() const
{ return m_first[m_pass]; }
/** Last index for this pass. */
uint last() const
{ return m_last[m_pass]; }
private:
/** Current pass. */
uint m_pass;
/** Maximum number of passes. */
uint m_pass_max;
/** First element for each pass. */
uint m_first[PFS_MAX_SCAN_PASS];
/** Last element for each pass. */
uint m_last[PFS_MAX_SCAN_PASS];
};
/** Instrumented thread implementation. @see PSI_thread. */
struct PFS_ALIGNED PFS_thread : PFS_connection_slice
{
static PFS_thread* get_current_thread(void);
/** Thread instrumentation flag. */
bool m_enabled;
/** Current wait event in the event stack. */
PFS_events_waits *m_events_waits_current;
/** Event ID counter */
ulonglong m_event_id;
/**
Internal lock.
This lock is exclusively used to protect against races
when creating and destroying PFS_thread.
Do not use this lock to protect thread attributes,
use one of @c m_stmt_lock or @c m_session_lock instead.
*/
pfs_lock m_lock;
/** Pins for filename_hash. */
LF_PINS *m_filename_hash_pins;
/** Pins for table_share_hash. */
LF_PINS *m_table_share_hash_pins;
/** Pins for setup_actor_hash. */
LF_PINS *m_setup_actor_hash_pins;
/** Pins for setup_object_hash. */
LF_PINS *m_setup_object_hash_pins;
/** Pins for host_hash. */
LF_PINS *m_host_hash_pins;
/** Pins for user_hash. */
LF_PINS *m_user_hash_pins;
/** Pins for account_hash. */
LF_PINS *m_account_hash_pins;
/** Pins for digest_hash. */
LF_PINS *m_digest_hash_pins;
/** Internal thread identifier, unique. */
ulonglong m_thread_internal_id;
/** Parent internal thread identifier. */
ulonglong m_parent_thread_internal_id;
/** External (SHOW PROCESSLIST) thread identifier, not unique. */
ulong m_processlist_id;
/** Thread class. */
PFS_thread_class *m_class;
/**
Stack of events waits.
This member holds the data for the table PERFORMANCE_SCHEMA.EVENTS_WAITS_CURRENT.
Note that stack[0] is a dummy record that represents the parent stage/statement.
For example, assuming the following tree:
- STAGE ID 100
- WAIT ID 101, parent STAGE 100
- WAIT ID 102, parent wait 101
the data in the stack will be:
stack[0].m_event_id= 100, set by the stage instrumentation
stack[0].m_event_type= STAGE, set by the stage instrumentation
stack[0].m_nesting_event_id= unused
stack[0].m_nesting_event_type= unused
stack[1].m_event_id= 101
stack[1].m_event_type= WAIT
stack[1].m_nesting_event_id= stack[0].m_event_id= 100
stack[1].m_nesting_event_type= stack[0].m_event_type= STAGE
stack[2].m_event_id= 102
stack[2].m_event_type= WAIT
stack[2].m_nesting_event_id= stack[1].m_event_id= 101
stack[2].m_nesting_event_type= stack[1].m_event_type= WAIT
The whole point of the stack[0] record is to allow this optimization
in the code, in the instrumentation for wait events:
wait->m_nesting_event_id= (wait-1)->m_event_id;
wait->m_nesting_event_type= (wait-1)->m_event_type;
This code works for both the top level wait, and nested waits,
and works without if conditions, which helps performances.
*/
PFS_events_waits m_events_waits_stack[WAIT_STACK_SIZE];
/** True if the circular buffer @c m_waits_history is full. */
bool m_waits_history_full;
/** Current index in the circular buffer @c m_waits_history. */
uint m_waits_history_index;
/**
Waits history circular buffer.
This member holds the data for the table
PERFORMANCE_SCHEMA.EVENTS_WAITS_HISTORY.
*/
PFS_events_waits *m_waits_history;
/** True if the circular buffer @c m_stages_history is full. */
bool m_stages_history_full;
/** Current index in the circular buffer @c m_stages_history. */
uint m_stages_history_index;
/**
Stages history circular buffer.
This member holds the data for the table
PERFORMANCE_SCHEMA.EVENTS_STAGES_HISTORY.
*/
PFS_events_stages *m_stages_history;
/** True if the circular buffer @c m_statements_history is full. */
bool m_statements_history_full;
/** Current index in the circular buffer @c m_statements_history. */
uint m_statements_history_index;
/**
Statements history circular buffer.
This member holds the data for the table
PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_HISTORY.
*/
PFS_events_statements *m_statements_history;
/**
Internal lock, for session attributes.
Statement attributes are expected to be updated in frequently,
typically per session execution.
*/
pfs_lock m_session_lock;
/**
User name.
Protected by @c m_session_lock.
*/
char m_username[USERNAME_LENGTH];
/**
Length of @c m_username.
Protected by @c m_session_lock.
*/
uint m_username_length;
/**
Host name.
Protected by @c m_session_lock.
*/
char m_hostname[HOSTNAME_LENGTH];
/**
Length of @c m_hostname.
Protected by @c m_session_lock.
*/
uint m_hostname_length;
/**
Database name.
Protected by @c m_stmt_lock.
*/
char m_dbname[NAME_LEN];
/**
Length of @c m_dbname.
Protected by @c m_stmt_lock.
*/
uint m_dbname_length;
/** Current command. */
int m_command;
/** Start time. */
time_t m_start_time;
/**
Internal lock, for statement attributes.
Statement attributes are expected to be updated frequently,
typically per statement execution.
*/
pfs_lock m_stmt_lock;
/** Processlist state (derived from stage). */
PFS_stage_key m_stage;
/**
Processlist info.
Protected by @c m_stmt_lock.
*/
char m_processlist_info[COL_INFO_SIZE];
/**
Length of @c m_processlist_info_length.
Protected by @c m_stmt_lock.
*/
uint m_processlist_info_length;
PFS_events_stages m_stage_current;
/** Size of @c m_events_statements_stack. */
uint m_events_statements_count;
PFS_events_statements *m_statement_stack;
PFS_host *m_host;
PFS_user *m_user;
PFS_account *m_account;
/** Reset session connect attributes */
void reset_session_connect_attrs();
/**
Buffer for the connection attributes.
Protected by @c m_session_lock.
*/
char *m_session_connect_attrs;
/**
Length used by @c m_connect_attrs.
Protected by @c m_session_lock.
*/
uint m_session_connect_attrs_length;
/**
Character set in which @c m_connect_attrs are encoded.
Protected by @c m_session_lock.
*/
uint m_session_connect_attrs_cs_number;
};
extern PFS_stage_stat *global_instr_class_stages_array;
extern PFS_statement_stat *global_instr_class_statements_array;
PFS_mutex *sanitize_mutex(PFS_mutex *unsafe);
PFS_rwlock *sanitize_rwlock(PFS_rwlock *unsafe);
PFS_cond *sanitize_cond(PFS_cond *unsafe);
PFS_thread *sanitize_thread(PFS_thread *unsafe);
PFS_file *sanitize_file(PFS_file *unsafe);
PFS_socket *sanitize_socket(PFS_socket *unsafe);
int init_instruments(const PFS_global_param *param);
void cleanup_instruments();
int init_file_hash();
void cleanup_file_hash();
PFS_mutex* create_mutex(PFS_mutex_class *mutex_class, const void *identity);
void destroy_mutex(PFS_mutex *pfs);
PFS_rwlock* create_rwlock(PFS_rwlock_class *klass, const void *identity);
void destroy_rwlock(PFS_rwlock *pfs);
PFS_cond* create_cond(PFS_cond_class *klass, const void *identity);
void destroy_cond(PFS_cond *pfs);
PFS_thread* create_thread(PFS_thread_class *klass, const void *identity,
ulonglong processlist_id);
void destroy_thread(PFS_thread *pfs);
PFS_file* find_or_create_file(PFS_thread *thread, PFS_file_class *klass,
const char *filename, uint len, bool create);
void release_file(PFS_file *pfs);
void destroy_file(PFS_thread *thread, PFS_file *pfs);
PFS_table* create_table(PFS_table_share *share, PFS_thread *opening_thread,
const void *identity);
void destroy_table(PFS_table *pfs);
PFS_socket* create_socket(PFS_socket_class *socket_class,
const my_socket *fd,
const struct sockaddr *addr,
socklen_t addr_len);
void destroy_socket(PFS_socket *pfs);
/* For iterators and show status. */
extern ulong mutex_max;
extern ulong mutex_lost;
extern ulong rwlock_max;
extern ulong rwlock_lost;
extern ulong cond_max;
extern ulong cond_lost;
extern ulong thread_max;
extern ulong thread_lost;
extern ulong file_max;
extern ulong file_lost;
extern long file_handle_max;
extern ulong file_handle_lost;
extern ulong table_max;
extern ulong table_lost;
extern ulong socket_max;
extern ulong socket_lost;
extern ulong events_waits_history_per_thread;
extern ulong events_stages_history_per_thread;
extern ulong events_statements_history_per_thread;
extern ulong locker_lost;
extern ulong statement_lost;
extern ulong session_connect_attrs_lost;
extern ulong session_connect_attrs_size_per_thread;
/* Exposing the data directly, for iterators. */
extern PFS_mutex *mutex_array;
extern PFS_rwlock *rwlock_array;
extern PFS_cond *cond_array;
extern PFS_thread *thread_array;
extern PFS_file *file_array;
extern PFS_file **file_handle_array;
extern PFS_table *table_array;
extern PFS_socket *socket_array;
void reset_events_waits_by_instance();
void reset_file_instance_io();
void reset_socket_instance_io();
void aggregate_all_event_names(PFS_single_stat *from_array,
PFS_single_stat *to_array);
void aggregate_all_event_names(PFS_single_stat *from_array,
PFS_single_stat *to_array_1,
PFS_single_stat *to_array_2);
void aggregate_all_stages(PFS_stage_stat *from_array,
PFS_stage_stat *to_array);
void aggregate_all_stages(PFS_stage_stat *from_array,
PFS_stage_stat *to_array_1,
PFS_stage_stat *to_array_2);
void aggregate_all_statements(PFS_statement_stat *from_array,
PFS_statement_stat *to_array);
void aggregate_all_statements(PFS_statement_stat *from_array,
PFS_statement_stat *to_array_1,
PFS_statement_stat *to_array_2);
void aggregate_thread(PFS_thread *thread,
PFS_account *safe_account,
PFS_user *safe_user,
PFS_host *safe_host);
void aggregate_thread_waits(PFS_thread *thread,
PFS_account *safe_account,
PFS_user *safe_user,
PFS_host *safe_host);
void aggregate_thread_stages(PFS_thread *thread,
PFS_account *safe_account,
PFS_user *safe_user,
PFS_host *safe_host);
void aggregate_thread_statements(PFS_thread *thread,
PFS_account *safe_account,
PFS_user *safe_user,
PFS_host *safe_host);
void clear_thread_account(PFS_thread *thread);
void set_thread_account(PFS_thread *thread);
/** Update derived flags for all mutex instances. */
void update_mutex_derived_flags();
/** Update derived flags for all rwlock instances. */
void update_rwlock_derived_flags();
/** Update derived flags for all condition instances. */
void update_cond_derived_flags();
/** Update derived flags for all file handles. */
void update_file_derived_flags();
/** Update derived flags for all table handles. */
void update_table_derived_flags();
/** Update derived flags for all socket instances. */
void update_socket_derived_flags();
/** Update derived flags for all instruments. */
void update_instruments_derived_flags();
extern LF_HASH filename_hash;
/** @} */
#endif
Reference in a new issue View git blame Copy permalink