Merge branch 'mysql-8.0' into mysql-trunk

Author: Marcin Babij

Diff for: 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;
 
@@ -1816,7 +1823,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);
   }
 
@@ -5016,8 +5023,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 {
@@ -6137,7 +6144,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(),
@@ -6711,11 +6719,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();
 
@@ -6735,26 +6738,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;