[MDEV-28162] Replace PFS_atomic with std::atomic<T>

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<T>::store()

  - PFS_atomic::load_*()
      -> my_atomic_load*
        -> __atomic_load_n()
    => std::atomic<T>::load()

  - PFS_atomic::add_*()
      -> my_atomic_add*
        -> __atomic_fetch_add()
    => std::atomic<T>::fetch_add()

  - PFS_atomic::cas_*()
    -> my_atomic_cas*
      -> __atomic_compare_exchange_n()
    => std::atomic<T>::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.

Author: keeper

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

storage/perfschema/pfs_account.h

@@ -27,6 +27,7 @@
   @file storage/perfschema/pfs_account.h
   Performance schema account (declarations).
 */
+#include <atomic>
 
 #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 @@ struct PFS_ALIGNED PFS_account : PFS_connection_slice
   ulonglong m_disconnected_count;
 
 private:
-  int m_refcount;
+  std::atomic<int> m_refcount;
 };
 
 int init_account(const PFS_global_param *param);

storage/perfschema/pfs_atomic.h

@@ -87,7 +87,7 @@ class PFS_buffer_default_array
     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<uint>(m_max);
 
     while (monotonic < monotonic_max)
@@ -99,7 +99,8 @@ class PFS_buffer_default_array
       {
         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 @@ class PFS_buffer_scalable_container
 
   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 @@ class PFS_buffer_scalable_container
     /*
       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 @@ class PFS_buffer_scalable_container
           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 @@ class PFS_buffer_scalable_container
           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);

storage/perfschema/pfs_buffer_container.h

@@ -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 @@ find_or_create_digest(PFS_thread *thread,
 
   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;
 }
 

storage/perfschema/pfs_digest.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;

storage/perfschema/pfs_events_stages.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;

storage/perfschema/pfs_events_statements.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;