Bug#32042393: SETTING TO INACTIVE AN UPGRADED EMPTY UNDO

TABLESPACE STATE DOES NOT CHANGE THE SPACE TO EMPTY

After the commit for Bug#31991688, it was found that an idle system may
not ever get around to truncating an undo tablespace when it is SET INACTIVE.
Actually, it takes about 128 seconds before the undo tablespace is finally
truncated.

There are three main tasks for the function trx_purge().
1) Process the undo logs and apply changes to the data files.
   (May be multiple threads)
2) Clean up the history list by freeing old undo logs and rollback
   segments.
3) Truncate undo tablespaces that have grown too big or are SET INACTIVE
   explicitly.

Bug#31991688 made sure that steps 2 & 3 are not done too often.
Concentrating this effort keeps the purge lag from growing too large.
By default, trx_purge() does step#1 128 times before attempting steps
#2 & #3 which are called 'truncate' steps.  This is set by the setting
innodb_purge_rseg_truncate_frequency.

On an idle system, trx_purge() is called once per second if it has nothing
to do in step 1.  After 128 seconds, it will finally do steps 2 (truncating
the undo logs and rollback segments which reduces the history list to zero)
and step 3 (truncating any undo tablespaces that need it).

The function that the purge coordinator thread uses to make these repeated
calls to trx_purge() is called srv_do_purge(). When trx_purge() returns
having done nothing, srv_do_purge() returns to srv_purge_coordinator_thread()
which will put the purge thread to sleep.  It is woke up again once per
second by the master thread in srv_master_do_idle_tasks() if not sooner
by any of several of other threads and activities.

This is how an idle system can wait 128 seconds before the truncate steps
are done and an undo tablespace that was SET INACTIVE can finally become
'empty'.

The solution in this patch is to modify srv_do_purge() so that if trx_purge()
did nothing and there is an undo space that was explicitly set to inactive,
it will immediately call trx_purge again with do_truncate=true so that steps
#2 and #3 will be done.

This does not affect the effort by Bug#31991688 to keep the purge lag from
growing too big on sysbench UPDATE NO_KEY. With this change, the purge lag
has to be zero and there must be a pending explicit undo space truncate
before this extra call to trx_purge is done.

Approved by Sunny in RB#25311

Author: kdjakevin

storage/innobase/include/trx0purge.h

@@ -720,6 +720,31 @@ class Tablespaces {
     return (nullptr);
   }
 
+  /** Find the first undo space that is marked inactive explicitly.
+  @param[in,out]  num_active  If there are no inactive_explicit spaces
+                              found, this will contain the number of
+                              active spaces found.
+  @return pointer to an undo::Tablespace struct */
+  Tablespace *find_first_inactive_explicit(size_t *num_active) {
+    ut_ad(own_latch());
+
+    if (m_spaces.empty()) {
+      return (nullptr);
+    }
+
+    for (auto undo_space : m_spaces) {
+      if (undo_space->is_inactive_explicit()) {
+        return (undo_space);
+      }
+
+      if (num_active != nullptr && undo_space->is_active()) {
+        (*num_active)++;
+      }
+    }
+
+    return (nullptr);
+  }
+
 #ifdef UNIV_DEBUG
   /** Determine if this thread owns a lock on m_latch. */
   bool own_latch() {

storage/innobase/srv/srv0srv.cc

@@ -2964,16 +2964,16 @@ void srv_worker_thread() {
 }
 
 /** Do the actual purge operation.
- @return length of history list before the last purge batch. */
-static ulint srv_do_purge(
-    ulint *n_total_purged) /*!< in/out: total pages purged */
-{
+@param[in,out]  n_total_purged  Total pages purged in this call
+@return length of history list before the last purge batch. */
+static ulint srv_do_purge(ulint *n_total_purged) {
   ulint n_pages_purged;
 
   static ulint count = 0;
   static ulint n_use_threads = 0;
   static uint64_t rseg_history_len = 0;
   ulint old_activity_count = srv_get_activity_count();
+  bool need_explicit_truncate = false;
 
   const auto n_threads = srv_threads.m_purge_workers_n;
 
@@ -3020,18 +3020,25 @@ static ulint srv_do_purge(
       break;
     }
 
-    bool do_truncate =
-        (srv_shutdown_state.load() == SRV_SHUTDOWN_PURGE
-             ? true
-             : (++count % srv_purge_rseg_truncate_frequency) == 0);
+    bool do_truncate = need_explicit_truncate ||
+                       srv_shutdown_state.load() == SRV_SHUTDOWN_PURGE ||
+                       (++count % srv_purge_rseg_truncate_frequency) == 0;
 
     n_pages_purged =
         trx_purge(n_use_threads, srv_purge_batch_size, do_truncate);
 
     *n_total_purged += n_pages_purged;
 
-  } while (!srv_purge_should_exit(n_pages_purged) && n_pages_purged > 0 &&
-           purge_sys->state == PURGE_STATE_RUN);
+    need_explicit_truncate = (n_pages_purged == 0);
+    if (need_explicit_truncate) {
+      undo::spaces->s_lock();
+      need_explicit_truncate =
+          (undo::spaces->find_first_inactive_explicit(nullptr) != nullptr);
+      undo::spaces->s_unlock();
+    }
+  } while (purge_sys->state == PURGE_STATE_RUN &&
+           (n_pages_purged > 0 || need_explicit_truncate) &&
+           !srv_purge_should_exit(n_pages_purged));
 
   return rseg_history_len;
 }

storage/innobase/trx/trx0purge.cc

@@ -1221,16 +1221,14 @@ static bool trx_purge_mark_undo_for_truncate(size_t truncate_count) {
   /* In order to implicitly select an undo space to truncate, we need
   at least 2 active UNDO tablespaces.  As long as there is one undo
   tablespace active the server will continue to operate. */
-  ulint num_active = 0;
+  size_t num_active = 0;
 
   /* Look for any undo space that is inactive explicitly. */
-  for (auto undo_ts : undo::spaces->m_spaces) {
-    if (undo_ts->is_inactive_explicit()) {
-      undo_trunc->mark(undo_ts);
-      undo::spaces->s_unlock();
-      return (true);
-    }
-    num_active += (undo_ts->is_active() ? 1 : 0);
+  auto undo_ts = undo::spaces->find_first_inactive_explicit(&num_active);
+  if (undo_ts != nullptr) {
+    undo_trunc->mark(undo_ts);
+    undo::spaces->s_unlock();
+    return (true);
   }
 
   undo::spaces->s_unlock();
@@ -2007,12 +2005,12 @@ static MY_ATTRIBUTE((warn_unused_result))
 
     if (!purge_sys->next_stored) {
       DBUG_PRINT("ib_purge", ("no logs left in the history list"));
-      return (nullptr);
+      return nullptr;
     }
   }
 
   if (purge_sys->iter.trx_no >= purge_sys->view.low_limit_no()) {
-    return (nullptr);
+    return nullptr;
   }
 
   /* fprintf(stderr, "Thread %lu purging trx %llu undo record %llu\n",