Merge remote-tracking branch 'origin/bb-10.10-MDEV-11026' into 10.11

Author: vaintroub

mysql-test/suite/sys_vars/r/innodb_file_io_threads_basic.result

@@ -8,16 +8,10 @@ COUNT(@@GLOBAL.innodb_write_io_threads)
 1
 1 Expected
 '#---------------------BS_STVARS_027_02----------------------#'
-SET @@GLOBAL.innodb_read_io_threads=1;
-ERROR HY000: Variable 'innodb_read_io_threads' is a read only variable
-Expected error 'Read only variable'
 SELECT COUNT(@@GLOBAL.innodb_read_io_threads);
 COUNT(@@GLOBAL.innodb_read_io_threads)
 1
 1 Expected
-SET @@GLOBAL.innodb_write_io_threads=1;
-ERROR HY000: Variable 'innodb_write_io_threads' is a read only variable
-Expected error 'Read only variable'
 SELECT COUNT(@@GLOBAL.innodb_write_io_threads);
 COUNT(@@GLOBAL.innodb_write_io_threads)
 1

mysql-test/suite/sys_vars/r/innodb_read_io_threads_basic.result

@@ -15,7 +15,15 @@ INNODB_READ_IO_THREADS	2
 select * from information_schema.session_variables where variable_name='innodb_read_io_threads';
 VARIABLE_NAME	VARIABLE_VALUE
 INNODB_READ_IO_THREADS	2
-set global innodb_read_io_threads=1;
-ERROR HY000: Variable 'innodb_read_io_threads' is a read only variable
+select @@innodb_read_io_threads into @n;
+set global innodb_read_io_threads = 1;
+select @@innodb_read_io_threads;
+@@innodb_read_io_threads
+1
+set global innodb_read_io_threads=64;
+select @@innodb_read_io_threads;
+@@innodb_read_io_threads
+64
 set session innodb_read_io_threads=1;
-ERROR HY000: Variable 'innodb_read_io_threads' is a read only variable
+ERROR HY000: Variable 'innodb_read_io_threads' is a GLOBAL variable and should be set with SET GLOBAL
+set global innodb_read_io_threads=@n;

mysql-test/suite/sys_vars/r/innodb_write_io_threads_basic.result

@@ -15,7 +15,13 @@ INNODB_WRITE_IO_THREADS	2
 select * from information_schema.session_variables where variable_name='innodb_write_io_threads';
 VARIABLE_NAME	VARIABLE_VALUE
 INNODB_WRITE_IO_THREADS	2
+select @@innodb_write_io_threads into @n;
 set global innodb_write_io_threads=1;
-ERROR HY000: Variable 'innodb_write_io_threads' is a read only variable
-set session innodb_write_io_threads=1;
-ERROR HY000: Variable 'innodb_write_io_threads' is a read only variable
+select @@innodb_write_io_threads;
+@@innodb_write_io_threads
+2
+set global innodb_write_io_threads=64;
+select @@innodb_write_io_threads;
+@@innodb_write_io_threads
+64
+set global innodb_write_io_threads=@n;

mysql-test/suite/sys_vars/r/sysvars_innodb.result

@@ -1349,7 +1349,7 @@ NUMERIC_MIN_VALUE	1
 NUMERIC_MAX_VALUE	64
 NUMERIC_BLOCK_SIZE	0
 ENUM_VALUE_LIST	NULL
-READ_ONLYYES
+READ_ONLYNO
 COMMAND_LINE_ARGUMENT	REQUIRED
 VARIABLE_NAME	INNODB_READ_ONLY
 SESSION_VALUE	NULL
@@ -1697,5 +1697,5 @@ NUMERIC_MIN_VALUE	2
 NUMERIC_MAX_VALUE	64
 NUMERIC_BLOCK_SIZE	0
 ENUM_VALUE_LIST	NULL
-READ_ONLYYES
+READ_ONLYNO
 COMMAND_LINE_ARGUMENT	REQUIRED

mysql-test/suite/sys_vars/t/innodb_file_io_threads_basic.test

@@ -39,17 +39,10 @@ SELECT COUNT(@@GLOBAL.innodb_write_io_threads);
 # Check if Value can set #
 ####################################################################
 
---error ER_INCORRECT_GLOBAL_LOCAL_VAR
-SET @@GLOBAL.innodb_read_io_threads=1;
---echo Expected error 'Read only variable'
 
 SELECT COUNT(@@GLOBAL.innodb_read_io_threads);
 --echo 1 Expected
 
---error ER_INCORRECT_GLOBAL_LOCAL_VAR
-SET @@GLOBAL.innodb_write_io_threads=1;
---echo Expected error 'Read only variable'
-
 SELECT COUNT(@@GLOBAL.innodb_write_io_threads);
 --echo 1 Expected
 

mysql-test/suite/sys_vars/t/innodb_read_io_threads_basic.test

@@ -19,10 +19,18 @@ select * from information_schema.session_variables where variable_name='innodb_r
 --enable_warnings
 
 #
-# show that it's read-only
+# show that it's not read-only
 #
---error ER_INCORRECT_GLOBAL_LOCAL_VAR
-set global innodb_read_io_threads=1;
---error ER_INCORRECT_GLOBAL_LOCAL_VAR
+select @@innodb_read_io_threads into @n;
+--disable_warnings
+set global innodb_read_io_threads = 1;
+--enable_warnings
+select @@innodb_read_io_threads;
+--disable_warnings
+set global innodb_read_io_threads=64;
+--enable_warnings
+select @@innodb_read_io_threads;
+--error ER_GLOBAL_VARIABLE
 set session innodb_read_io_threads=1;
+set global innodb_read_io_threads=@n;
 

mysql-test/suite/sys_vars/t/innodb_write_io_threads_basic.test

@@ -19,10 +19,18 @@ select * from information_schema.session_variables where variable_name='innodb_w
 --enable_warnings
 
 #
-# show that it's read-only
+# show that it's not read-only
 #
---error ER_INCORRECT_GLOBAL_LOCAL_VAR
+select @@innodb_write_io_threads into @n;
+--disable_warnings
 set global innodb_write_io_threads=1;
---error ER_INCORRECT_GLOBAL_LOCAL_VAR
-set session innodb_write_io_threads=1;
+--enable_warnings
+select @@innodb_write_io_threads;
+--disable_warnings
+set global innodb_write_io_threads=64;
+--enable_warnings
+select @@innodb_write_io_threads;
+--disable_warnings
+set global innodb_write_io_threads=@n;
+--enable_warnings
 

storage/innobase/handler/ha_innodb.cc

@@ -19271,15 +19271,44 @@ static MYSQL_SYSVAR_BOOL(optimize_fulltext_only, innodb_optimize_fulltext_only,
  "Only optimize the Fulltext index of the table",
  NULL, NULL, FALSE);
 
+extern int os_aio_resize(ulint n_reader_threads, ulint n_writer_threads);
+static void innodb_update_io_thread_count(THD *thd,ulint n_read, ulint n_write)
+{
+ int res = os_aio_resize(n_read, n_write);
+ if (res)
+ {
+#ifndef __linux__
+ ut_ad(0);
+#else
+ ut_a(srv_use_native_aio);
+ push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+ ER_UNKNOWN_ERROR,
+ "Could not reserve max. number of concurrent ios."
+ "Increase the /proc/sys/fs/aio-max-nr to fix.");
+#endif
+ }
+}
+
+static void innodb_read_io_threads_update(THD* thd, struct st_mysql_sys_var*, void*, const void* save)
+{
+ srv_n_read_io_threads = *static_cast<const uint*>(save);
+ innodb_update_io_thread_count(thd, srv_n_read_io_threads, srv_n_write_io_threads);
+}
+static void innodb_write_io_threads_update(THD* thd, struct st_mysql_sys_var*, void*, const void* save)
+{
+ srv_n_write_io_threads = *static_cast<const uint*>(save);
+ innodb_update_io_thread_count(thd, srv_n_read_io_threads, srv_n_write_io_threads);
+}
+
 static MYSQL_SYSVAR_UINT(read_io_threads, srv_n_read_io_threads,
- PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+ PLUGIN_VAR_RQCMDARG,
  "Number of background read I/O threads in InnoDB.",
- NULL, NULL, 4, 1, 64, 0);
+ NULL, innodb_read_io_threads_update , 4, 1, 64, 0);
 
 static MYSQL_SYSVAR_UINT(write_io_threads, srv_n_write_io_threads,
- PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+ PLUGIN_VAR_RQCMDARG,
  "Number of background write I/O threads in InnoDB.",
- NULL, NULL, 4, 2, 64, 0);
+ NULL, innodb_write_io_threads_update, 4, 2, 64, 0);
 
 static MYSQL_SYSVAR_ULONG(force_recovery, srv_force_recovery,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,

storage/innobase/os/os0file.cc

@@ -83,8 +83,7 @@ class io_slots
 int m_max_aio;
 public:
 io_slots(int max_submitted_io, int max_callback_concurrency) :
-m_cache(max_submitted_io),
-m_group(max_callback_concurrency),
+m_cache(max_submitted_io), m_group(max_callback_concurrency, false),
 m_max_aio(max_submitted_io)
 {
 }
@@ -105,6 +104,11 @@ class io_slots
 }
 
 /* Wait for completions of all AIO operations */
+void wait(std::unique_lock<std::mutex> &lk)
+{
+m_cache.wait(lk);
+}
+
 void wait()
 {
 m_cache.wait();
@@ -124,6 +128,24 @@ class io_slots
 {
 wait();
 }
+
+std::mutex& mutex()
+{
+return m_cache.mutex();
+}
+
+void resize(int max_submitted_io, int max_callback_concurrency, std::unique_lock<std::mutex> &lk)
+{
+ut_a(lk.owns_lock());
+m_cache.resize(max_submitted_io);
+m_group.set_max_tasks(max_callback_concurrency);
+m_max_aio = max_submitted_io;
+}
+
+tpool::task_group& task_group()
+{
+return m_group;
+}
 };
 
 static io_slots *read_slots;
@@ -3691,6 +3713,58 @@ int os_aio_init()
 }
 
 
+/**
+Change reader or writer thread parameter on a running server.
+This includes resizing the io slots, as we calculate
+number of outstanding IOs based on the these variables.
+
+It is trickier with when Linux AIO is involved (io_context
+needs to be recreated to account for different number of
+max_events). With Linux AIO, depending on fs-max-aio number
+and user and system wide max-aio limitation, this can fail.
+
+Otherwise, we just resize the slots, and allow for
+more concurrent threads via thread_group setting.
+
+@param[in] n_reader_threads - max number of concurrently
+ executing read callbacks
+@param[in] n_writer_thread - max number of cuncurrently
+ executing write callbacks
+@return 0 for success, !=0 for error.
+*/
+int os_aio_resize(ulint n_reader_threads, ulint n_writer_threads)
+{
+ /* Lock the slots, and wait until all current IOs finish.*/
+ std::unique_lock<std::mutex> lk_read(read_slots->mutex());
+ std::unique_lock<std::mutex> lk_write(write_slots->mutex());
+
+ read_slots->wait(lk_read);
+ write_slots->wait(lk_write);
+
+ /* Now, all IOs have finished and no new ones can start, due to locks. */
+ int max_read_events= int(n_reader_threads * OS_AIO_N_PENDING_IOS_PER_THREAD);
+ int max_write_events= int(n_writer_threads * OS_AIO_N_PENDING_IOS_PER_THREAD);
+ int events= max_read_events + max_write_events;
+
+ /** Do the Linux AIO dance (this will try to create a new
+ io context with changed max_events ,etc*/
+
+ if (int ret= srv_thread_pool->reconfigure_aio(srv_use_native_aio, events))
+ {
+ /** Do the best effort. We can't change the parallel io number,
+ but we still can adjust the number of concurrent completion handlers.*/
+ read_slots->task_group().set_max_tasks(static_cast<int>(n_reader_threads));
+ write_slots->task_group().set_max_tasks(static_cast<int>(n_writer_threads));
+ return ret;
+ }
+
+ /* Allocation succeeded, resize the slots*/
+ read_slots->resize(max_read_events, static_cast<int>(n_reader_threads), lk_read);
+ write_slots->resize(max_write_events, static_cast<int>(n_writer_threads), lk_write);
+
+ return 0;
+}
+
 void os_aio_free()
 {
  srv_thread_pool->disable_aio();

tpool/task_group.cc

@@ -25,11 +25,26 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111 - 1301 USA*/
 #endif
 namespace tpool
 {
- task_group::task_group(unsigned int max_concurrency) :
+
+ /**
+ Task_group constructor
+
+ @param max_threads - maximum number of threads allowed to execute
+ tasks from the group at the same time.
+
+ @param enable_task_release - if true (default), task::release() will be
+ called after task execution.'false' should only be used in rare cases
+ when accessing memory, pointed by task structures, would be unsafe after.
+ the callback. Also 'false' is only possible ,if task::release() is a trivial function
+ */
+ task_group::task_group(unsigned int max_concurrency,
+ bool enable_task_release)
+ :
  m_queue(8),
  m_mtx(),
  m_tasks_running(),
- m_max_concurrent_tasks(max_concurrency)
+ m_max_concurrent_tasks(max_concurrency),
+ m_enable_task_release(enable_task_release)
  {};
 
  void task_group::set_max_tasks(unsigned int max_concurrency)
@@ -53,7 +68,8 @@ namespace tpool
  if (t)
  {
  t->m_func(t->m_arg);
- t->release();
+ if (m_enable_task_release)
+ t->release();
  }
  lk.lock();