From 55db59f16de3dea3d8bfc35bdca33f2ca62fdef4 Mon Sep 17 00:00:00 2001 From: Meng-Hsiu Chiang Date: Wed, 6 Dec 2023 19:48:53 +0000 Subject: [PATCH] [MDEV-28162] Replace PFS_atomic with std::atomic PFS_atomic class contains wrappers around my_atomic_* operations, which are macros to GNU atomic operations (__atomic_*). Due to different implementations of compilers, clang may encounter errors when compiling on x86_32 architecture. The following functions are replaced with C++ std::atomic type in performance schema code base: - PFS_atomic::store_*() -> my_atomic_store* -> __atomic_store_n() => std::atomic::store() - PFS_atomic::load_*() -> my_atomic_load* -> __atomic_load_n() => std::atomic::load() - PFS_atomic::add_*() -> my_atomic_add* -> __atomic_fetch_add() => std::atomic::fetch_add() - PFS_atomic::cas_*() -> my_atomic_cas* -> __atomic_compare_exchange_n() => std::atomic::compare_exchange_strong() and PFS_atomic class could be dropped completely. Note that in the wrapper memory order passed to original GNU atomic extensions are hard-coded as `__ATOMIC_SEQ_CST`, which is equivalent to `std::memory_order_seq_cst` in C++, and is the default parameter for std::atomic_* functions. All new code of the whole pull request, including one or several files that are either new files or modified ones, are contributed under the BSD-new license. I am contributing on behalf of my employer Amazon Web Services. --- storage/perfschema/CMakeLists.txt | 1 - storage/perfschema/pfs_account.h | 11 +- storage/perfschema/pfs_atomic.h | 141 ------------------ storage/perfschema/pfs_buffer_container.h | 15 +- storage/perfschema/pfs_digest.cc | 6 +- storage/perfschema/pfs_events_stages.cc | 7 +- storage/perfschema/pfs_events_statements.cc | 7 +- storage/perfschema/pfs_events_transactions.cc | 7 +- storage/perfschema/pfs_events_waits.cc | 7 +- storage/perfschema/pfs_global.h | 6 +- storage/perfschema/pfs_host.h | 12 +- storage/perfschema/pfs_instr.cc | 2 +- storage/perfschema/pfs_instr_class.cc | 74 ++++----- storage/perfschema/pfs_instr_class.h | 13 +- storage/perfschema/pfs_lock.h | 34 ++--- storage/perfschema/pfs_memory.cc | 1 - storage/perfschema/pfs_status.cc | 1 - storage/perfschema/pfs_user.h | 12 +- 18 files changed, 109 insertions(+), 248 deletions(-) delete mode 100644 storage/perfschema/pfs_atomic.h diff --git a/storage/perfschema/CMakeLists.txt b/storage/perfschema/CMakeLists.txt index bb486457dde..aea4040c408 100644 --- a/storage/perfschema/CMakeLists.txt +++ b/storage/perfschema/CMakeLists.txt @@ -49,7 +49,6 @@ cursor_by_thread.h cursor_by_user.h pfs.h pfs_account.h -pfs_atomic.h pfs_buffer_container.h pfs_builtin_memory.h pfs_column_types.h diff --git a/storage/perfschema/pfs_account.h b/storage/perfschema/pfs_account.h index 0aa36204e12..8a2d40c5017 100644 --- a/storage/perfschema/pfs_account.h +++ b/storage/perfschema/pfs_account.h @@ -27,6 +27,7 @@ @file storage/perfschema/pfs_account.h Performance schema account (declarations). */ +#include #include "pfs_lock.h" #include "lf.h" @@ -62,22 +63,22 @@ struct PFS_ALIGNED PFS_account : PFS_connection_slice public: inline void init_refcount(void) { - PFS_atomic::store_32(& m_refcount, 1); + m_refcount.store(1); } inline int get_refcount(void) { - return PFS_atomic::load_32(& m_refcount); + return m_refcount.load(); } inline void inc_refcount(void) { - PFS_atomic::add_32(& m_refcount, 1); + m_refcount.fetch_add(1); } inline void dec_refcount(void) { - PFS_atomic::add_32(& m_refcount, -1); + m_refcount.fetch_sub(1); } void aggregate(bool alive, PFS_user *safe_user, PFS_host *safe_host); @@ -109,7 +110,7 @@ public: ulonglong m_disconnected_count; private: - int m_refcount; + std::atomic m_refcount; }; int init_account(const PFS_global_param *param); diff --git a/storage/perfschema/pfs_atomic.h b/storage/perfschema/pfs_atomic.h deleted file mode 100644 index 8543cdabc88..00000000000 --- a/storage/perfschema/pfs_atomic.h +++ /dev/null @@ -1,141 +0,0 @@ -/* Copyright (c) 2009, 2023, Oracle and/or its affiliates. - - 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_ATOMIC_H -#define PFS_ATOMIC_H - -/** - @file storage/perfschema/pfs_atomic.h - Atomic operations (declarations). -*/ - -#include - -/** Helper for atomic operations. */ -class PFS_atomic -{ -public: - /** Atomic load. */ - static inline int32 load_32(int32 *ptr) - { - return my_atomic_load32(ptr); - } - - /** Atomic load. */ - static inline int64 load_64(int64 *ptr) - { - return my_atomic_load64(ptr); - } - - /** Atomic load. */ - static inline uint32 load_u32(uint32 *ptr) - { - return (uint32) my_atomic_load32((int32*) ptr); - } - - /** Atomic load. */ - static inline uint64 load_u64(uint64 *ptr) - { - return (uint64) my_atomic_load64((int64*) ptr); - } - - /** Atomic store. */ - static inline void store_32(int32 *ptr, int32 value) - { - my_atomic_store32(ptr, value); - } - - /** Atomic store. */ - static inline void store_64(int64 *ptr, int64 value) - { - my_atomic_store64(ptr, value); - } - - /** Atomic store. */ - static inline void store_u32(uint32 *ptr, uint32 value) - { - my_atomic_store32((int32*) ptr, (int32) value); - } - - /** Atomic store. */ - static inline void store_u64(uint64 *ptr, uint64 value) - { - my_atomic_store64((int64*) ptr, (int64) value); - } - - /** Atomic add. */ - static inline int32 add_32(int32 *ptr, int32 value) - { - return my_atomic_add32(ptr, value); - } - - /** Atomic add. */ - static inline int64 add_64(int64 *ptr, int64 value) - { - return my_atomic_add64(ptr, value); - } - - /** Atomic add. */ - static inline uint32 add_u32(uint32 *ptr, uint32 value) - { - return (uint32) my_atomic_add32((int32*) ptr, (int32) value); - } - - /** Atomic add. */ - static inline uint64 add_u64(uint64 *ptr, uint64 value) - { - return (uint64) my_atomic_add64((int64*) ptr, (int64) value); - } - - /** Atomic compare and swap. */ - static inline bool cas_32(int32 *ptr, int32 *old_value, - int32 new_value) - { - return my_atomic_cas32(ptr, old_value, new_value); - } - - /** Atomic compare and swap. */ - static inline bool cas_64(int64 *ptr, int64 *old_value, - int64 new_value) - { - return my_atomic_cas64(ptr, old_value, new_value); - } - - /** Atomic compare and swap. */ - static inline bool cas_u32(uint32 *ptr, uint32 *old_value, - uint32 new_value) - { - return my_atomic_cas32((int32*) ptr, (int32*) old_value, - (uint32) new_value); - } - - /** Atomic compare and swap. */ - static inline bool cas_u64(uint64 *ptr, uint64 *old_value, - uint64 new_value) - { - return my_atomic_cas64((int64*) ptr, (int64*) old_value, - (uint64) new_value); - } -}; - -#endif - diff --git a/storage/perfschema/pfs_buffer_container.h b/storage/perfschema/pfs_buffer_container.h index b5506fe0195..c1cd9e644ef 100644 --- a/storage/perfschema/pfs_buffer_container.h +++ b/storage/perfschema/pfs_buffer_container.h @@ -87,7 +87,7 @@ public: if (m_full) return NULL; - monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1); + monotonic= m_monotonic.m_u32.fetch_add(1); monotonic_max= monotonic + static_cast(m_max); while (monotonic < monotonic_max) @@ -99,7 +99,8 @@ public: { return pfs; } - monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1); + monotonic= m_monotonic.m_u32.fetch_add(1); + } m_full= true; @@ -517,7 +518,7 @@ public: ulong get_row_count() { - ulong page_count= PFS_atomic::load_u32(& m_max_page_index.m_u32); + ulong page_count= m_max_page_index.m_u32.load(); return page_count * PFS_PAGE_SIZE; } @@ -554,11 +555,11 @@ public: /* 1: Try to find an available record within the existing pages */ - current_page_count= PFS_atomic::load_u32(& m_max_page_index.m_u32); + current_page_count= m_max_page_index.m_u32.load(); if (current_page_count != 0) { - monotonic= PFS_atomic::load_u32(& m_monotonic.m_u32); + monotonic= m_monotonic.m_u32.load(); monotonic_max= monotonic + current_page_count; while (monotonic < monotonic_max) @@ -602,7 +603,7 @@ public: counter faster and then move on to the detection of new pages, in part 2: below. */ - monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1); + monotonic= m_monotonic.m_u32.fetch_add(1); }; } @@ -683,7 +684,7 @@ public: my_atomic_storeptr(typed_addr, ptr); /* Advertise the new page */ - PFS_atomic::add_u32(& m_max_page_index.m_u32, 1); + m_max_page_index.m_u32.fetch_add(1); } pthread_mutex_unlock(& m_critical_section); diff --git a/storage/perfschema/pfs_digest.cc b/storage/perfschema/pfs_digest.cc index c2541f7f7e7..46a97534bb2 100644 --- a/storage/perfschema/pfs_digest.cc +++ b/storage/perfschema/pfs_digest.cc @@ -75,7 +75,7 @@ int init_digest(const PFS_global_param *param) */ digest_max= param->m_digest_sizing; digest_lost= 0; - PFS_atomic::store_u32(& digest_monotonic_index.m_u32, 1); + digest_monotonic_index.m_u32.store(1); digest_full= false; if (digest_max == 0) @@ -274,7 +274,7 @@ search: while (++attempts <= digest_max) { - safe_index= PFS_atomic::add_u32(& digest_monotonic_index.m_u32, 1) % digest_max; + safe_index= digest_monotonic_index.m_u32.fetch_add(1) % digest_max; if (safe_index == 0) { /* Record [0] is reserved. */ @@ -406,7 +406,7 @@ void reset_esms_by_digest() Reset index which indicates where the next calculated digest information to be inserted in statements_digest_stat_array. */ - PFS_atomic::store_u32(& digest_monotonic_index.m_u32, 1); + digest_monotonic_index.m_u32.store(1); digest_full= false; } diff --git a/storage/perfschema/pfs_events_stages.cc b/storage/perfschema/pfs_events_stages.cc index aa1bdf4f7a0..9289d25e38e 100644 --- a/storage/perfschema/pfs_events_stages.cc +++ b/storage/perfschema/pfs_events_stages.cc @@ -34,7 +34,6 @@ #include "pfs_host.h" #include "pfs_user.h" #include "pfs_events_stages.h" -#include "pfs_atomic.h" #include "pfs_buffer_container.h" #include "pfs_builtin_memory.h" #include "m_string.h" @@ -62,7 +61,7 @@ int init_events_stages_history_long(uint events_stages_history_long_sizing) { events_stages_history_long_size= events_stages_history_long_sizing; events_stages_history_long_full= false; - PFS_atomic::store_u32(&events_stages_history_long_index.m_u32, 0); + events_stages_history_long_index.m_u32.store(0); if (events_stages_history_long_size == 0) return 0; @@ -135,7 +134,7 @@ void insert_events_stages_history_long(PFS_events_stages *stage) assert(events_stages_history_long_array != NULL); - uint index= PFS_atomic::add_u32(&events_stages_history_long_index.m_u32, 1); + uint index= events_stages_history_long_index.m_u32.fetch_add(1); index= index % events_stages_history_long_size; if (index == 0) @@ -176,7 +175,7 @@ void reset_events_stages_history(void) /** Reset table EVENTS_STAGES_HISTORY_LONG data. */ void reset_events_stages_history_long(void) { - PFS_atomic::store_u32(&events_stages_history_long_index.m_u32, 0); + events_stages_history_long_index.m_u32.store(0); events_stages_history_long_full= false; PFS_events_stages *pfs= events_stages_history_long_array; diff --git a/storage/perfschema/pfs_events_statements.cc b/storage/perfschema/pfs_events_statements.cc index 05bdc83fc5c..9bd6013b390 100644 --- a/storage/perfschema/pfs_events_statements.cc +++ b/storage/perfschema/pfs_events_statements.cc @@ -34,7 +34,6 @@ #include "pfs_host.h" #include "pfs_user.h" #include "pfs_events_statements.h" -#include "pfs_atomic.h" #include "pfs_buffer_container.h" #include "pfs_builtin_memory.h" #include "m_string.h" @@ -64,7 +63,7 @@ int init_events_statements_history_long(size_t events_statements_history_long_si { events_statements_history_long_size= events_statements_history_long_sizing; events_statements_history_long_full= false; - PFS_atomic::store_u32(&events_statements_history_long_index.m_u32, 0); + events_statements_history_long_index.m_u32.store(0); if (events_statements_history_long_size == 0) return 0; @@ -213,7 +212,7 @@ void insert_events_statements_history_long(PFS_events_statements *statement) assert(events_statements_history_long_array != NULL); - uint index= PFS_atomic::add_u32(&events_statements_history_long_index.m_u32, 1); + uint index= events_statements_history_long_index.m_u32.fetch_add(1); index= index % events_statements_history_long_size; if (index == 0) @@ -258,7 +257,7 @@ void reset_events_statements_history(void) /** Reset table EVENTS_STATEMENTS_HISTORY_LONG data. */ void reset_events_statements_history_long(void) { - PFS_atomic::store_u32(&events_statements_history_long_index.m_u32, 0); + events_statements_history_long_index.m_u32.store(0); events_statements_history_long_full= false; PFS_events_statements *pfs= events_statements_history_long_array; diff --git a/storage/perfschema/pfs_events_transactions.cc b/storage/perfschema/pfs_events_transactions.cc index 5ccdb0345d7..563de844f3a 100644 --- a/storage/perfschema/pfs_events_transactions.cc +++ b/storage/perfschema/pfs_events_transactions.cc @@ -34,7 +34,6 @@ #include "pfs_host.h" #include "pfs_user.h" #include "pfs_events_transactions.h" -#include "pfs_atomic.h" #include "pfs_buffer_container.h" #include "pfs_builtin_memory.h" #include "m_string.h" @@ -62,7 +61,7 @@ int init_events_transactions_history_long(uint events_transactions_history_long_ { events_transactions_history_long_size= events_transactions_history_long_sizing; events_transactions_history_long_full= false; - PFS_atomic::store_u32(&events_transactions_history_long_index.m_u32, 0); + events_transactions_history_long_index.m_u32.store(0); if (events_transactions_history_long_size == 0) return 0; @@ -135,7 +134,7 @@ void insert_events_transactions_history_long(PFS_events_transactions *transactio assert(events_transactions_history_long_array != NULL); - uint index= PFS_atomic::add_u32(&events_transactions_history_long_index.m_u32, 1); + uint index= events_transactions_history_long_index.m_u32.fetch_add(1); index= index % events_transactions_history_long_size; if (index == 0) @@ -176,7 +175,7 @@ void reset_events_transactions_history(void) /** Reset table EVENTS_TRANSACTIONS_HISTORY_LONG data. */ void reset_events_transactions_history_long(void) { - PFS_atomic::store_u32(&events_transactions_history_long_index.m_u32, 0); + events_transactions_history_long_index.m_u32.store(0); events_transactions_history_long_full= false; PFS_events_transactions *pfs= events_transactions_history_long_array; diff --git a/storage/perfschema/pfs_events_waits.cc b/storage/perfschema/pfs_events_waits.cc index 3ec6a671913..bceb8d3b791 100644 --- a/storage/perfschema/pfs_events_waits.cc +++ b/storage/perfschema/pfs_events_waits.cc @@ -34,7 +34,6 @@ #include "pfs_host.h" #include "pfs_account.h" #include "pfs_events_waits.h" -#include "pfs_atomic.h" #include "pfs_buffer_container.h" #include "pfs_builtin_memory.h" #include "m_string.h" @@ -66,7 +65,7 @@ int init_events_waits_history_long(uint events_waits_history_long_sizing) { events_waits_history_long_size= events_waits_history_long_sizing; events_waits_history_long_full= false; - PFS_atomic::store_u32(&events_waits_history_long_index.m_u32, 0); + events_waits_history_long_index.m_u32.store(0); if (events_waits_history_long_size == 0) return 0; @@ -135,7 +134,7 @@ void insert_events_waits_history_long(PFS_events_waits *wait) if (unlikely(events_waits_history_long_size == 0)) return; - uint index= PFS_atomic::add_u32(&events_waits_history_long_index.m_u32, 1); + uint index= events_waits_history_long_index.m_u32.fetch_add(1); index= index % events_waits_history_long_size; if (index == 0) @@ -181,7 +180,7 @@ void reset_events_waits_history(void) /** Reset table EVENTS_WAITS_HISTORY_LONG data. */ void reset_events_waits_history_long(void) { - PFS_atomic::store_u32(&events_waits_history_long_index.m_u32, 0); + events_waits_history_long_index.m_u32.store(0); events_waits_history_long_full= false; PFS_events_waits *wait= events_waits_history_long_array; diff --git a/storage/perfschema/pfs_global.h b/storage/perfschema/pfs_global.h index 9f2fba7123e..28e62ca3057 100644 --- a/storage/perfschema/pfs_global.h +++ b/storage/perfschema/pfs_global.h @@ -23,6 +23,8 @@ #ifndef PFS_GLOBAL_H #define PFS_GLOBAL_H +#include + #include "my_compiler.h" /** @@ -59,7 +61,7 @@ extern size_t pfs_allocated_memory; */ struct PFS_cacheline_uint32 { - uint32 m_u32; + std::atomic m_u32; char m_full_cache_line[PFS_CACHE_LINE_SIZE - sizeof(uint32)]; PFS_cacheline_uint32() @@ -73,7 +75,7 @@ struct PFS_cacheline_uint32 */ struct PFS_cacheline_uint64 { - uint64 m_u64; + std::atomic m_u64; char m_full_cache_line[PFS_CACHE_LINE_SIZE - sizeof(uint64)]; PFS_cacheline_uint64() diff --git a/storage/perfschema/pfs_host.h b/storage/perfschema/pfs_host.h index 56bcccb94ac..89dd05df864 100644 --- a/storage/perfschema/pfs_host.h +++ b/storage/perfschema/pfs_host.h @@ -28,6 +28,8 @@ Performance schema host (declarations). */ +#include + #include "pfs_lock.h" #include "lf.h" #include "pfs_con_slice.h" @@ -58,22 +60,22 @@ struct PFS_ALIGNED PFS_host : PFS_connection_slice public: inline void init_refcount(void) { - PFS_atomic::store_32(& m_refcount, 1); + m_refcount.store(1); } inline int get_refcount(void) { - return PFS_atomic::load_32(& m_refcount); + return m_refcount.load(); } inline void inc_refcount(void) { - PFS_atomic::add_32(& m_refcount, 1); + m_refcount.fetch_add(1); } inline void dec_refcount(void) { - PFS_atomic::add_32(& m_refcount, -1); + m_refcount.fetch_sub(1); } void aggregate(bool alive); @@ -97,7 +99,7 @@ public: ulonglong m_disconnected_count; private: - int m_refcount; + std::atomic m_refcount; }; int init_host(const PFS_global_param *param); diff --git a/storage/perfschema/pfs_instr.cc b/storage/perfschema/pfs_instr.cc index 8d0e1265011..9e2d0a81f13 100644 --- a/storage/perfschema/pfs_instr.cc +++ b/storage/perfschema/pfs_instr.cc @@ -526,7 +526,7 @@ PFS_thread* create_thread(PFS_thread_class *klass, const void *identity, if (pfs != NULL) { pfs->m_thread_internal_id= - PFS_atomic::add_u64(&thread_internal_id_counter.m_u64, 1); + thread_internal_id_counter.m_u64.fetch_add(1); pfs->m_parent_thread_internal_id= 0; pfs->m_processlist_id= static_cast(processlist_id); pfs->m_thread_os_id= my_thread_os_id(); diff --git a/storage/perfschema/pfs_instr_class.cc b/storage/perfschema/pfs_instr_class.cc index 56573d3dffd..49aa73f078a 100644 --- a/storage/perfschema/pfs_instr_class.cc +++ b/storage/perfschema/pfs_instr_class.cc @@ -25,6 +25,7 @@ @file storage/perfschema/pfs_instr_class.cc Performance schema instruments meta data (implementation). */ +#include #include "my_global.h" #include "my_sys.h" @@ -36,7 +37,6 @@ #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" @@ -76,12 +76,12 @@ static void init_instr_class(PFS_instr_class *klass, - 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; +static std::atomic mutex_class_dirty_count(0); +static std::atomic mutex_class_allocated_count(0); +static std::atomic rwlock_class_dirty_count(0); +static std::atomic rwlock_class_allocated_count(0); +static std::atomic cond_class_dirty_count(0); +static std::atomic cond_class_allocated_count(0); /** Size of the mutex class array. @sa mutex_class_array */ ulong mutex_class_max= 0; @@ -137,8 +137,8 @@ PFS_cond_class *cond_class_array= NULL; - the performance schema initialization - a plugin initialization */ -static uint32 thread_class_dirty_count= 0; -static uint32 thread_class_allocated_count= 0; +static std::atomic thread_class_dirty_count(0); +static std::atomic thread_class_allocated_count(0); static PFS_thread_class *thread_class_array= NULL; @@ -185,28 +185,28 @@ 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; +static std::atomic file_class_dirty_count(0); +static std::atomic 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 std::atomic stage_class_dirty_count(0); +static std::atomic 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 std::atomic statement_class_dirty_count(0); +static std::atomic 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 std::atomic socket_class_dirty_count(0); +static std::atomic 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 std::atomic memory_class_dirty_count(0); +static std::atomic memory_class_allocated_count(0); static PFS_memory_class *memory_class_array= NULL; @@ -1092,7 +1092,7 @@ PFS_sync_key register_mutex_class(const char *name, uint name_length, 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); + index= mutex_class_dirty_count.fetch_add(1); if (index < mutex_class_max) { @@ -1148,7 +1148,7 @@ PFS_sync_key register_mutex_class(const char *name, uint name_length, 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); + mutex_class_allocated_count.fetch_add(1); return (index + 1); } @@ -1178,7 +1178,7 @@ PFS_sync_key register_rwlock_class(const char *name, uint name_length, REGISTER_CLASS_BODY_PART(index, rwlock_class_array, rwlock_class_max, name, name_length) - index= PFS_atomic::add_u32(&rwlock_class_dirty_count, 1); + index= rwlock_class_dirty_count.fetch_add(1); if (index < rwlock_class_max) { @@ -1191,7 +1191,7 @@ PFS_sync_key register_rwlock_class(const char *name, uint name_length, 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); + rwlock_class_allocated_count.fetch_add(1); return (index + 1); } @@ -1217,7 +1217,7 @@ PFS_sync_key register_cond_class(const char *name, uint name_length, REGISTER_CLASS_BODY_PART(index, cond_class_array, cond_class_max, name, name_length) - index= PFS_atomic::add_u32(&cond_class_dirty_count, 1); + index= cond_class_dirty_count.fetch_add(1); if (index < cond_class_max) { @@ -1229,7 +1229,7 @@ PFS_sync_key register_cond_class(const char *name, uint name_length, 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); + cond_class_allocated_count.fetch_add(1); return (index + 1); } @@ -1311,7 +1311,7 @@ PFS_thread_key register_thread_class(const char *name, uint name_length, return (index + 1); } - index= PFS_atomic::add_u32(&thread_class_dirty_count, 1); + index= thread_class_dirty_count.fetch_add(1); if (index < thread_class_max) { @@ -1320,7 +1320,7 @@ PFS_thread_key register_thread_class(const char *name, uint 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); + thread_class_allocated_count.fetch_add(1); return (index + 1); } @@ -1361,7 +1361,7 @@ PFS_file_key register_file_class(const char *name, uint name_length, REGISTER_CLASS_BODY_PART(index, file_class_array, file_class_max, name, name_length) - index= PFS_atomic::add_u32(&file_class_dirty_count, 1); + index= file_class_dirty_count.fetch_add(1); if (index < file_class_max) { @@ -1373,7 +1373,7 @@ PFS_file_key register_file_class(const char *name, uint name_length, 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); + file_class_allocated_count.fetch_add(1); return (index + 1); } @@ -1403,7 +1403,7 @@ PFS_stage_key register_stage_class(const char *name, REGISTER_CLASS_BODY_PART(index, stage_class_array, stage_class_max, name, name_length) - index= PFS_atomic::add_u32(&stage_class_dirty_count, 1); + index= stage_class_dirty_count.fetch_add(1); if (index < stage_class_max) { @@ -1427,7 +1427,7 @@ PFS_stage_key register_stage_class(const char *name, /* Set user-defined configuration options for this instrument */ configure_instr_class(entry); - PFS_atomic::add_u32(&stage_class_allocated_count, 1); + stage_class_allocated_count.fetch_add(1); return (index + 1); } @@ -1454,7 +1454,7 @@ PFS_statement_key register_statement_class(const char *name, uint name_length, REGISTER_CLASS_BODY_PART(index, statement_class_array, statement_class_max, name, name_length) - index= PFS_atomic::add_u32(&statement_class_dirty_count, 1); + index= statement_class_dirty_count.fetch_add(1); if (index < statement_class_max) { @@ -1465,7 +1465,7 @@ PFS_statement_key register_statement_class(const char *name, uint name_length, 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); + statement_class_allocated_count.fetch_add(1); return (index + 1); } @@ -1537,7 +1537,7 @@ PFS_socket_key register_socket_class(const char *name, uint name_length, REGISTER_CLASS_BODY_PART(index, socket_class_array, socket_class_max, name, name_length) - index= PFS_atomic::add_u32(&socket_class_dirty_count, 1); + index= socket_class_dirty_count.fetch_add(1); if (index < socket_class_max) { @@ -1549,7 +1549,7 @@ PFS_socket_key register_socket_class(const char *name, uint name_length, 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); + socket_class_allocated_count.fetch_add(1); return (index + 1); } @@ -1590,7 +1590,7 @@ PFS_memory_key register_memory_class(const char *name, uint name_length, REGISTER_CLASS_BODY_PART(index, memory_class_array, memory_class_max, name, name_length) - index= PFS_atomic::add_u32(&memory_class_dirty_count, 1); + index= memory_class_dirty_count.fetch_add(1); if (index < memory_class_max) { @@ -1601,7 +1601,7 @@ PFS_memory_key register_memory_class(const char *name, uint name_length, /* 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); + memory_class_allocated_count.fetch_add(1); return (index + 1); } diff --git a/storage/perfschema/pfs_instr_class.h b/storage/perfschema/pfs_instr_class.h index f353c410d4c..57c7f9e5464 100644 --- a/storage/perfschema/pfs_instr_class.h +++ b/storage/perfschema/pfs_instr_class.h @@ -23,11 +23,12 @@ #ifndef PFS_INSTR_CLASS_H #define PFS_INSTR_CLASS_H +#include + #include "my_global.h" #include "mysql_com.h" /* NAME_LEN */ #include "lf.h" #include "pfs_global.h" -#include "pfs_atomic.h" #include "sql_array.h" /** @@ -329,22 +330,22 @@ public: inline void init_refcount(void) { - PFS_atomic::store_32(& m_refcount, 1); + m_refcount.store(1); } inline int get_refcount(void) { - return PFS_atomic::load_32(& m_refcount); + return m_refcount.load(); } inline void inc_refcount(void) { - PFS_atomic::add_32(& m_refcount, 1); + m_refcount.fetch_add(1); } inline void dec_refcount(void) { - PFS_atomic::add_32(& m_refcount, -1); + m_refcount.fetch_sub(1); } void refresh_setup_object_flags(PFS_thread *thread); @@ -387,7 +388,7 @@ public: private: /** Number of opened table handles. */ - int m_refcount; + std::atomic m_refcount; /** Table locks statistics. */ PFS_table_share_lock *m_race_lock_stat; /** Table indexes' stats. */ diff --git a/storage/perfschema/pfs_lock.h b/storage/perfschema/pfs_lock.h index 0f4bcb6de8f..4d3c7c040e8 100644 --- a/storage/perfschema/pfs_lock.h +++ b/storage/perfschema/pfs_lock.h @@ -28,9 +28,9 @@ Performance schema internal locks (declarations). */ -#include "my_global.h" +#include -#include "pfs_atomic.h" +#include "my_global.h" /* to cause bugs, testing */ // #define MEM(X) std::memory_order_relaxed @@ -103,7 +103,7 @@ struct pfs_lock The version number is stored in the high 30 bits. The state is stored in the low 2 bits. */ - uint32 m_version_state; + std::atomic m_version_state; uint32 copy_version_state() { @@ -119,7 +119,7 @@ struct pfs_lock { uint32 copy; - copy= PFS_atomic::load_u32(&m_version_state); + copy= m_version_state.load(); return ((copy & STATE_MASK) == PFS_LOCK_FREE); } @@ -129,7 +129,7 @@ struct pfs_lock { uint32 copy; - copy= PFS_atomic::load_u32(&m_version_state); + copy= m_version_state.load(); return ((copy & STATE_MASK) == PFS_LOCK_ALLOCATED); } @@ -144,7 +144,7 @@ struct pfs_lock { uint32 old_val; - old_val= PFS_atomic::load_u32(&m_version_state); + old_val= m_version_state.load(); if ((old_val & STATE_MASK) != PFS_LOCK_FREE) { @@ -154,7 +154,7 @@ struct pfs_lock uint32 new_val= (old_val & VERSION_MASK) + PFS_LOCK_DIRTY; bool pass; - pass= PFS_atomic::cas_u32(&m_version_state, &old_val, new_val); + pass= m_version_state.compare_exchange_strong(old_val, new_val); if (pass) { @@ -178,7 +178,7 @@ struct pfs_lock uint32 new_val= (copy & VERSION_MASK) + PFS_LOCK_DIRTY; /* We own the record, no need to use compare and swap. */ - PFS_atomic::store_u32(&m_version_state, new_val); + m_version_state.store(new_val); copy_ptr->m_version_state= new_val; } @@ -195,7 +195,7 @@ struct pfs_lock /* Increment the version, set the ALLOCATED state */ uint32 new_val= (copy->m_version_state & VERSION_MASK) + VERSION_INC + PFS_LOCK_ALLOCATED; - PFS_atomic::store_u32(&m_version_state, new_val); + m_version_state.store(new_val); } /** @@ -210,7 +210,7 @@ struct pfs_lock /* Increment the version, set the ALLOCATED state */ uint32 new_val= (copy & VERSION_MASK) + VERSION_INC + PFS_LOCK_ALLOCATED; - PFS_atomic::store_u32(&m_version_state, new_val); + m_version_state.store(new_val); } /** @@ -219,10 +219,10 @@ struct pfs_lock void set_dirty(pfs_dirty_state *copy_ptr) { /* Do not set the version to 0, read the previous value. */ - uint32 copy= PFS_atomic::load_u32(&m_version_state); + uint32 copy= m_version_state.load(); /* Increment the version, set the DIRTY state */ uint32 new_val= (copy & VERSION_MASK) + VERSION_INC + PFS_LOCK_DIRTY; - PFS_atomic::store_u32(&m_version_state, new_val); + m_version_state.store(new_val); copy_ptr->m_version_state= new_val; } @@ -238,7 +238,7 @@ struct pfs_lock /* Keep the same version, set the FREE state */ uint32 new_val= (copy->m_version_state & VERSION_MASK) + PFS_LOCK_FREE; - PFS_atomic::store_u32(&m_version_state, new_val); + m_version_state.store(new_val); } /** @@ -258,7 +258,7 @@ struct pfs_lock /* Keep the same version, set the FREE state */ uint32 new_val= (copy & VERSION_MASK) + PFS_LOCK_FREE; - PFS_atomic::store_u32(&m_version_state, new_val); + m_version_state.store(new_val); } /** @@ -268,7 +268,7 @@ struct pfs_lock */ void begin_optimistic_lock(struct pfs_optimistic_state *copy) { - copy->m_version_state= PFS_atomic::load_u32(&m_version_state); + copy->m_version_state= m_version_state.load(); } /** @@ -285,7 +285,7 @@ struct pfs_lock if ((copy->m_version_state & STATE_MASK) != PFS_LOCK_ALLOCATED) return false; - version_state= PFS_atomic::load_u32(&m_version_state); + version_state= m_version_state.load(); /* Check the version + state has not changed. */ if (copy->m_version_state != version_state) @@ -298,7 +298,7 @@ struct pfs_lock { uint32 version_state; - version_state= PFS_atomic::load_u32(&m_version_state); + version_state= m_version_state.load(); return (version_state & VERSION_MASK); } diff --git a/storage/perfschema/pfs_memory.cc b/storage/perfschema/pfs_memory.cc index 0ee8e3dd7df..7cb932b3502 100644 --- a/storage/perfschema/pfs_memory.cc +++ b/storage/perfschema/pfs_memory.cc @@ -33,7 +33,6 @@ #include "pfs_account.h" #include "pfs_host.h" #include "pfs_user.h" -#include "pfs_atomic.h" #include "pfs_buffer_container.h" #include "m_string.h" diff --git a/storage/perfschema/pfs_status.cc b/storage/perfschema/pfs_status.cc index 2596c53c4ad..9d3bcd43ec3 100644 --- a/storage/perfschema/pfs_status.cc +++ b/storage/perfschema/pfs_status.cc @@ -34,7 +34,6 @@ #include "pfs_host.h" #include "pfs_user.h" #include "pfs_status.h" -#include "pfs_atomic.h" #include "pfs_buffer_container.h" #include "sql_show.h" /* reset_status_vars */ diff --git a/storage/perfschema/pfs_user.h b/storage/perfschema/pfs_user.h index e15e733e5ac..e92629e4dd7 100644 --- a/storage/perfschema/pfs_user.h +++ b/storage/perfschema/pfs_user.h @@ -28,6 +28,8 @@ Performance schema user (declarations). */ +#include + #include "pfs_lock.h" #include "lf.h" #include "pfs_con_slice.h" @@ -58,22 +60,22 @@ struct PFS_ALIGNED PFS_user : public PFS_connection_slice public: inline void init_refcount(void) { - PFS_atomic::store_32(& m_refcount, 1); + m_refcount.store(1); } inline int get_refcount(void) { - return PFS_atomic::load_32(& m_refcount); + return m_refcount.load(); } inline void inc_refcount(void) { - PFS_atomic::add_32(& m_refcount, 1); + m_refcount.fetch_add(1); } inline void dec_refcount(void) { - PFS_atomic::add_32(& m_refcount, -1); + m_refcount.fetch_sub(1); } void aggregate(bool alive); @@ -97,7 +99,7 @@ public: ulonglong m_disconnected_count; private: - int m_refcount; + std::atomic m_refcount; }; int init_user(const PFS_global_param *param);