Bug#22891628: BINARY GROUP COMMIT HANGS WHEN

BINLOG_GROUP_COMMIT_SYNC_DELAY IS SET TO [1-9]

Problem:
=======
When binlog_group_commit_sync_delay is set to [1-9]:
1) If binlog_group_commit_sync_no_delay_count > 1, and the
number of transaction commits is less than
binlog_group_commit_sync_no_delay_count, these commits will
hang forever if no more commits come in;
2) If binlog_group_commit_sync_no_delay_count = 0, all
transaction commits will hang forever;

Analysis:
=========
Setting binlog_group_commit_sync_no_delay_count option means
that the server exits the wait procedure if the number of
sessions reaches the count given before the timeout i.e is
set in binlog_group_commit_sync_delay elapses. In order to
check if session count has reached the given limit, the
waiting time is broken into small intervals called as delta.
The delta is calculated as 1/10 of total wait time. After
each delta waiting time is elapsed queue size is checked to
see if count has reached. If count is not reached then
wait_time= wait_time - delta. This process is repeated until
wait_time > 0 and count has not been reached.

If the wait_time is set to [1-9] then the delta will become
0. If number of transaction commits is less than the count
and the delta is '0' then wait_time = wait_time - delta will
be a no-op. This will cause the commits to hang as the wait
will never end.

Fix:
===
Have '1' as the minimum delta value,
i.e max(1, wait_time * 0.1) is set as delta.
If 1 > (wait_time * 0.1) then delta=1 other wise
delta= (wait_time * 0.1).

Author: Sujatha Sivakumar

mysql-test/suite/binlog/r/binlog_group_commit_indefinite_wait.result

@@ -0,0 +1,14 @@
+CREATE TABLE t(id INT PRIMARY KEY, v INT NOT NULL) ENGINE INNODB;
+INSERT INTO t VALUES(1, 100), (2, 100), (3, 100), (4, 100);
+SET GLOBAL binlog_group_commit_sync_delay = 8;
+SET GLOBAL binlog_group_commit_sync_no_delay_count = 2;
+BEGIN;
+UPDATE t set v = v + 100 WHERE id = 1;
+COMMIT;
+SET GLOBAL binlog_group_commit_sync_delay = 8;
+SET GLOBAL binlog_group_commit_sync_no_delay_count = 0;
+BEGIN;
+UPDATE t set v = v + 100 WHERE id = 3;
+COMMIT;
+SET GLOBAL binlog_group_commit_sync_delay=0;
+DROP TABLE t;

mysql-test/suite/binlog/t/binlog_group_commit_indefinite_wait.test

@@ -0,0 +1,41 @@
+# ==== Purpose and Implementation ====
+# Set binlog_group_commit_sync_delay to 1~9.
+# case1) Have binlog_group_commit_sync_no_delay_count > 1, and the number of
+# transaction commits less than binlog_group_commit_sync_no_delay_count, these
+# commits should not hang forever if no more commits come in;
+# case2) If binlog_group_commit_sync_no_delay_count = 0 transaction commits
+# should not hang forever;
+#
+# ==== References ====
+#
+# Bug#22891628: BINARY GROUP COMMIT HANGS WHEN BINLOG_GROUP_COMMIT_SYNC_DELAY
+# IS SET TO 1~9
+#
+###############################################################################
+--source include/have_log_bin.inc
+
+CREATE TABLE t(id INT PRIMARY KEY, v INT NOT NULL) ENGINE INNODB;
+
+INSERT INTO t VALUES(1, 100), (2, 100), (3, 100), (4, 100);
+--let $bgcd_saved=`SELECT @@GLOBAL.binlog_group_commit_sync_delay`
+##################### begin of case 1 ######################
+SET GLOBAL binlog_group_commit_sync_delay = 8;
+SET GLOBAL binlog_group_commit_sync_no_delay_count = 2;
+
+BEGIN;
+UPDATE t set v = v + 100 WHERE id = 1;
+COMMIT; # hangs here forever if no more commits come in
+
+###################### end of case 1 #######################
+
+##################### begin of case 2 ######################
+SET GLOBAL binlog_group_commit_sync_delay = 8;
+SET GLOBAL binlog_group_commit_sync_no_delay_count = 0;
+
+BEGIN;
+UPDATE t set v = v + 100 WHERE id = 3;
+COMMIT; # hangs here forever
+
+###################### end of case 2 #######################
+--eval SET GLOBAL binlog_group_commit_sync_delay=$bgcd_saved
+DROP TABLE t;

sql/binlog.cc

@@ -1919,19 +1919,19 @@ THD *Stage_manager::Mutex_queue::fetch_and_empty()
   DBUG_RETURN(result);
 }
 
-time_t Stage_manager::wait_count_or_timeout(ulong count, time_t usec, StageID stage)
+void Stage_manager::wait_count_or_timeout(ulong count, ulong usec, StageID stage)
 {
-  time_t to_wait=
+  ulong to_wait=
     DBUG_EVALUATE_IF("bgc_set_infinite_delay", LONG_MAX, usec);
   /*
     For testing purposes while waiting for inifinity
     to arrive, we keep checking the queue size at regular,
     small intervals. Otherwise, waiting 0.1 * infinite
     is too long.
    */
-  time_t delta=
+  ulong delta=
     DBUG_EVALUATE_IF("bgc_set_infinite_delay", 100000,
-                     static_cast<time_t>(to_wait * 0.1));
+                     max<ulong>(1, (to_wait * 0.1)));
 
   while (to_wait > 0 && (count == 0 || static_cast<ulong>(m_queue[stage].get_size()) < count))
   {
@@ -1942,7 +1942,6 @@ time_t Stage_manager::wait_count_or_timeout(ulong count, time_t usec, StageID st
     my_sleep(delta);
     to_wait -= delta;
   }
-  return to_wait;
 }
 
 void Stage_manager::signal_done(THD *queue)

sql/binlog.h

@@ -274,7 +274,7 @@ class Stage_manager {
                     session is waiting on
     @param stage    which stage queue size to compare count against.
    */
-  time_t wait_count_or_timeout(ulong count, time_t usec, StageID stage);
+  void wait_count_or_timeout(ulong count, ulong usec, StageID stage);
 
   void signal_done(THD *queue);