From 3f619478f796eddbba6e39502fe941b285dd97b1 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 4 May 2024 20:00:34 +0200 Subject: Adding upstream version 1:10.11.6. Signed-off-by: Daniel Baumann --- storage/perfschema/pfs_instr_class.cc | 2064 +++++++++++++++++++++++++++++++++ 1 file changed, 2064 insertions(+) create mode 100644 storage/perfschema/pfs_instr_class.cc (limited to 'storage/perfschema/pfs_instr_class.cc') diff --git a/storage/perfschema/pfs_instr_class.cc b/storage/perfschema/pfs_instr_class.cc new file mode 100644 index 00000000..2b1a80d3 --- /dev/null +++ b/storage/perfschema/pfs_instr_class.cc @@ -0,0 +1,2064 @@ +/* Copyright (c) 2008, 2023, Oracle and/or its affiliates. + Copyright (c) 2020, MariaDB Corporation. + + 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 */ + +/** + @file storage/perfschema/pfs_instr_class.cc + Performance schema instruments meta data (implementation). +*/ + +#include "my_global.h" +#include "my_sys.h" +#include "table.h" +#include "pfs_instr_class.h" +#include "pfs_builtin_memory.h" +#include "pfs_instr.h" +#include "pfs_global.h" +#include "pfs_timer.h" +#include "pfs_events_waits.h" +#include "pfs_setup_object.h" +#include "pfs_atomic.h" +#include "pfs_program.h" +#include "pfs_buffer_container.h" +#include "mysql/psi/mysql_thread.h" +#include "lf.h" + +#include + +/** + @defgroup Performance_schema_buffers Performance Schema Buffers + @ingroup Performance_schema_implementation + @{ +*/ + +/** + Global performance schema flag. + Indicate if the performance schema is enabled. + This flag is set at startup, and never changes. +*/ +my_bool pfs_enabled= TRUE; + +/** + PFS_INSTRUMENT option settings array + */ +Pfs_instr_config_array *pfs_instr_config_array= NULL; + +static void configure_instr_class(PFS_instr_class *entry); + +static void init_instr_class(PFS_instr_class *klass, + const char *name, + uint name_length, + int flags, + PFS_class_type class_type); + +/** + Current number of elements in mutex_class_array. + This global variable is written to during: + - the performance schema initialization + - a plugin initialization +*/ +static uint32 mutex_class_dirty_count= 0; +static uint32 mutex_class_allocated_count= 0; +static uint32 rwlock_class_dirty_count= 0; +static uint32 rwlock_class_allocated_count= 0; +static uint32 cond_class_dirty_count= 0; +static uint32 cond_class_allocated_count= 0; + +/** Size of the mutex class array. @sa mutex_class_array */ +ulong mutex_class_max= 0; +/** Number of mutex class lost. @sa mutex_class_array */ +ulong mutex_class_lost= 0; +/** Size of the rwlock class array. @sa rwlock_class_array */ +ulong rwlock_class_max= 0; +/** Number of rwlock class lost. @sa rwlock_class_array */ +ulong rwlock_class_lost= 0; +/** Size of the condition class array. @sa cond_class_array */ +ulong cond_class_max= 0; +/** Number of condition class lost. @sa cond_class_array */ +ulong cond_class_lost= 0; +/** Size of the thread class array. @sa thread_class_array */ +ulong thread_class_max= 0; +/** Number of thread class lost. @sa thread_class_array */ +ulong thread_class_lost= 0; +/** Size of the file class array. @sa file_class_array */ +ulong file_class_max= 0; +/** Number of file class lost. @sa file_class_array */ +ulong file_class_lost= 0; +/** Size of the stage class array. @sa stage_class_array */ +ulong stage_class_max= 0; +/** Number of stage class lost. @sa stage_class_array */ +ulong stage_class_lost= 0; +/** Size of the statement class array. @sa statement_class_array */ +ulong statement_class_max= 0; +/** Number of statement class lost. @sa statement_class_array */ +ulong statement_class_lost= 0; +/** Size of the socket class array. @sa socket_class_array */ +ulong socket_class_max= 0; +/** Number of socket class lost. @sa socket_class_array */ +ulong socket_class_lost= 0; +/** Size of the memory class array. @sa memory_class_array */ +ulong memory_class_max= 0; +/** Number of memory class lost. @sa memory_class_array */ +ulong memory_class_lost= 0; + +/** + Number of transaction classes. Although there is only one transaction class, + this is used for sizing by other event classes. + @sa global_transaction_class +*/ +ulong transaction_class_max= 0; + +PFS_mutex_class *mutex_class_array= NULL; +PFS_rwlock_class *rwlock_class_array= NULL; +PFS_cond_class *cond_class_array= NULL; + +/** + Current number or elements in thread_class_array. + This global variable is written to during: + - the performance schema initialization + - a plugin initialization +*/ +static uint32 thread_class_dirty_count= 0; +static uint32 thread_class_allocated_count= 0; + +static PFS_thread_class *thread_class_array= NULL; + +PFS_ALIGNED PFS_single_stat global_idle_stat; +PFS_ALIGNED PFS_table_io_stat global_table_io_stat; +PFS_ALIGNED PFS_table_lock_stat global_table_lock_stat; +PFS_ALIGNED PFS_single_stat global_metadata_stat; +PFS_ALIGNED PFS_transaction_stat global_transaction_stat; +PFS_ALIGNED PFS_instr_class global_table_io_class; +PFS_ALIGNED PFS_instr_class global_table_lock_class; +PFS_ALIGNED PFS_instr_class global_idle_class; +PFS_ALIGNED PFS_instr_class global_metadata_class; +PFS_ALIGNED PFS_transaction_class global_transaction_class; + +/** Class-timer map */ +enum_timer_name *class_timers[] = +{&wait_timer, /* PFS_CLASS_NONE */ + &wait_timer, /* PFS_CLASS_MUTEX */ + &wait_timer, /* PFS_CLASS_RWLOCK */ + &wait_timer, /* PFS_CLASS_COND */ + &wait_timer, /* PFS_CLASS_FILE */ + &wait_timer, /* PFS_CLASS_TABLE */ + &stage_timer, /* PFS_CLASS_STAGE */ + &statement_timer, /* PFS_CLASS_STATEMENT */ + &transaction_timer, /* PFS_CLASS_TRANSACTION */ + &wait_timer, /* PFS_CLASS_SOCKET */ + &wait_timer, /* PFS_CLASS_TABLE_IO */ + &wait_timer, /* PFS_CLASS_TABLE_LOCK */ + &idle_timer, /* PFS_CLASS_IDLE */ + &wait_timer, /* PFS_CLASS_METADATA */ + &wait_timer /* PFS_CLASS_MEMORY */ +}; + +/** + Hash index for instrumented table shares. + This index is searched by table fully qualified name (@c PFS_table_share_key), + and points to instrumented table shares (@c PFS_table_share). + @sa PFS_table_share_key + @sa PFS_table_share + @sa table_share_hash_get_key + @sa get_table_share_hash_pins +*/ +LF_HASH table_share_hash; +/** True if table_share_hash is initialized. */ +static bool table_share_hash_inited= false; + +static uint32 file_class_dirty_count= 0; +static uint32 file_class_allocated_count= 0; + +PFS_file_class *file_class_array= NULL; + +static uint32 stage_class_dirty_count= 0; +static uint32 stage_class_allocated_count= 0; + +static PFS_stage_class *stage_class_array= NULL; + +static uint32 statement_class_dirty_count= 0; +static uint32 statement_class_allocated_count= 0; + +static PFS_statement_class *statement_class_array= NULL; + +static uint32 socket_class_dirty_count= 0; +static uint32 socket_class_allocated_count= 0; + +static PFS_socket_class *socket_class_array= NULL; + +static uint32 memory_class_dirty_count= 0; +static uint32 memory_class_allocated_count= 0; + +static PFS_memory_class *memory_class_array= NULL; + +uint mutex_class_start= 0; +uint rwlock_class_start= 0; +uint cond_class_start= 0; +uint file_class_start= 0; +uint wait_class_max= 0; +uint socket_class_start= 0; + +void init_event_name_sizing(const PFS_global_param *param) +{ + /* global table io, table lock, idle, metadata */ + mutex_class_start= COUNT_GLOBAL_EVENT_INDEX; + rwlock_class_start= mutex_class_start + param->m_mutex_class_sizing; + cond_class_start= rwlock_class_start + param->m_rwlock_class_sizing; + file_class_start= cond_class_start + param->m_cond_class_sizing; + socket_class_start= file_class_start + param->m_file_class_sizing; + wait_class_max= socket_class_start + param->m_socket_class_sizing; +} + +void register_global_classes() +{ + /* Table IO class */ + init_instr_class(&global_table_io_class, "wait/io/table/sql/handler", 25, + 0, PFS_CLASS_TABLE_IO); + global_table_io_class.m_event_name_index= GLOBAL_TABLE_IO_EVENT_INDEX; + configure_instr_class(&global_table_io_class); + + /* Table lock class */ + init_instr_class(&global_table_lock_class, "wait/lock/table/sql/handler", 27, + 0, PFS_CLASS_TABLE_LOCK); + global_table_lock_class.m_event_name_index= GLOBAL_TABLE_LOCK_EVENT_INDEX; + configure_instr_class(&global_table_lock_class); + + /* Idle class */ + init_instr_class(&global_idle_class, "idle", 4, + 0, PFS_CLASS_IDLE); + global_idle_class.m_event_name_index= GLOBAL_IDLE_EVENT_INDEX; + configure_instr_class(&global_idle_class); + + /* Metadata class */ + init_instr_class(&global_metadata_class, "wait/lock/metadata/sql/mdl", 26, + 0, PFS_CLASS_METADATA); + global_metadata_class.m_event_name_index= GLOBAL_METADATA_EVENT_INDEX; + global_metadata_class.m_enabled= false; /* Disabled by default */ + global_metadata_class.m_timed= false; + configure_instr_class(&global_metadata_class); + + /* Transaction class */ + init_instr_class(&global_transaction_class, "transaction", 11, + 0, PFS_CLASS_TRANSACTION); + global_transaction_class.m_event_name_index= GLOBAL_TRANSACTION_INDEX; + global_transaction_class.m_enabled= false; /* Disabled by default */ + global_transaction_class.m_timed= false; + configure_instr_class(&global_transaction_class); + transaction_class_max= 1; /* used for sizing by other event classes */ +} + +/** + Initialize the instrument synch class buffers. + @param mutex_class_sizing max number of mutex class + @param rwlock_class_sizing max number of rwlock class + @param cond_class_sizing max number of condition class + @return 0 on success +*/ +int init_sync_class(uint mutex_class_sizing, + uint rwlock_class_sizing, + uint cond_class_sizing) +{ + mutex_class_dirty_count= mutex_class_allocated_count= 0; + rwlock_class_dirty_count= rwlock_class_allocated_count= 0; + cond_class_dirty_count= cond_class_allocated_count= 0; + mutex_class_max= mutex_class_sizing; + rwlock_class_max= rwlock_class_sizing; + cond_class_max= cond_class_sizing; + mutex_class_lost= rwlock_class_lost= cond_class_lost= 0; + + mutex_class_array= NULL; + rwlock_class_array= NULL; + cond_class_array= NULL; + + if (mutex_class_max > 0) + { + mutex_class_array= PFS_MALLOC_ARRAY(& builtin_memory_mutex_class, + mutex_class_max, + sizeof(PFS_mutex_class), PFS_mutex_class, + MYF(MY_ZEROFILL)); + if (unlikely(mutex_class_array == NULL)) + return 1; + } + + if (rwlock_class_max > 0) + { + rwlock_class_array= PFS_MALLOC_ARRAY(& builtin_memory_rwlock_class, + rwlock_class_max, + sizeof(PFS_rwlock_class), PFS_rwlock_class, + MYF(MY_ZEROFILL)); + if (unlikely(rwlock_class_array == NULL)) + return 1; + } + + if (cond_class_max > 0) + { + cond_class_array= PFS_MALLOC_ARRAY(& builtin_memory_cond_class, + cond_class_max, + sizeof(PFS_cond_class), PFS_cond_class, + MYF(MY_ZEROFILL)); + if (unlikely(cond_class_array == NULL)) + return 1; + } + + return 0; +} + +/** Cleanup the instrument synch class buffers. */ +void cleanup_sync_class(void) +{ + PFS_FREE_ARRAY(& builtin_memory_mutex_class, + mutex_class_max, sizeof(PFS_mutex_class), + mutex_class_array); + mutex_class_array= NULL; + mutex_class_dirty_count= mutex_class_allocated_count= mutex_class_max= 0; + + PFS_FREE_ARRAY(& builtin_memory_rwlock_class, + rwlock_class_max, sizeof(PFS_rwlock_class), + rwlock_class_array); + rwlock_class_array= NULL; + rwlock_class_dirty_count= rwlock_class_allocated_count= rwlock_class_max= 0; + + PFS_FREE_ARRAY(& builtin_memory_cond_class, + cond_class_max, sizeof(PFS_cond_class), + cond_class_array); + cond_class_array= NULL; + cond_class_dirty_count= cond_class_allocated_count= cond_class_max= 0; +} + +/** + Initialize the thread class buffer. + @param thread_class_sizing max number of thread class + @return 0 on success +*/ +int init_thread_class(uint thread_class_sizing) +{ + int result= 0; + thread_class_dirty_count= thread_class_allocated_count= 0; + thread_class_max= thread_class_sizing; + thread_class_lost= 0; + + if (thread_class_max > 0) + { + thread_class_array= PFS_MALLOC_ARRAY(& builtin_memory_thread_class, + thread_class_max, + sizeof(PFS_thread_class), PFS_thread_class, + MYF(MY_ZEROFILL)); + if (unlikely(thread_class_array == NULL)) + result= 1; + } + else + thread_class_array= NULL; + + return result; +} + +/** Cleanup the thread class buffers. */ +void cleanup_thread_class(void) +{ + PFS_FREE_ARRAY(& builtin_memory_thread_class, + thread_class_max, sizeof(PFS_thread_class), + thread_class_array); + thread_class_array= NULL; + thread_class_dirty_count= thread_class_allocated_count= 0; + thread_class_max= 0; +} + +/** + Initialize the table share buffer. + @param table_share_sizing max number of table share + @return 0 on success +*/ +int init_table_share(uint table_share_sizing) +{ + if (global_table_share_container.init(table_share_sizing)) + return 1; + + return 0; +} + +/** Cleanup the table share buffers. */ +void cleanup_table_share(void) +{ + global_table_share_container.cleanup(); +} + +C_MODE_START +/** get_key function for @c table_share_hash. */ +static uchar *table_share_hash_get_key(const uchar *entry, size_t *length, + my_bool) +{ + const PFS_table_share * const *typed_entry; + const PFS_table_share *share; + const void *result; + typed_entry= reinterpret_cast (entry); + assert(typed_entry != NULL); + share= *typed_entry; + assert(share != NULL); + *length= share->m_key.m_key_length; + result= &share->m_key.m_hash_key[0]; + return const_cast (reinterpret_cast (result)); +} +C_MODE_END + +/** Initialize the table share hash table. */ +int init_table_share_hash(const PFS_global_param *param) +{ + if ((! table_share_hash_inited) && (param->m_table_share_sizing != 0)) + { + lf_hash_init(&table_share_hash, sizeof(PFS_table_share*), LF_HASH_UNIQUE, + 0, 0, table_share_hash_get_key, &my_charset_bin); + table_share_hash_inited= true; + } + return 0; +} + +/** Cleanup the table share hash table. */ +void cleanup_table_share_hash(void) +{ + if (table_share_hash_inited) + { + lf_hash_destroy(&table_share_hash); + table_share_hash_inited= false; + } +} + +/** + Get the hash pins for @sa table_share_hash. + @param thread The running thread. + @returns The LF_HASH pins for the thread. +*/ +LF_PINS* get_table_share_hash_pins(PFS_thread *thread) +{ + if (unlikely(thread->m_table_share_hash_pins == NULL)) + { + if (! table_share_hash_inited) + return NULL; + thread->m_table_share_hash_pins= lf_hash_get_pins(&table_share_hash); + } + return thread->m_table_share_hash_pins; +} + +/** + Set a table share hash key. + @param [out] key The key to populate. + @param temporary True for TEMPORARY TABLE. + @param schema_name The table schema name. + @param schema_name_length The table schema name length. + @param table_name The table name. + @param table_name_length The table name length. +*/ +static void set_table_share_key(PFS_table_share_key *key, + bool temporary, + const char *schema_name, size_t schema_name_length, + const char *table_name, size_t table_name_length) +{ + assert(schema_name_length <= NAME_LEN); + assert(table_name_length <= NAME_LEN); + char *saved_schema_name; + char *saved_table_name; + + char *ptr= &key->m_hash_key[0]; + ptr[0]= (temporary ? OBJECT_TYPE_TEMPORARY_TABLE : OBJECT_TYPE_TABLE); + ptr++; + saved_schema_name= ptr; + memcpy(ptr, schema_name, schema_name_length); + ptr+= schema_name_length; + ptr[0]= 0; + ptr++; + saved_table_name= ptr; + memcpy(ptr, table_name, table_name_length); + ptr+= table_name_length; + ptr[0]= 0; + ptr++; + key->m_key_length= (uint)(ptr - &key->m_hash_key[0]); + + if (lower_case_table_names) + { + my_casedn_str(files_charset_info, saved_schema_name); + my_casedn_str(files_charset_info, saved_table_name); + } +} + +/** + Find an existing table share lock instrumentation. + @return a table share lock. +*/ +PFS_table_share_lock* +PFS_table_share::find_lock_stat() const +{ + PFS_table_share *that= const_cast(this); + void *addr= & that->m_race_lock_stat; + void * volatile * typed_addr= static_cast(addr); + void *ptr; + + /* Atomic Load */ + ptr= my_atomic_loadptr(typed_addr); + + PFS_table_share_lock *pfs; + pfs= static_cast(ptr); + return pfs; +} + +/** + Find or create a table share lock instrumentation. + @return a table share lock, or NULL. +*/ +PFS_table_share_lock* +PFS_table_share::find_or_create_lock_stat() +{ + void *addr= & this->m_race_lock_stat; + void * volatile * typed_addr= static_cast(addr); + void *ptr; + + /* (1) Atomic Load */ + ptr= my_atomic_loadptr(typed_addr); + + PFS_table_share_lock *pfs; + if (ptr != NULL) + { + pfs= static_cast(ptr); + return pfs; + } + + /* (2) Create a lock stat */ + pfs= create_table_share_lock_stat(); + if (pfs == NULL) + return NULL; + pfs->m_owner= this; + + void *old_ptr= NULL; + ptr= pfs; + + /* (3) Atomic CAS */ + if (my_atomic_casptr(typed_addr, & old_ptr, ptr)) + { + /* Ok. */ + return pfs; + } + + /* Collision with another thread that also executed (2) and (3). */ + release_table_share_lock_stat(pfs); + + pfs= static_cast(old_ptr); + return pfs; +} + +/** Destroy a table share lock instrumentation. */ +void PFS_table_share::destroy_lock_stat() +{ + void *addr= & this->m_race_lock_stat; + void * volatile * typed_addr= static_cast(addr); + void *new_ptr= NULL; + void *old_ptr; + + old_ptr= my_atomic_fasptr(typed_addr, new_ptr); + if (old_ptr != NULL) + { + PFS_table_share_lock *pfs; + pfs= static_cast(old_ptr); + release_table_share_lock_stat(pfs); + } +} + +/** + Find an existing table share index instrumentation. + @return a table share index +*/ +PFS_table_share_index* +PFS_table_share::find_index_stat(uint index) const +{ + assert(index <= MAX_INDEXES); + + PFS_table_share *that= const_cast(this); + void *addr= & that->m_race_index_stat[index]; + void * volatile * typed_addr= static_cast(addr); + void *ptr; + + /* Atomic Load */ + ptr= my_atomic_loadptr(typed_addr); + + PFS_table_share_index *pfs; + pfs= static_cast(ptr); + return pfs; +} + +/** + Find or create a table share index instrumentation. + @param server_share + @index index + @return a table share index, or NULL +*/ +PFS_table_share_index* +PFS_table_share::find_or_create_index_stat(const TABLE_SHARE *server_share, uint index) +{ + assert(index <= MAX_INDEXES); + + void *addr= & this->m_race_index_stat[index]; + void * volatile * typed_addr= static_cast(addr); + void *ptr; + + /* (1) Atomic Load */ + ptr= my_atomic_loadptr(typed_addr); + + PFS_table_share_index *pfs; + if (ptr != NULL) + { + pfs= static_cast(ptr); + return pfs; + } + + /* (2) Create an index stat */ + pfs= create_table_share_index_stat(server_share, index); + if (pfs == NULL) + return NULL; + pfs->m_owner= this; + + void *old_ptr= NULL; + ptr= pfs; + + /* (3) Atomic CAS */ + if (my_atomic_casptr(typed_addr, & old_ptr, ptr)) + { + /* Ok. */ + return pfs; + } + + /* Collision with another thread that also executed (2) and (3). */ + release_table_share_index_stat(pfs); + + pfs= static_cast(old_ptr); + return pfs; +} + +/** Destroy table share index instrumentation. */ +void PFS_table_share::destroy_index_stats() +{ + uint index; + + for (index= 0; index <= MAX_INDEXES; index++) + { + void *addr= & this->m_race_index_stat[index]; + void * volatile * typed_addr= static_cast(addr); + void *new_ptr= NULL; + void *old_ptr; + + old_ptr= my_atomic_fasptr(typed_addr, new_ptr); + if (old_ptr != NULL) + { + PFS_table_share_index *pfs; + pfs= static_cast(old_ptr); + release_table_share_index_stat(pfs); + } + } +} + +void PFS_table_share::refresh_setup_object_flags(PFS_thread *thread) +{ + bool old_enabled= m_enabled; + + lookup_setup_object(thread, + OBJECT_TYPE_TABLE, + m_schema_name, m_schema_name_length, + m_table_name, m_table_name_length, + &m_enabled, &m_timed); + + /* + If instrumentation for this table was enabled earlier and is disabled now, + cleanup slots reserved for lock stats and index stats. + */ + if (old_enabled && ! m_enabled) + { + destroy_lock_stat(); + destroy_index_stats(); + } +} + +/** + Initialize the table lock stat buffer. + @param table_stat_sizing max number of table lock statistics + @return 0 on success +*/ +int init_table_share_lock_stat(uint table_stat_sizing) +{ + if (global_table_share_lock_container.init(table_stat_sizing)) + return 1; + + return 0; +} + +/** + Create a table share lock instrumentation. + @return table share lock instrumentation, or NULL +*/ +PFS_table_share_lock* +create_table_share_lock_stat() +{ + PFS_table_share_lock *pfs= NULL; + pfs_dirty_state dirty_state; + + /* Create a new record in table stat array. */ + pfs= global_table_share_lock_container.allocate(& dirty_state); + if (pfs != NULL) + { + /* Reset the stats. */ + pfs->m_stat.reset(); + + /* Use this stat buffer. */ + pfs->m_lock.dirty_to_allocated(& dirty_state); + } + + return pfs; +} + +/** Release a table share lock instrumentation. */ +void release_table_share_lock_stat(PFS_table_share_lock *pfs) +{ + pfs->m_owner= NULL; + global_table_share_lock_container.deallocate(pfs); + return; +} + +/** Cleanup the table stat buffers. */ +void cleanup_table_share_lock_stat(void) +{ + global_table_share_lock_container.cleanup(); +} + +/** + Initialize table index stat buffer. + @param index_stat_sizing max number of index statistics + @return 0 on success +*/ +int init_table_share_index_stat(uint index_stat_sizing) +{ + if (global_table_share_index_container.init(index_stat_sizing)) + return 1; + + return 0; +} + +/** + Create a table share index instrumentation. + @return table share index instrumentation, or NULL +*/ +PFS_table_share_index* +create_table_share_index_stat(const TABLE_SHARE *server_share, uint server_index) +{ + assert((server_share != NULL) || (server_index == MAX_INDEXES)); + + PFS_table_share_index *pfs= NULL; + pfs_dirty_state dirty_state; + + /* Create a new record in index stat array. */ + pfs= global_table_share_index_container.allocate(& dirty_state); + if (pfs != NULL) + { + if (server_index == MAX_INDEXES) + { + pfs->m_key.m_name_length= 0; + } + else + { + KEY *key_info= server_share->key_info + server_index; + size_t len= key_info->name.length; + + memcpy(pfs->m_key.m_name, key_info->name.str, len); + pfs->m_key.m_name_length= static_cast(len); + } + + /* Reset the stats. */ + pfs->m_stat.reset(); + + /* Use this stat buffer. */ + pfs->m_lock.dirty_to_allocated(& dirty_state); + } + + return pfs; +} + +/** Release a table share index instrumentation. */ +void release_table_share_index_stat(PFS_table_share_index *pfs) +{ + pfs->m_owner= NULL; + global_table_share_index_container.deallocate(pfs); + return; +} + +/** Cleanup the table stat buffers. */ +void cleanup_table_share_index_stat(void) +{ + global_table_share_index_container.cleanup(); +} + +/** + Initialize the file class buffer. + @param file_class_sizing max number of file class + @return 0 on success +*/ +int init_file_class(uint file_class_sizing) +{ + int result= 0; + file_class_dirty_count= file_class_allocated_count= 0; + file_class_max= file_class_sizing; + file_class_lost= 0; + + if (file_class_max > 0) + { + file_class_array= PFS_MALLOC_ARRAY(& builtin_memory_file_class, + file_class_max, + sizeof(PFS_file_class), PFS_file_class, + MYF(MY_ZEROFILL)); + if (unlikely(file_class_array == NULL)) + return 1; + } + else + file_class_array= NULL; + + return result; +} + +/** Cleanup the file class buffers. */ +void cleanup_file_class(void) +{ + PFS_FREE_ARRAY(& builtin_memory_file_class, + file_class_max, sizeof(PFS_file_class), + file_class_array); + file_class_array= NULL; + file_class_dirty_count= file_class_allocated_count= 0; + file_class_max= 0; +} + +/** + Initialize the stage class buffer. + @param stage_class_sizing max number of stage class + @return 0 on success +*/ +int init_stage_class(uint stage_class_sizing) +{ + int result= 0; + stage_class_dirty_count= stage_class_allocated_count= 0; + stage_class_max= stage_class_sizing; + stage_class_lost= 0; + + if (stage_class_max > 0) + { + stage_class_array= PFS_MALLOC_ARRAY(& builtin_memory_stage_class, + stage_class_max, + sizeof(PFS_stage_class), PFS_stage_class, + MYF(MY_ZEROFILL)); + if (unlikely(stage_class_array == NULL)) + return 1; + } + else + stage_class_array= NULL; + + return result; +} + +/** Cleanup the stage class buffers. */ +void cleanup_stage_class(void) +{ + PFS_FREE_ARRAY(& builtin_memory_stage_class, + stage_class_max, sizeof(PFS_stage_class), + stage_class_array); + stage_class_array= NULL; + stage_class_dirty_count= stage_class_allocated_count= 0; + stage_class_max= 0; +} + +/** + Initialize the statement class buffer. + @param statement_class_sizing max number of statement class + @return 0 on success +*/ +int init_statement_class(uint statement_class_sizing) +{ + int result= 0; + statement_class_dirty_count= statement_class_allocated_count= 0; + statement_class_max= statement_class_sizing; + statement_class_lost= 0; + + if (statement_class_max > 0) + { + statement_class_array= PFS_MALLOC_ARRAY(& builtin_memory_statement_class, + statement_class_max, + sizeof(PFS_statement_class), PFS_statement_class, + MYF(MY_ZEROFILL)); + if (unlikely(statement_class_array == NULL)) + return 1; + } + else + statement_class_array= NULL; + + return result; +} + +/** Cleanup the statement class buffers. */ +void cleanup_statement_class(void) +{ + PFS_FREE_ARRAY(& builtin_memory_statement_class, + statement_class_max, sizeof(PFS_statement_class), + statement_class_array); + statement_class_array= NULL; + statement_class_dirty_count= statement_class_allocated_count= 0; + statement_class_max= 0; +} + +/** + Initialize the socket class buffer. + @param socket_class_sizing max number of socket class + @return 0 on success +*/ +int init_socket_class(uint socket_class_sizing) +{ + int result= 0; + socket_class_dirty_count= socket_class_allocated_count= 0; + socket_class_max= socket_class_sizing; + socket_class_lost= 0; + + if (socket_class_max > 0) + { + socket_class_array= PFS_MALLOC_ARRAY(& builtin_memory_socket_class, + socket_class_max, + sizeof(PFS_socket_class), PFS_socket_class, + MYF(MY_ZEROFILL)); + if (unlikely(socket_class_array == NULL)) + return 1; + } + else + socket_class_array= NULL; + + return result; +} + +/** Cleanup the socket class buffers. */ +void cleanup_socket_class(void) +{ + PFS_FREE_ARRAY(& builtin_memory_socket_class, + socket_class_max, sizeof(PFS_socket_class), + socket_class_array); + socket_class_array= NULL; + socket_class_dirty_count= socket_class_allocated_count= 0; + socket_class_max= 0; +} + +/** + Initialize the memory class buffer. + @param memory_class_sizing max number of memory class + @return 0 on success +*/ +int init_memory_class(uint memory_class_sizing) +{ + int result= 0; + memory_class_dirty_count= memory_class_allocated_count= 0; + memory_class_max= memory_class_sizing; + memory_class_lost= 0; + + if (memory_class_max > 0) + { + memory_class_array= PFS_MALLOC_ARRAY(& builtin_memory_memory_class, + memory_class_max, + sizeof(PFS_memory_class), PFS_memory_class, + MYF(MY_ZEROFILL)); + if (unlikely(memory_class_array == NULL)) + return 1; + } + else + memory_class_array= NULL; + + return result; +} + +/** Cleanup the memory class buffers. */ +void cleanup_memory_class(void) +{ + PFS_FREE_ARRAY(& builtin_memory_memory_class, + memory_class_max, sizeof(PFS_memory_class), + memory_class_array); + memory_class_array= NULL; + memory_class_dirty_count= memory_class_allocated_count= 0; + memory_class_max= 0; +} + +static void init_instr_class(PFS_instr_class *klass, + const char *name, + uint name_length, + int flags, + PFS_class_type class_type) +{ + assert(name_length <= PFS_MAX_INFO_NAME_LENGTH); + memset(klass, 0, sizeof(PFS_instr_class)); + strncpy(klass->m_name, name, name_length); + klass->m_name[PFS_MAX_INFO_NAME_LENGTH - 1]= '\0'; + klass->m_name_length= name_length; + klass->m_flags= flags; + klass->m_enabled= true; + klass->m_timed= true; + klass->m_type= class_type; + klass->m_timer= class_timers[class_type]; +} + +/** + Set user-defined configuration values for an instrument. +*/ +static void configure_instr_class(PFS_instr_class *entry) +{ + uint match_length= 0; /* length of matching pattern */ + + // May be NULL in unit tests + if (pfs_instr_config_array == NULL) + return; + PFS_instr_config **it= pfs_instr_config_array->front(); + for ( ; it != pfs_instr_config_array->end(); it++) + { + PFS_instr_config* e= *it; + + /** + Compare class name to all configuration entries. In case of multiple + matches, the longer specification wins. For example, the pattern + 'ABC/DEF/GHI=ON' has precedence over 'ABC/DEF/%=OFF' regardless of + position within the configuration file or command line. + + Consecutive wildcards affect the count. + */ + if (!my_charset_latin1.wildcmp( + entry->m_name, entry->m_name+entry->m_name_length, + e->m_name, e->m_name+e->m_name_length, + '\\', '?','%')) + { + if (e->m_name_length >= match_length) + { + entry->m_enabled= e->m_enabled; + entry->m_timed= e->m_timed; + match_length= MY_MAX(e->m_name_length, match_length); + } + } + } +} + +#define REGISTER_CLASS_BODY_PART(INDEX, ARRAY, MAX, NAME, NAME_LENGTH) \ + for (INDEX= 0; INDEX < MAX; INDEX++) \ + { \ + entry= &ARRAY[INDEX]; \ + if ((entry->m_name_length == NAME_LENGTH) && \ + (strncmp(entry->m_name, NAME, NAME_LENGTH) == 0)) \ + { \ + assert(entry->m_flags == flags); \ + return (INDEX + 1); \ + } \ + } + +/** + Register a mutex instrumentation metadata. + @param name the instrumented name + @param name_length length in bytes of name + @param flags the instrumentation flags + @return a mutex instrumentation key +*/ +PFS_sync_key register_mutex_class(const char *name, uint name_length, + int flags) +{ + uint32 index; + PFS_mutex_class *entry; + + /* + This is a full array scan, which is not optimal. + This is acceptable since this code is only used at startup, + or when a plugin is loaded. + */ + REGISTER_CLASS_BODY_PART(index, mutex_class_array, mutex_class_max, + name, name_length) + /* + Note that: + mutex_class_dirty_count is incremented *before* an entry is added + mutex_class_allocated_count is incremented *after* an entry is added + */ + index= PFS_atomic::add_u32(&mutex_class_dirty_count, 1); + + if (index < mutex_class_max) + { + /* + The instrument was not found (from a possible previous + load / unload of a plugin), allocate it. + This code is safe when 2 threads execute in parallel + for different mutex classes: + - thread 1 registering class A + - thread 2 registering class B + will not collide in the same mutex_class_array[index] entry. + This code does not protect against 2 threads registering + in parallel the same class: + - thread 1 registering class A + - thread 2 registering class A + could lead to a duplicate class A entry. + This is ok, since this case can not happen in the caller: + - classes names are derived from a plugin name + ('wait/synch/mutex//xxx') + - 2 threads can not register concurrently the same plugin + in INSTALL PLUGIN. + */ + entry= &mutex_class_array[index]; + init_instr_class(entry, name, name_length, flags, PFS_CLASS_MUTEX); + entry->m_mutex_stat.reset(); + entry->m_event_name_index= mutex_class_start + index; + entry->m_singleton= NULL; + entry->m_enabled= false; /* disabled by default */ + entry->m_timed= false; + + /* Set user-defined configuration options for this instrument */ + configure_instr_class(entry); + + /* + Now that this entry is populated, advertise it + + Technically, there is a small race condition here: + T0: + mutex_class_dirty_count= 10 + mutex_class_allocated_count= 10 + T1: Thread A increment mutex_class_dirty_count to 11 + T2: Thread B increment mutex_class_dirty_count to 12 + T3: Thread A populate entry 11 + T4: Thread B populate entry 12 + T5: Thread B increment mutex_class_allocated_count to 11, + advertise thread A incomplete record 11, + but does not advertise thread B complete record 12 + T6: Thread A increment mutex_class_allocated_count to 12 + This has no impact, and is acceptable. + A reader will not see record 12 for a short time. + A reader will see an incomplete record 11 for a short time, + which is ok: the mutex name / statistics will be temporarily + empty/NULL/zero, but this won't cause a crash + (mutex_class_array is initialized with MY_ZEROFILL). + */ + PFS_atomic::add_u32(&mutex_class_allocated_count, 1); + return (index + 1); + } + + /* + Out of space, report to SHOW STATUS that + the allocated memory was too small. + */ + if (pfs_enabled) + mutex_class_lost++; + return 0; +} + +/** + Register a rwlock instrumentation metadata. + @param name the instrumented name + @param name_length length in bytes of name + @param flags the instrumentation flags + @return a rwlock instrumentation key +*/ +PFS_sync_key register_rwlock_class(const char *name, uint name_length, + int flags) +{ + /* See comments in register_mutex_class */ + uint32 index; + PFS_rwlock_class *entry; + + REGISTER_CLASS_BODY_PART(index, rwlock_class_array, rwlock_class_max, + name, name_length) + + index= PFS_atomic::add_u32(&rwlock_class_dirty_count, 1); + + if (index < rwlock_class_max) + { + entry= &rwlock_class_array[index]; + init_instr_class(entry, name, name_length, flags, PFS_CLASS_RWLOCK); + entry->m_rwlock_stat.reset(); + entry->m_event_name_index= rwlock_class_start + index; + entry->m_singleton= NULL; + entry->m_enabled= false; /* disabled by default */ + entry->m_timed= false; + /* Set user-defined configuration options for this instrument */ + configure_instr_class(entry); + PFS_atomic::add_u32(&rwlock_class_allocated_count, 1); + return (index + 1); + } + + if (pfs_enabled) + rwlock_class_lost++; + return 0; +} + +/** + Register a condition instrumentation metadata. + @param name the instrumented name + @param name_length length in bytes of name + @param flags the instrumentation flags + @return a condition instrumentation key +*/ +PFS_sync_key register_cond_class(const char *name, uint name_length, + int flags) +{ + /* See comments in register_mutex_class */ + uint32 index; + PFS_cond_class *entry; + + REGISTER_CLASS_BODY_PART(index, cond_class_array, cond_class_max, + name, name_length) + + index= PFS_atomic::add_u32(&cond_class_dirty_count, 1); + + if (index < cond_class_max) + { + entry= &cond_class_array[index]; + init_instr_class(entry, name, name_length, flags, PFS_CLASS_COND); + entry->m_event_name_index= cond_class_start + index; + entry->m_singleton= NULL; + entry->m_enabled= false; /* disabled by default */ + entry->m_timed= false; + /* Set user-defined configuration options for this instrument */ + configure_instr_class(entry); + PFS_atomic::add_u32(&cond_class_allocated_count, 1); + return (index + 1); + } + + if (pfs_enabled) + cond_class_lost++; + return 0; +} + +#define FIND_CLASS_BODY(KEY, COUNT, ARRAY) \ + if ((KEY == 0) || (KEY > COUNT)) \ + return NULL; \ + return &ARRAY[KEY - 1] + +/** + Find a mutex instrumentation class by key. + @param key the instrument key + @return the instrument class, or NULL +*/ +PFS_mutex_class *find_mutex_class(PFS_sync_key key) +{ + FIND_CLASS_BODY(key, mutex_class_allocated_count, mutex_class_array); +} + +PFS_mutex_class *sanitize_mutex_class(PFS_mutex_class *unsafe) +{ + SANITIZE_ARRAY_BODY(PFS_mutex_class, mutex_class_array, mutex_class_max, unsafe); +} + +/** + Find a rwlock instrumentation class by key. + @param key the instrument key + @return the instrument class, or NULL +*/ +PFS_rwlock_class *find_rwlock_class(PFS_sync_key key) +{ + FIND_CLASS_BODY(key, rwlock_class_allocated_count, rwlock_class_array); +} + +PFS_rwlock_class *sanitize_rwlock_class(PFS_rwlock_class *unsafe) +{ + SANITIZE_ARRAY_BODY(PFS_rwlock_class, rwlock_class_array, rwlock_class_max, unsafe); +} + +/** + Find a condition instrumentation class by key. + @param key the instrument key + @return the instrument class, or NULL +*/ +PFS_cond_class *find_cond_class(PFS_sync_key key) +{ + FIND_CLASS_BODY(key, cond_class_allocated_count, cond_class_array); +} + +PFS_cond_class *sanitize_cond_class(PFS_cond_class *unsafe) +{ + SANITIZE_ARRAY_BODY(PFS_cond_class, cond_class_array, cond_class_max, unsafe); +} + +/** + Register a thread instrumentation metadata. + @param name the instrumented name + @param name_length length in bytes of name + @param flags the instrumentation flags + @return a thread instrumentation key +*/ +PFS_thread_key register_thread_class(const char *name, uint name_length, + int flags) +{ + /* See comments in register_mutex_class */ + uint32 index; + PFS_thread_class *entry; + + for (index= 0; index < thread_class_max; index++) + { + entry= &thread_class_array[index]; + + if ((entry->m_name_length == name_length) && + (strncmp(entry->m_name, name, name_length) == 0)) + return (index + 1); + } + + index= PFS_atomic::add_u32(&thread_class_dirty_count, 1); + + if (index < thread_class_max) + { + entry= &thread_class_array[index]; + assert(name_length <= PFS_MAX_INFO_NAME_LENGTH); + strncpy(entry->m_name, name, name_length); + entry->m_name_length= name_length; + entry->m_enabled= true; + PFS_atomic::add_u32(&thread_class_allocated_count, 1); + return (index + 1); + } + + if (pfs_enabled) + thread_class_lost++; + return 0; +} + +/** + Find a thread instrumentation class by key. + @param key the instrument key + @return the instrument class, or NULL +*/ +PFS_thread_class *find_thread_class(PFS_sync_key key) +{ + FIND_CLASS_BODY(key, thread_class_allocated_count, thread_class_array); +} + +PFS_thread_class *sanitize_thread_class(PFS_thread_class *unsafe) +{ + SANITIZE_ARRAY_BODY(PFS_thread_class, thread_class_array, thread_class_max, unsafe); +} + +/** + Register a file instrumentation metadata. + @param name the instrumented name + @param name_length length in bytes of name + @param flags the instrumentation flags + @return a file instrumentation key +*/ +PFS_file_key register_file_class(const char *name, uint name_length, + int flags) +{ + /* See comments in register_mutex_class */ + uint32 index; + PFS_file_class *entry; + + REGISTER_CLASS_BODY_PART(index, file_class_array, file_class_max, + name, name_length) + + index= PFS_atomic::add_u32(&file_class_dirty_count, 1); + + if (index < file_class_max) + { + entry= &file_class_array[index]; + init_instr_class(entry, name, name_length, flags, PFS_CLASS_FILE); + entry->m_event_name_index= file_class_start + index; + entry->m_singleton= NULL; + entry->m_enabled= true; /* enabled by default */ + entry->m_timed= true; + /* Set user-defined configuration options for this instrument */ + configure_instr_class(entry); + PFS_atomic::add_u32(&file_class_allocated_count, 1); + + return (index + 1); + } + + if (pfs_enabled) + file_class_lost++; + return 0; +} + +/** + Register a stage instrumentation metadata. + @param name the instrumented name + @param prefix_length length in bytes of the name prefix + @param name_length length in bytes of name + @param flags the instrumentation flags + @return a stage instrumentation key +*/ +PFS_stage_key register_stage_class(const char *name, + uint prefix_length, + uint name_length, + int flags) +{ + /* See comments in register_mutex_class */ + uint32 index; + PFS_stage_class *entry; + + REGISTER_CLASS_BODY_PART(index, stage_class_array, stage_class_max, + name, name_length) + + index= PFS_atomic::add_u32(&stage_class_dirty_count, 1); + + if (index < stage_class_max) + { + entry= &stage_class_array[index]; + init_instr_class(entry, name, name_length, flags, PFS_CLASS_STAGE); + entry->m_prefix_length= prefix_length; + entry->m_event_name_index= index; + + if (flags & PSI_FLAG_STAGE_PROGRESS) + { + /* Stages with progress information are enabled and timed by default */ + entry->m_enabled= true; + entry->m_timed= true; + } + else + { + /* Stages without progress information are disabled by default */ + entry->m_enabled= false; + entry->m_timed= false; + } + + /* Set user-defined configuration options for this instrument */ + configure_instr_class(entry); + PFS_atomic::add_u32(&stage_class_allocated_count, 1); + + return (index + 1); + } + + if (pfs_enabled) + stage_class_lost++; + return 0; +} + +/** + Register a statement instrumentation metadata. + @param name the instrumented name + @param name_length length in bytes of name + @param flags the instrumentation flags + @return a statement instrumentation key +*/ +PFS_statement_key register_statement_class(const char *name, uint name_length, + int flags) +{ + /* See comments in register_mutex_class */ + uint32 index; + PFS_statement_class *entry; + + REGISTER_CLASS_BODY_PART(index, statement_class_array, statement_class_max, + name, name_length) + + index= PFS_atomic::add_u32(&statement_class_dirty_count, 1); + + if (index < statement_class_max) + { + entry= &statement_class_array[index]; + init_instr_class(entry, name, name_length, flags, PFS_CLASS_STATEMENT); + entry->m_event_name_index= index; + entry->m_enabled= true; /* enabled by default */ + entry->m_timed= true; + /* Set user-defined configuration options for this instrument */ + configure_instr_class(entry); + PFS_atomic::add_u32(&statement_class_allocated_count, 1); + + return (index + 1); + } + + if (pfs_enabled) + statement_class_lost++; + return 0; +} + +/** + Find a file instrumentation class by key. + @param key the instrument key + @return the instrument class, or NULL +*/ +PFS_file_class *find_file_class(PFS_file_key key) +{ + FIND_CLASS_BODY(key, file_class_allocated_count, file_class_array); +} + +PFS_file_class *sanitize_file_class(PFS_file_class *unsafe) +{ + SANITIZE_ARRAY_BODY(PFS_file_class, file_class_array, file_class_max, unsafe); +} + +/** + Find a stage instrumentation class by key. + @param key the instrument key + @return the instrument class, or NULL +*/ +PFS_stage_class *find_stage_class(PFS_stage_key key) +{ + FIND_CLASS_BODY(key, stage_class_allocated_count, stage_class_array); +} + +PFS_stage_class *sanitize_stage_class(PFS_stage_class *unsafe) +{ + SANITIZE_ARRAY_BODY(PFS_stage_class, stage_class_array, stage_class_max, unsafe); +} + +/** + Find a statement instrumentation class by key. + @param key the instrument key + @return the instrument class, or NULL +*/ +PFS_statement_class *find_statement_class(PFS_stage_key key) +{ + FIND_CLASS_BODY(key, statement_class_allocated_count, statement_class_array); +} + +PFS_statement_class *sanitize_statement_class(PFS_statement_class *unsafe) +{ + SANITIZE_ARRAY_BODY(PFS_statement_class, statement_class_array, statement_class_max, unsafe); +} + +/** + Register a socket instrumentation metadata. + @param name the instrumented name + @param name_length length in bytes of name + @param flags the instrumentation flags + @return a socket instrumentation key +*/ +PFS_socket_key register_socket_class(const char *name, uint name_length, + int flags) +{ + /* See comments in register_mutex_class */ + uint32 index; + PFS_socket_class *entry; + + REGISTER_CLASS_BODY_PART(index, socket_class_array, socket_class_max, + name, name_length) + + index= PFS_atomic::add_u32(&socket_class_dirty_count, 1); + + if (index < socket_class_max) + { + entry= &socket_class_array[index]; + init_instr_class(entry, name, name_length, flags, PFS_CLASS_SOCKET); + entry->m_event_name_index= socket_class_start + index; + entry->m_singleton= NULL; + entry->m_enabled= false; /* disabled by default */ + entry->m_timed= false; + /* Set user-defined configuration options for this instrument */ + configure_instr_class(entry); + PFS_atomic::add_u32(&socket_class_allocated_count, 1); + return (index + 1); + } + + if (pfs_enabled) + socket_class_lost++; + return 0; +} + +/** + Find a socket instrumentation class by key. + @param key the instrument key + @return the instrument class, or NULL +*/ +PFS_socket_class *find_socket_class(PFS_socket_key key) +{ + FIND_CLASS_BODY(key, socket_class_allocated_count, socket_class_array); +} + +PFS_socket_class *sanitize_socket_class(PFS_socket_class *unsafe) +{ + SANITIZE_ARRAY_BODY(PFS_socket_class, socket_class_array, socket_class_max, unsafe); +} + +/** + Register a memory instrumentation metadata. + @param name the instrumented name + @param name_length length in bytes of name + @param flags the instrumentation flags + @return a memory instrumentation key +*/ +PFS_memory_key register_memory_class(const char *name, uint name_length, + int flags) +{ + /* See comments in register_mutex_class */ + uint32 index; + PFS_memory_class *entry; + + REGISTER_CLASS_BODY_PART(index, memory_class_array, memory_class_max, + name, name_length) + + index= PFS_atomic::add_u32(&memory_class_dirty_count, 1); + + if (index < memory_class_max) + { + entry= &memory_class_array[index]; + init_instr_class(entry, name, name_length, flags, PFS_CLASS_MEMORY); + entry->m_event_name_index= index; + entry->m_enabled= false; /* disabled by default */ + /* Set user-defined configuration options for this instrument */ + configure_instr_class(entry); + entry->m_timed= false; /* Immutable */ + PFS_atomic::add_u32(&memory_class_allocated_count, 1); + return (index + 1); + } + + if (pfs_enabled) + memory_class_lost++; + return 0; +} + +/** + Find a memory instrumentation class by key. + @param key the instrument key + @return the instrument class, or NULL +*/ +PFS_memory_class *find_memory_class(PFS_memory_key key) +{ + FIND_CLASS_BODY(key, memory_class_allocated_count, memory_class_array); +} + +PFS_memory_class *sanitize_memory_class(PFS_memory_class *unsafe) +{ + SANITIZE_ARRAY_BODY(PFS_memory_class, memory_class_array, memory_class_max, unsafe); +} + +PFS_instr_class *find_table_class(uint index) +{ + if (index == 1) + return & global_table_io_class; + if (index == 2) + return & global_table_lock_class; + return NULL; +} + +PFS_instr_class *sanitize_table_class(PFS_instr_class *unsafe) +{ + if (likely((& global_table_io_class == unsafe) || + (& global_table_lock_class == unsafe))) + return unsafe; + return NULL; +} + +PFS_instr_class *find_idle_class(uint index) +{ + if (index == 1) + return & global_idle_class; + return NULL; +} + +PFS_instr_class *sanitize_idle_class(PFS_instr_class *unsafe) +{ + if (likely(& global_idle_class == unsafe)) + return unsafe; + return NULL; +} + +PFS_instr_class *find_metadata_class(uint index) +{ + if (index == 1) + return & global_metadata_class; + return NULL; +} + +PFS_instr_class *sanitize_metadata_class(PFS_instr_class *unsafe) +{ + if (likely(& global_metadata_class == unsafe)) + return unsafe; + return NULL; +} + +PFS_transaction_class *find_transaction_class(uint index) +{ + if (index == 1) + return &global_transaction_class; + return NULL; +} + +PFS_transaction_class *sanitize_transaction_class(PFS_transaction_class *unsafe) +{ + if (likely(&global_transaction_class == unsafe)) + return unsafe; + return NULL; +} + +static int compare_keys(PFS_table_share *pfs, const TABLE_SHARE *share) +{ + if (pfs->m_key_count != share->keys) + return 1; + + size_t len; + uint index= 0; + uint key_count= share->keys; + KEY *key_info= share->key_info; + PFS_table_share_index *index_stat; + + for ( ; index < key_count; key_info++, index++) + { + index_stat= pfs->find_index_stat(index); + if (index_stat != NULL) + { + len= key_info->name.length; + + if (len != index_stat->m_key.m_name_length) + return 1; + + if (memcmp(index_stat->m_key.m_name, key_info->name.str, len) != 0) + return 1; + } + } + + return 0; +} + + +/** + Find or create a table share instrumentation. + @param thread the executing instrumented thread + @param temporary true for TEMPORARY TABLE + @param share table share + @return a table share, or NULL +*/ +PFS_table_share* find_or_create_table_share(PFS_thread *thread, + bool temporary, + const TABLE_SHARE *share) +{ + /* See comments in register_mutex_class */ + PFS_table_share_key key; + + LF_PINS *pins= get_table_share_hash_pins(thread); + if (unlikely(pins == NULL)) + { + global_table_share_container.m_lost++; + return NULL; + } + + const char *schema_name= share->db.str; + size_t schema_name_length= share->db.length; + const char *table_name= share->table_name.str; + size_t table_name_length= share->table_name.length; + + set_table_share_key(&key, temporary, + schema_name, schema_name_length, + table_name, table_name_length); + + PFS_table_share **entry; + uint retry_count= 0; + const uint retry_max= 3; + bool enabled= true; + bool timed= true; + PFS_table_share *pfs; + pfs_dirty_state dirty_state; + +search: + entry= reinterpret_cast + (lf_hash_search(&table_share_hash, pins, + key.m_hash_key, key.m_key_length)); + if (entry && (entry != MY_ERRPTR)) + { + pfs= *entry; + pfs->inc_refcount() ; + if (compare_keys(pfs, share) != 0) + { + /* + Some DDL was detected. + - keep the lock stats, they are unaffected + - destroy the index stats, indexes changed. + - adjust the expected key count + - recreate index stats + */ + pfs->destroy_index_stats(); + pfs->m_key_count= share->keys; + for (uint index= 0; index < pfs->m_key_count; index++) + { + (void)pfs->find_or_create_index_stat(share, index); + } + } + lf_hash_search_unpin(pins); + return pfs; + } + + lf_hash_search_unpin(pins); + + if (retry_count == 0) + { + lookup_setup_object(thread, + OBJECT_TYPE_TABLE, + schema_name, static_cast(schema_name_length), + table_name, static_cast(table_name_length), + &enabled, &timed); + /* + Even when enabled is false, a record is added in the dictionary: + - It makes enabling a table already in the table cache possible, + - It improves performances for the next time a TABLE_SHARE is reloaded + in the table cache. + */ + } + + pfs= global_table_share_container.allocate(& dirty_state); + if (pfs != NULL) + { + pfs->m_key= key; + pfs->m_schema_name= &pfs->m_key.m_hash_key[1]; + pfs->m_schema_name_length= static_cast(schema_name_length); + pfs->m_table_name= &pfs->m_key.m_hash_key[schema_name_length + 2]; + pfs->m_table_name_length= static_cast(table_name_length); + pfs->m_enabled= enabled; + pfs->m_timed= timed; + pfs->init_refcount(); + pfs->destroy_lock_stat(); + pfs->destroy_index_stats(); + pfs->m_key_count= share->keys; + + int res; + pfs->m_lock.dirty_to_allocated(& dirty_state); + res= lf_hash_insert(&table_share_hash, pins, &pfs); + + if (likely(res == 0)) + { + /* Create table share index stats. */ + for (uint index= 0; index < pfs->m_key_count; index++) + { + (void)pfs->find_or_create_index_stat(share, index); + } + return pfs; + } + + global_table_share_container.deallocate(pfs); + + if (res > 0) + { + /* Duplicate insert by another thread */ + if (++retry_count > retry_max) + { + /* Avoid infinite loops */ + global_table_share_container.m_lost++; + return NULL; + } + goto search; + } + + /* OOM in lf_hash_insert */ + global_table_share_container.m_lost++; + return NULL; + } + + return NULL; +} + +void PFS_table_share::aggregate_io(void) +{ + uint index; + uint safe_key_count= sanitize_index_count(m_key_count); + PFS_table_share_index *from_stat; + PFS_table_io_stat sum_io; + + /* Aggregate stats for each index, if any */ + for (index= 0; index < safe_key_count; index++) + { + from_stat= find_index_stat(index); + if (from_stat != NULL) + { + sum_io.aggregate(& from_stat->m_stat); + from_stat->m_stat.reset(); + } + } + + /* Aggregate stats for the table */ + from_stat= find_index_stat(MAX_INDEXES); + if (from_stat != NULL) + { + sum_io.aggregate(& from_stat->m_stat); + from_stat->m_stat.reset(); + } + + /* Add this table stats to the global sink. */ + global_table_io_stat.aggregate(& sum_io); +} + +void PFS_table_share::sum_io(PFS_single_stat *result, uint key_count) +{ + uint index; + PFS_table_share_index *stat; + + assert(key_count <= MAX_INDEXES); + + /* Sum stats for each index, if any */ + for (index= 0; index < key_count; index++) + { + stat= find_index_stat(index); + if (stat != NULL) + { + stat->m_stat.sum(result); + } + } + + /* Sum stats for the table */ + stat= find_index_stat(MAX_INDEXES); + if (stat != NULL) + { + stat->m_stat.sum(result); + } +} + +void PFS_table_share::sum_lock(PFS_single_stat *result) +{ + PFS_table_share_lock *lock_stat; + lock_stat= find_lock_stat(); + if (lock_stat != NULL) + lock_stat->m_stat.sum(result); +} + +void PFS_table_share::sum(PFS_single_stat *result, uint key_count) +{ + sum_io(result, key_count); + sum_lock(result); +} + +void PFS_table_share::aggregate_lock(void) +{ + PFS_table_share_lock *lock_stat; + lock_stat= find_lock_stat(); + if (lock_stat != NULL) + { + global_table_lock_stat.aggregate(& lock_stat->m_stat); + /* Reset lock stat. */ + lock_stat->m_stat.reset(); + } +} + +void release_table_share(PFS_table_share *pfs) +{ + assert(pfs->get_refcount() > 0); + pfs->dec_refcount(); +} + +/** + Drop the instrumented table share associated with a table. + @param thread The running thread + @param temporary True for TEMPORARY TABLE + @param schema_name The table schema name + @param schema_name_length The table schema name length + @param table_name The table name + @param table_name_length The table name length +*/ +void drop_table_share(PFS_thread *thread, + bool temporary, + const char *schema_name, uint schema_name_length, + const char *table_name, uint table_name_length) +{ + PFS_table_share_key key; + LF_PINS* pins= get_table_share_hash_pins(thread); + if (unlikely(pins == NULL)) + return; + set_table_share_key(&key, temporary, schema_name, schema_name_length, + table_name, table_name_length); + PFS_table_share **entry; + entry= reinterpret_cast + (lf_hash_search(&table_share_hash, pins, + key.m_hash_key, key.m_key_length)); + if (entry && (entry != MY_ERRPTR)) + { + PFS_table_share *pfs= *entry; + lf_hash_delete(&table_share_hash, pins, + pfs->m_key.m_hash_key, pfs->m_key.m_key_length); + pfs->destroy_lock_stat(); + pfs->destroy_index_stats(); + + pfs->m_lock.allocated_to_free(); + } + + lf_hash_search_unpin(pins); +} + +/** + Sanitize an unsafe table_share pointer. + @param unsafe The possibly corrupt pointer. + @return A valid table_safe_pointer, or NULL. +*/ +PFS_table_share *sanitize_table_share(PFS_table_share *unsafe) +{ + return global_table_share_container.sanitize(unsafe); +} + +/** Reset the wait statistics per instrument class. */ +void reset_events_waits_by_class() +{ + reset_file_class_io(); + reset_socket_class_io(); + global_idle_stat.reset(); + global_table_io_stat.reset(); + global_table_lock_stat.reset(); + global_metadata_stat.reset(); +} + +/** Reset the io statistics per file class. */ +void reset_file_class_io(void) +{ + PFS_file_class *pfs= file_class_array; + PFS_file_class *pfs_last= file_class_array + file_class_max; + + for ( ; pfs < pfs_last; pfs++) + pfs->m_file_stat.m_io_stat.reset(); +} + +/** Reset the io statistics per socket class. */ +void reset_socket_class_io(void) +{ + PFS_socket_class *pfs= socket_class_array; + PFS_socket_class *pfs_last= socket_class_array + socket_class_max; + + for ( ; pfs < pfs_last; pfs++) + pfs->m_socket_stat.m_io_stat.reset(); +} + +class Proc_table_share_derived_flags + : public PFS_buffer_processor +{ +public: + Proc_table_share_derived_flags(PFS_thread *thread) + : m_thread(thread) + {} + + virtual void operator()(PFS_table_share *pfs) + { + pfs->refresh_setup_object_flags(m_thread); + } + +private: + PFS_thread* m_thread; +}; + +void update_table_share_derived_flags(PFS_thread *thread) +{ + Proc_table_share_derived_flags proc(thread); + global_table_share_container.apply(proc); +} + +class Proc_program_share_derived_flags + : public PFS_buffer_processor +{ +public: + Proc_program_share_derived_flags(PFS_thread *thread) + : m_thread(thread) + {} + + virtual void operator()(PFS_program *pfs) + { + pfs->refresh_setup_object_flags(m_thread); + } + +private: + PFS_thread* m_thread; +}; + +void update_program_share_derived_flags(PFS_thread *thread) +{ + Proc_program_share_derived_flags proc(thread); + global_program_container.apply(proc); +} + +/** @} */ + -- cgit v1.2.3