Bug #31095274 I_INNODB.INNODB_BUG16138582 TIMES OUT ON WINDOWS [Part 2/2]

This patch is using findings from the bug resolution that found the AIO threads have uneven amounts of completed OS IO requests ready to be served.
This changes the way AIO::reserve_slot() works to balance the use of the segments.

RB#24646

Author: Marcin Babij

storage/innobase/os/os0file.cc

@@ -736,6 +736,13 @@ class AIO {
   the ibuf segment */
   ulint m_n_reserved;
 
+  /** The index of last slot used to reserve. This is used to balance the
+   incoming requests more evenly throughout the segments.
+   This field is not guarded by any lock.
+   This is only used as a heuristic and any value read or written to it is OK.
+   It is atomic as it is accesses without any latches from multiple threads. */
+  std::atomic_size_t m_last_slot_used;
+
 #ifdef _WIN32
   typedef std::vector<HANDLE, ut_allocator<HANDLE>> Handles;
 
@@ -1815,7 +1822,7 @@ static char *os_file_get_parent_dir(const char *path) {
 
   if (last_slash - path < 0) {
     /* Sanity check, it prevents gcc from trying to handle this case which
-     * results in warnings for some optimized builds */
+    results in warnings for some optimized builds */
     return (nullptr);
   }
 
@@ -5015,8 +5022,8 @@ static MY_ATTRIBUTE((warn_unused_result)) ssize_t
       block = os_file_compress_page(type, buf, &n);
     } else {
       /* Since e_block is valid, encryption must have already happened. Since we
-       * do compression before encryption, we assert here that there is no
-       * encryption involved. */
+      do compression before encryption, we assert here that there is no
+      encryption involved. */
       ut_ad(!type.is_encrypted());
     }
   } else {
@@ -6136,7 +6143,8 @@ dberr_t os_aio_handler(ulint segment, fil_node_t **m1, void **m2,
 AIO::AIO(latch_id_t id, ulint n, ulint segments)
     : m_slots(n),
       m_n_segments(segments),
-      m_n_reserved()
+      m_n_reserved(),
+      m_last_slot_used(0)
 #ifdef LINUX_NATIVE_AIO
       ,
       m_aio_ctx(),
@@ -6710,11 +6718,6 @@ Slot *AIO::reserve_slot(IORequest &type, fil_node_t *m1, void *m2,
 
   const auto slots_per_seg = slots_per_segment();
 
-  /* We attempt to keep adjacent blocks in the same local
-  segment. This can help in merging IO requests when we are
-  doing simulated AIO */
-  ulint local_seg = (offset >> (UNIV_PAGE_SIZE_SHIFT + 6)) % m_n_segments;
-
   for (;;) {
     acquire();
 
@@ -6734,26 +6737,53 @@ Slot *AIO::reserve_slot(IORequest &type, fil_node_t *m1, void *m2,
     os_event_wait(m_not_full);
   }
 
-  ulint counter = 0;
-  Slot *slot = nullptr;
-
-  /* We start our search for an available slot from our preferred
-  local segment and do a full scan of the array. We are
-  guaranteed to find a slot in full scan. */
-  for (ulint i = local_seg * slots_per_seg; counter < m_slots.size();
-       ++i, ++counter) {
-    i %= m_slots.size();
-
-    slot = at(i);
-
-    if (slot->is_reserved == false) {
-      break;
+  /* We will check first, next(first), next(next(first))... which should be a
+  permutation of values 0,..,m_slots.size()-1.*/
+  auto find_slot = [this](size_t first, auto next) {
+    size_t i = first;
+    for (size_t counter = 0; counter < m_slots.size(); ++counter) {
+      if (!at(i)->is_reserved) {
+        return i;
+      }
+      i = next(i);
     }
-  }
-
-  /* We MUST always be able to get hold of a reserved slot. */
-  ut_a(counter < m_slots.size());
-
+    /* We know that there is a free slot, because m_n_reserved != m_slots.size()
+    was checked under the mutex protection, which we still hold. Additionally
+    the permutation generated by next() should visit all slots. If we checked
+    m_slots.size() elements of the sequence and not found a free slot, then it
+    was not a permutation, or there was no free slot.*/
+    ut_error;
+  };
+  size_t free_index;
+  if (srv_use_native_aio) {
+    /* We assume the m_slots.size() cannot be changed during runtime. */
+    ut_a(m_last_slot_used < m_slots.size());
+    /* We iterate through slots starting with the last used and then trying next
+    ones from consecutive segments to balance the incoming requests evenly
+    between the AIO threads. */
+    free_index = find_slot(m_last_slot_used, [&](size_t i) {
+      i += slots_per_seg;
+      if (i >= m_slots.size()) {
+        /* Start again from the first segment, this time trying next slot in
+        each segment. If we checked the last slot in segment, start with
+        first slot. */
+        i = (i + 1) % slots_per_seg;
+      }
+      return i;
+    });
+    m_last_slot_used = free_index;
+  } else {
+    /* We attempt to keep adjacent blocks in the same local
+    segment. This can help in merging IO requests when we are
+    doing simulated AIO */
+    const size_t local_seg =
+        (offset >> (UNIV_PAGE_SIZE_SHIFT + 6)) % m_n_segments;
+    /* We start our search for an available slot from our preferred
+    local segment and do a full scan of the array. */
+    free_index = find_slot(local_seg * slots_per_seg,
+                           [&](size_t i) { return (i + 1) % m_slots.size(); });
+  }
+  Slot *const slot = at(free_index);
   ut_a(slot->is_reserved == false);
 
   ++m_n_reserved;