The concluding commit prior to collapse the branch.

- renaming
- function header comments added
- hyperoptimization of `wfc->parent_commit_started` is removed
  for the reason of not having been proved safe
- the size of the XAP sliding window is doubled to account
  a possibility of XAP_k -> XAP_k+2|W|-1 dependency.
  Say k=1, and the # of Workers is 4. Transaction are distributed RR,
  then it's possible to have T^*_1 -> T^*_8. It's seen from worker
  queues. The queue depelops downward:

  W1 ...  W4
  1^* 2 3 4
  5   6 7 8^*

 Worker # 1 has assigned with
  T_1 and T_5. Worker #4 can take on its T_8 when T_1 is yet at the
  beginning of its processing, so even before XA START of that XAP.

  This analysis was done couple of weeks ago, but I have not found a
  commit planned to cover it.

Author: andrelkin

sql/log.cc

@@ -7944,7 +7944,7 @@ MYSQL_BIN_LOG::queue_for_group_commit(group_commit_entry *orig_entry)
       it.
     */
     if ((loc_waitee= wfc->waitee.load(std::memory_order_relaxed)) &&
-        !(wfc->parent_commit_started= loc_waitee->commit_started))
+        !loc_waitee->commit_started)
     {
       PSI_stage_info old_stage;
 
@@ -8336,7 +8336,7 @@ MYSQL_BIN_LOG::write_transaction_to_binlog_events(group_commit_entry *entry)
   }
 
   if (likely(!entry->error))
-    return  (entry->thd->wait_for_commit_ptr && entry->thd->wait_for_commit_ptr->parent_commit_started) ? 0 : entry->thd->wait_for_prior_commit();
+    return entry->thd->wait_for_prior_commit();
 
   switch (entry->error)
   {

sql/mysqld.cc

@@ -1055,7 +1055,7 @@ PSI_cond_key key_BINLOG_COND_xid_list,
   key_BINLOG_COND_queue_busy;
 PSI_cond_key key_RELAYLOG_COND_relay_log_updated,
   key_RELAYLOG_COND_bin_log_updated, key_COND_wakeup_ready,
-  key_COND_wait_commit, key_COND_wait_xa_commit;
+  key_COND_wait_commit, key_COND_wait_commit_dep;
 PSI_cond_key key_RELAYLOG_COND_queue_busy;
 PSI_cond_key key_TC_LOG_MMAP_COND_queue_busy;
 PSI_cond_key key_COND_rpl_thread_queue, key_COND_rpl_thread,
@@ -1083,7 +1083,7 @@ static PSI_cond_info all_server_conds[]=
   { &key_RELAYLOG_COND_queue_busy, "MYSQL_RELAY_LOG::COND_queue_busy", 0},
   { &key_COND_wakeup_ready, "THD::COND_wakeup_ready", 0},
   { &key_COND_wait_commit, "wait_for_commit::COND_wait_commit", 0},
-  { &key_COND_wait_commit, "wait_for_commit::COND_wait_xa_commit", 0},
+  { &key_COND_wait_commit, "wait_for_commit::COND_wait_commit_dep", 0},
   { &key_COND_cache_status_changed, "Query_cache::COND_cache_status_changed", 0},
   { &key_COND_manager, "COND_manager", PSI_FLAG_GLOBAL},
   { &key_COND_server_started, "COND_server_started", PSI_FLAG_GLOBAL},

sql/mysqld.h

@@ -376,7 +376,7 @@ extern PSI_cond_key key_BINLOG_COND_xid_list, key_BINLOG_update_cond,
   key_COND_start_thread;
 extern PSI_cond_key key_RELAYLOG_COND_relay_log_updated,
   key_RELAYLOG_COND_bin_log_updated, key_COND_wakeup_ready,
-  key_COND_wait_commit, key_COND_wait_xa_commit;
+  key_COND_wait_commit, key_COND_wait_commit_dep;
 extern PSI_cond_key key_RELAYLOG_COND_queue_busy;
 extern PSI_cond_key key_TC_LOG_MMAP_COND_queue_busy;
 extern PSI_cond_key key_COND_rpl_thread, key_COND_rpl_thread_queue,

sql/rpl_parallel.cc

@@ -2521,7 +2521,7 @@ rpl_parallel::find(uint32 domain_id)
 
     e->concurrent_xaps_window.init((PSI_memory_key) PSI_INSTRUMENT_ME,
                                    max((decltype(e->rpl_thread_max)) 2,
-                                        e->rpl_thread_max));
+                                        2*e->rpl_thread_max));
     e->cxap_lhs= e->cxap_rhs= 0;
 
     /*
@@ -2809,8 +2809,17 @@ abandon_worker_thread(THD *thd, rpl_parallel_thread *cur_thread,
 }
 
 /**
-  @return true when there exists a duplicate xid hash value,
-          otherwise false.
+  Check the concurrency status of @c xid with ones in progress.
+  Any new @c xid of XA-prepare (@c is_xap is true then) is appended to
+  a sliding window designed as circular buffer. Through search in the window
+  the return result is computed.
+
+  @param  e      parallel entry pointer
+  @param  xid    a pointer to the xid of either XA-prepare of XA-"complete"
+  @param  is_xap
+                 true when xid belongs to XA-prepare
+  @return true   when there exists a duplicate xid hash value,
+          false  otherwise.
 */
 static bool
 handle_xa_prepera_duplicate_xid(rpl_parallel_entry *e, XID *xid, bool is_xap)
@@ -2832,8 +2841,9 @@ handle_xa_prepera_duplicate_xid(rpl_parallel_entry *e, XID *xid, bool is_xap)
     of the window.
     Otherwise RHS always points to a free cell of which one at least must
     exist at this point.
-    Potential conflicts with the current input xid can come only from
-    the preceeding |W| - 1 xids, the |W|th in the past is safe.
+    While transaction disribution is Round-robin, potential conflicts with
+    the current input xid can come only from
+    the preceeding 2*|W| - 1 xids, the 2*|W|th in the past is safe.
   */
   for (i= e->cxap_lhs; i != e->cxap_rhs;
        i= (i+1) % (e->concurrent_xaps_window.max_size()))
@@ -3132,7 +3142,9 @@ rpl_parallel::do_event(rpl_group_info *serial_rgi, Log_event *ev,
     gco= e->current_gco;
     /*
       Take care of duplicate xids in XA-prepare, XA-"complete" should not
-      race its XA-prepare parent either.
+      race its XA-prepare parent either. When the current transaction's xid
+      was seen and its transaction may still be in process this event group
+      gets flagged to wait for prior commits at the start of execution.
     */
     if ((gtid_flags & (Gtid_log_event::FL_PREPARED_XA |
                        Gtid_log_event::FL_COMPLETED_XA)) &&

sql/rpl_parallel.h

@@ -428,12 +428,9 @@ struct rpl_parallel_entry {
   group_commit_orderer *current_gco;
 
   /*
-    Circular buffer of size slave_parallel_threads to hold XIDs which may
-    prepare concurrently along with the one that the SQL thread is currently
-    processing.
-
-    For each queued event, the last element in the index is reset, and if the
-    new event is an XAP, the xid will be saved in the spot of the last element.
+    Circular buffer of size slave_parallel_threads to hold XIDs of XA-prepare
+    group of events which may be processed concurrently.
+    See how handle_xa_prepera_duplicate_xid operates on it.
   */
   Dynamic_array<std::pair<std::size_t, uint32>> concurrent_xaps_window;
   uint32 cxap_lhs, cxap_rhs;

sql/rpl_rli.h

@@ -838,9 +838,8 @@ struct rpl_group_info
   /*
     When true indicates that the user xa transaction is going to
     complete (with COMMIT or ROLLBACK) by the worker thread,
-    *while* another worker is preparing it to eventually release
-    the xid for the former terminator one.
-    Upon that followed by the xid acquisition the value flips to false.
+    *while* another worker is still preparing it. Once the latter is done
+    the xid will be acquired and the flag gets reset.
   */
   bool is_async_xac;
 

sql/sql_class.cc

@@ -7933,7 +7933,6 @@ wait_for_commit::reinit()
   wakeup_subsequent_commits_running= false;
   commit_started= false;
   wakeup_blocked= false;
-  parent_commit_started= false;
 #ifdef SAFE_MUTEX
   /*
     When using SAFE_MUTEX, the ordering between taking the LOCK_wait_commit
@@ -7959,7 +7958,7 @@ wait_for_commit::wait_for_commit()
 {
   mysql_mutex_init(key_LOCK_wait_commit, &LOCK_wait_commit, MY_MUTEX_INIT_FAST);
   mysql_cond_init(key_COND_wait_commit, &COND_wait_commit, 0);
-  mysql_cond_init(key_COND_wait_xa_commit, &COND_wait_xa_commit, 0);
+  mysql_cond_init(key_COND_wait_commit_dep, &COND_wait_commit_dep, 0);
   reinit();
 }
 
@@ -7989,7 +7988,7 @@ wait_for_commit::~wait_for_commit()
 
   mysql_mutex_destroy(&LOCK_wait_commit);
   mysql_cond_destroy(&COND_wait_commit);
-  mysql_cond_destroy(&COND_wait_xa_commit);
+  mysql_cond_destroy(&COND_wait_commit_dep);
 }
 
 

sql/sql_class.h

@@ -2354,11 +2354,15 @@ struct wait_for_commit
     event group is fully done.
   */
   bool wakeup_blocked;
-  mysql_cond_t COND_wait_xa_commit;
+  /*
+    The condition variable servers as a part of facilities to handle various
+    commit time additional dependency between groups of replication events, e.g
+    XA-Prepare -> XA-Commit, or XA-Prepare -> XA-Prepare all with the same xid.
+  */
+  mysql_cond_t COND_wait_commit_dep;
 #ifndef DBUG_OFF
   bool debug_done;
 #endif
-  bool parent_commit_started;
 
   void register_wait_for_prior_commit(wait_for_commit *waitee);
   int wait_for_prior_commit(THD *thd, bool allow_kill=true)

sql/xa.cc

@@ -343,15 +343,15 @@ bool xid_cache_insert_maybe_wait(THD* thd)
       if (waiter) // notifier was not seen
       {
         mysql_mutex_lock(&waiter->LOCK_wait_commit);
-        thd->ENTER_COND(&waiter->COND_wait_xa_commit, &waiter->LOCK_wait_commit,
+        thd->ENTER_COND(&waiter->COND_wait_commit_dep, &waiter->LOCK_wait_commit,
                         &stage_waiting_for_prior_xa_transaction,
                         &old_stage);
         if ((element=
              (XID_cache_element*) lf_hash_search(&xid_cache, thd->xid_hash_pins,
                                                  xid->key(), xid->key_length())))
         {
           lf_hash_search_unpin(thd->xid_hash_pins);
-          mysql_cond_wait(&waiter->COND_wait_xa_commit,
+          mysql_cond_wait(&waiter->COND_wait_commit_dep,
                           &waiter->LOCK_wait_commit);
 
           DBUG_ASSERT(waiter->debug_done || thd->check_killed(1));
@@ -440,12 +440,12 @@ XID_cache_element * xid_cache_search_maybe_wait(THD* thd)
         {
           PSI_stage_info old_stage;
           mysql_mutex_lock(&waiter->LOCK_wait_commit);
-          thd->ENTER_COND(&waiter->COND_wait_xa_commit, &waiter->LOCK_wait_commit,
+          thd->ENTER_COND(&waiter->COND_wait_commit_dep, &waiter->LOCK_wait_commit,
                           &stage_waiting_for_prior_xa_transaction,
                           &old_stage);
           if (element->c_waiter.load(std::memory_order_relaxed) &&
               likely(!thd->check_killed(1)))
-            mysql_cond_wait(&waiter->COND_wait_xa_commit,
+            mysql_cond_wait(&waiter->COND_wait_commit_dep,
                             &waiter->LOCK_wait_commit);
 
           if (element->c_waiter.load(std::memory_order_relaxed))
@@ -552,7 +552,7 @@ static void xid_cache_delete(THD *thd, XID_cache_element *&element)
 #ifndef DBUG_OFF
     waiter->debug_done= true;
 #endif
-    mysql_cond_signal(&waiter->COND_wait_xa_commit);
+    mysql_cond_signal(&waiter->COND_wait_commit_dep);
     mysql_mutex_unlock(&waiter->LOCK_wait_commit);
   }
 }
@@ -1445,9 +1445,8 @@ static bool slave_applier_reset_xa_trans(THD *thd)
     // unmark and signal
     mysql_mutex_lock(&xac_waiter->LOCK_wait_commit);
     element->c_waiter.store(NULL, std::memory_order_relaxed);
-    mysql_cond_signal(&xac_waiter->COND_wait_xa_commit);
+    mysql_cond_signal(&xac_waiter->COND_wait_commit_dep);
     mysql_mutex_unlock(&xac_waiter->LOCK_wait_commit);
-    sql_print_information("Notified XA COMMIT");
   }
   thd->transaction->cleanup();
   thd->transaction->all.reset();