PS-9647: MySQL Perf Improvements

https://perconadev.atlassian.net/browse/PS-9647

This patch introduces a new hybrid data structure for MVCC ReadView from Enhanced MySQL

Typically, online transactions are short rather than long, and transaction IDs
increase continuously. To leverage these characteristics, a hybrid data
structure is used: a static array for consecutive short transaction IDs and a
vector for long transactions. With a 2048-byte array, up to 16,384 consecutive
active transaction IDs can be stored, each bit representing a transaction ID.

The minimum short transaction ID is used to differentiate between short and long
transactions.

IDs smaller than this minimum go into the long transaction vector, while IDs
equal to or greater than it are placed in the short transaction array.

For an ID in changes_visible, if it is below the minimum short transaction ID, a
direct query is made to the vector, which is efficient due to the generally
small number of long transactions.

If the ID is equal to or above the minimum short transaction ID, a bitwise query
is performed, with a time complexity of O(1), compared to the previous O(log n)
complexity. This improvement enhances efficiency and reduces cache migration
between NUMA nodes, as O(1) queries typically complete within a single CPU time
slice.

- In the short_rw_trx_ids_bitmap structure, MAX_SHORT_ACTIVE_BYTES is set to
  65536, theoretically accommodating up to 524,288 consecutive short transaction
  IDs.

- If the limit is exceeded, the oldest short transaction IDs are converted into
  long transactions and stored in long_rw_trx_ids.

- Global long and short transactions are distinguished by min_short_valid_id:
  IDs smaller than this value are treated as global long transactions, while IDs
  equal to or greater are considered global short transactions.

During the copying process from the global active transaction list, the
short_rw_trx_ids_bitmap structure, which uses only one bit per transaction ID,
allows for much higher copying efficiency compared to the native MySQL solution.

For example, with 1000 active transactions, the native MySQL version would
require copying at least 8000 bytes, whereas the optimized solution may only
need a few hundred bytes. This results in a significant improvement in copying
efficiency.

Author: Venkatesh Prasad

storage/innobase/include/read0types.h

@@ -46,6 +46,9 @@ class MVCC;
 /** Read view lists the trx ids of those transactions for which a consistent
 read should not see the modifications to the database. */
 
+#define MAX_TOP_ACTIVE_BYTES 8192
+#define MAX_SHORT_ACTIVE_BYTES 65536
+
 class ReadView {
   /** This is similar to a std::vector but it is not a drop
   in replacement. It is specific to ReadView. */
@@ -173,14 +176,33 @@ class ReadView {
 
     if (id >= m_low_limit_id) {
       return (false);
-
-    } else if (m_ids.empty()) {
+    } else if (empty()) {
       return (true);
     }
 
-    const ids_t::value_type *p = m_ids.data();
+    /* first search short bitmap */
+    if (m_has_short_actives && id >= m_short_min_id) {
+      if (id > m_short_max_id) {
+        return false;
+      }
+      unsigned int trim_id = id & 0x7FFFF;
+      unsigned int trim_min_id = m_short_min_id & 0x7FFFF;
+      unsigned int array_index = (trim_id >> 3);
+      unsigned int array_min_index = (trim_min_id >> 3);
+      array_index = (MAX_SHORT_ACTIVE_BYTES + array_index - array_min_index) %
+                    MAX_TOP_ACTIVE_BYTES;
+      unsigned int array_remainder = trim_id & (0x7);
+      int is_value_set = top_active[array_index] & (1 << (7 - array_remainder));
+      if (is_value_set) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+
+    const ids_t::value_type *p = m_long_ids.data();
 
-    return (!std::binary_search(p, p + m_ids.size(), id));
+    return (!std::binary_search(p, p + m_long_ids.size(), id));
   }
 
   /**
@@ -235,7 +257,18 @@ class ReadView {
 
   /**
   @return true if there are no transaction ids in the snapshot */
-  bool empty() const { return (m_ids.empty()); }
+  bool empty() const {
+    bool long_empty = m_long_ids.empty();
+    if (long_empty) {
+      if (!m_has_short_actives) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
 
   /**
   Clones a read view object. The resulting read view has identical change
@@ -264,17 +297,19 @@ class ReadView {
     fprintf(file, "Read view low limit trx n:o " TRX_ID_FMT "\n",
             low_limit_no());
     print_limits(file);
-    fprintf(file, "Read view individually stored trx ids:\n");
-    for (ulint i = 0; i < m_ids.size(); i++)
-      fprintf(file, "Read view trx id " TRX_ID_FMT "\n", m_ids.data()[i]);
+    fprintf(file, "Read view individually stored long trx ids:\n");
+    for (ulint i = 0; i < m_long_ids.size(); i++)
+      fprintf(file, "Read view trx id " TRX_ID_FMT "\n", m_long_ids.data()[i]);
   }
 
   bool is_cloned() const noexcept { return (m_cloned); }
 
  private:
   /**
   Copy the transaction ids from the source vector */
-  inline void copy_trx_ids(const trx_ids_t &trx_ids);
+  inline void copy_long_trx_ids(const trx_ids_t &trx_ids,
+                                trx_id_t min_short_id);
+  inline void copy_short_trx_ids();
 
   /**
   Opens a read view where exactly the transactions serialized before this
@@ -307,6 +342,7 @@ class ReadView {
   ReadView &operator=(const ReadView &);
 
  private:
+  unsigned char top_active[MAX_TOP_ACTIVE_BYTES];
   /** The read should not see any transaction with trx id >= this
   value. In other words, this is the "high water mark". */
   trx_id_t m_low_limit_id;
@@ -322,7 +358,7 @@ class ReadView {
 
   /** Set of RW transactions that was active when this snapshot
   was taken */
-  ids_t m_ids;
+  ids_t m_long_ids;
 
   /** The view does not need to see the undo logs for transactions
   whose transaction number is strictly smaller (<) than this value:
@@ -337,6 +373,10 @@ class ReadView {
   trx_id_t m_view_low_limit_no;
 #endif /* UNIV_DEBUG */
 
+  trx_id_t m_short_min_id;
+  trx_id_t m_short_max_id;
+  bool m_has_short_actives;
+
   /** AC-NL-RO transaction view that has been "closed". */
   bool m_closed;
 

storage/innobase/include/trx0sys.h

@@ -553,7 +553,11 @@ struct trx_sys_t {
   take a snapshot of these transactions whose changes are not visible to it.
   We should remove transactions from the list before committing in memory and
   releasing locks to ensure right order of removal and consistent snapshot. */
-  trx_ids_t rw_trx_ids;
+  trx_ids_t long_rw_trx_ids;
+  unsigned char short_rw_trx_ids_bitmap[MAX_SHORT_ACTIVE_BYTES];
+  int short_rw_trx_valid_number;
+  trx_id_t min_short_valid_id;
+  trx_id_t max_short_valid_id;
 
   char pad7[ut::INNODB_CACHE_LINE_SIZE];