Bug#28091735:COMMIT HANGS IF BINLOG_GROUP_COMMIT_SYNC_DELAY NOT MULTIPLE OF 1/10TH OF ITSELF

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/10th 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 is modified
"to_wait = to_wait - delta".

This process is repeated until to_wait > 0 and count has not been reached.
delta is calculated like this
ulong delta=
    DBUG_EVALUATE_IF("bgc_set_infinite_delay", 100000,
                     max<ulong>(1, (to_wait * 0.1)));

When to_wait which is the value of sync_delay is a non multiple of the
delta(3) like lets say 32, as this is not a multiple of to_wait time
there will be a point in the waiting code where to_wait = 2, and then
to_wait(2) = to_wait(2) - delta(3) = -1 now as to_wait is of type ulong
so the value will be wrapped and to_wait = 18446744073709551615 [ULONG_MAX].

This will make the waiting loop continue forever.

Author: Neha Kumari

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

@@ -0,0 +1,9 @@
+CREATE TABLE t(s INT);
+SET GLOBAL binlog_group_commit_sync_delay = 32;
+SET GLOBAL binlog_group_commit_sync_no_delay_count = 0;
+BEGIN;
+INSERT INTO t VALUES(10);
+COMMIT;
+SET GLOBAL binlog_group_commit_sync_delay = 0;
+SET GLOBAL binlog_group_commit_sync_no_delay_count = 0;
+DROP TABLE t;

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

@@ -0,0 +1,40 @@
+# ==== Purpose ====
+#
+# This test will set a value for binlog_group_commit_sync_delay
+# which will be a non multiple of delta(the waiting time is
+# broken into smaller chunks called as delta), and execute some
+# transactions after that.
+#
+# The test verifies that server does not hang when a non multiple of 10
+# is assigned to binlog_group_commit_sync_delay variable.
+#
+# Related bugs and Worklogs
+#
+# Bug#28091735:COMMIT WILL HANG IF BINLOG_GROUP_COMMIT_SYNC_DELAY
+#              IS NOT A MULTIPLE OF 10
+
+# this is binlog format agnostic
+--source include/have_binlog_format_row.inc
+
+--let $bgcd_saved = `SELECT @@GLOBAL.binlog_group_commit_sync_delay`
+--let $bgcc_saved = `SELECT @@GLOBAL.binlog_group_commit_sync_no_delay_count`
+
+CREATE TABLE t(s INT);
+
+# Set the delay to a non multiple of delta, in this case
+# delta will be 3, MAX(1, wait_time * .1) and so it will not be
+# a multiple of the waiting time which is 32
+
+SET GLOBAL binlog_group_commit_sync_delay = 32;
+SET GLOBAL binlog_group_commit_sync_no_delay_count = 0;
+
+BEGIN;
+INSERT INTO t VALUES(10);
+COMMIT; # Hangs here without the fix
+
+#cleanup
+
+--eval SET GLOBAL binlog_group_commit_sync_delay = $bgcd_saved
+--eval SET GLOBAL binlog_group_commit_sync_no_delay_count = $bgcc_saved
+DROP TABLE t;
+

sql/binlog.cc

@@ -2252,19 +2252,19 @@ THD *Stage_manager::Mutex_queue::fetch_and_empty()
   DBUG_RETURN(result);
 }
 
-void Stage_manager::wait_count_or_timeout(ulong count, ulong usec, StageID stage)
+void Stage_manager::wait_count_or_timeout(ulong count, long usec, StageID stage)
 {
-  ulong to_wait=
+  long 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.
    */
-  ulong delta=
+  long delta=
     DBUG_EVALUATE_IF("bgc_set_infinite_delay", 100000,
-                     max<ulong>(1, (to_wait * 0.1)));
+                     max<long>(1, (to_wait * 0.1)));
 
   while (to_wait > 0 && (count == 0 || static_cast<ulong>(m_queue[stage].get_size()) < count))
   {

sql/binlog.h

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

sql/mysqld.cc

@@ -473,7 +473,7 @@ ulonglong  max_binlog_cache_size=0;
 ulong slave_max_allowed_packet= 0;
 ulong binlog_stmt_cache_size=0;
 int32 opt_binlog_max_flush_queue_time= 0;
-ulong opt_binlog_group_commit_sync_delay= 0;
+long opt_binlog_group_commit_sync_delay= 0;
 ulong opt_binlog_group_commit_sync_no_delay_count= 0;
 ulonglong  max_binlog_stmt_cache_size=0;
 ulong query_cache_size=0;

sql/mysqld.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2010, 2017, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2010, 2018, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -246,7 +246,7 @@ extern ulong open_files_limit;
 extern ulong binlog_cache_size, binlog_stmt_cache_size;
 extern ulonglong max_binlog_cache_size, max_binlog_stmt_cache_size;
 extern int32 opt_binlog_max_flush_queue_time;
-extern ulong opt_binlog_group_commit_sync_delay;
+extern long opt_binlog_group_commit_sync_delay;
 extern ulong opt_binlog_group_commit_sync_no_delay_count;
 extern ulong max_binlog_size, max_relay_log_size;
 extern ulong slave_max_allowed_packet;

sql/sys_vars.cc

@@ -748,7 +748,7 @@ static Sys_var_int32 Sys_binlog_max_flush_queue_time(
        NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(0), ON_UPDATE(0),
        DEPRECATED(""));
 
-static Sys_var_ulong Sys_binlog_group_commit_sync_delay(
+static Sys_var_long Sys_binlog_group_commit_sync_delay(
        "binlog_group_commit_sync_delay",
        "The number of microseconds the server waits for the "
        "binary log group commit sync queue to fill before "