Merge lp:~laurynas-biveinis/percona-server/lru-manager into lp:percona-server/5.6

[Laurynas Biveinis]

http://jenkins.percona.com/job/percona-server-5.6-param/392/

    Split an LRU manager thread out of the page cleaner thread,
    implementing
    https://blueprints.launchpad.net/percona-server/+spec/lru-manager-thread.

    Declare new thread entry point buf_lru_manager_thread(). Move LRU
    flushing-related code from buf_flush_page_cleaner_thread(). Spawn
    this thread from innobase_start_or_create_for_mysql().

    Revert the change that was needed by
    https://blueprints.launchpad.net/percona-server/+spec/xtradb-empty-free-list-backoff
    in buf_flush_ready_for_flush() and allow flush list flushing of
    latched pages again.

    Introduce a new flag buf_lru_manager_is_active that is used instead of
    buf_page_cleaner_is_active by buf_LRU_get_free_block().

    Adjust innodb_sched_priority_cleaner_update() to set the priority for
    both cleaner and LRU manager threads.

    Define a PFS key for the new thread. Re-record
    perfschema.threads_innodb testcase.

[Vlad Lesin (vlad-lesin)]

1) Lines 33,34: Why do we need this?

2) buf_flush_wait_LRU_batch_end() call in buf_flush_page_cleaner_thread():
Actually buf_flush_LRU_tail() waits for batch LRU end. Do we really need to invoke buf_flush_wait_LRU_batch_end() from buf_flush_page_cleaner_thread()?

3) buf_flush_LRU_tail():
Interestingly how often
do {
...
} while (active_instance[i]
         && free_len <= free_list_lwm);
loop is repeated for each buffer pool instance? If not so often then replacing the order of buf_flush_LRU() and buf_flush_wait_batch_end() call would allow us to avoid waiting for LRU batch flushing for the current buffer pool instance. I mean we could invoke buf_flush_wait_batch_end() before buf_flush_LRU() to follow the restriction "one LRU batch per one buffer pool instance" from one hand and to have possibility to launch batch LRU flushing for other buffer pool instances not waiting the end of the current buffer pool instance batch flushing from another hand.

[Laurynas Biveinis (laurynas-biveinis)]

Vlad -

> 1) Lines 33,34: Why do we need this?

They implement this bit from the commit message:

    Revert the change that was needed by
    https://blueprints.launchpad.net/percona-server/+spec/xtradb-empty-free-list-backoff
    in buf_flush_ready_for_flush() and allow flush list flushing of
    latched pages again.

> 2) buf_flush_wait_LRU_batch_end() call in buf_flush_page_cleaner_thread():
> Actually buf_flush_LRU_tail() waits for batch LRU end. Do we really need to
> invoke buf_flush_wait_LRU_batch_end() from
> buf_flush_page_cleaner_thread()?

An LRU flush not by buf_flush_LRU_tail() but by a query thread is
possible if running with --innodb_empty_free_list_algorithm=legacy.

> 3) buf_flush_LRU_tail():
> Interestingly how often
> do {
> ...
> } while (active_instance[i]
> && free_len <= free_list_lwm);
> loop is repeated for each buffer pool instance?

Alexey Stroganov should have a detailed answer for this :)

> If not so often then replacing
> the order of buf_flush_LRU() and buf_flush_wait_batch_end() call would allow
> us to avoid waiting for LRU batch flushing for the current buffer pool
> instance. I mean we could invoke buf_flush_wait_batch_end() before
> buf_flush_LRU() to follow the restriction "one LRU batch per one buffer pool
> instance" from one hand and to have possibility to launch batch LRU flushing
> for other buffer pool instances not waiting the end of the current buffer pool
> instance batch flushing from another hand.

I am not sure I understand: if we swap buf_flush_LRU() with
buf_flush_wait_batch_end(), how does that give the possibility to
start batches for other instances? buf_flush_wait_batch_end() will
block on the current instance.

[Vlad Lesin (vlad-lesin)]

Thank you for the previous answers, they helped me to dispell doubts about some parts of the code.

> > If not so often then replacing
> > the order of buf_flush_LRU() and buf_flush_wait_batch_end() call would allow
> > us to avoid waiting for LRU batch flushing for the current buffer pool
> > instance. I mean we could invoke buf_flush_wait_batch_end() before
> > buf_flush_LRU() to follow the restriction "one LRU batch per one buffer pool
> > instance" from one hand and to have possibility to launch batch LRU flushing
> > for other buffer pool instances not waiting the end of the current buffer
> pool
> > instance batch flushing from another hand.
>
> I am not sure I understand: if we swap buf_flush_LRU() with
> buf_flush_wait_batch_end(), how does that give the possibility to
> start batches for other instances? buf_flush_wait_batch_end() will
> block on the current instance.

Yes, but we could check for example buf_pool->n_flush before invoking buf_flush_wait_batch_end() to avoid blocking if there are not pending flushes for the current buffer pool instance.

The current algorithm is the following:
for (ulint i = 0; i < srv_buf_pool_instances; i++) {
  ...
  do {
    ...
    buf_flush_LRU(i-th buffer-pool instance);
    buf_flush_wait_batch_end(i-th buffer-pool instance);
    ...
  } while (...)
}

So buf_flush_wait_batch_end() will block execution until flush io for the current buffer pool instance is finished. And in the case when the count of "do {} while()" loops is generally small this buf_flush_wait_batch_end() call prevent processing the next buffer pool instance until the current buffer pool instance flush io's is finished. The idea is to swap these two calls like the following:

for (ulint i = 0; i < srv_buf_pool_instances; i++) {
  ...
  do {
    ...
    if (buf_pool->n_flush[...])
        buf_flush_wait_batch_end(i-th buffer-pool instance);
    buf_flush_LRU(i-th buffer-pool instance);
    ...
  } while (...)
}

In this case we don't wait for flush ending for the current buffer pool instance and begin processing the next buffer pool instance while the current buffer pool instance flushing is still in progress.

So I am not completely sure about this idea as I did not dig the code deep enough in this direction. Just want to share and discuss it.

review: Approve (g2)

[Laurynas Biveinis (laurynas-biveinis)]

Vlad -

> for (ulint i = 0; i < srv_buf_pool_instances; i++) {
> ...
> do {
> ...
> if (buf_pool->n_flush[...])
> buf_flush_wait_batch_end(i-th buffer-pool instance);
> buf_flush_LRU(i-th buffer-pool instance);
> ...
> } while (...)
> }

I think I understand now. Yes, it seems it would block less. I think we had tried something similar that was supposed to block less during prototyping and IIRC it just didn't help, although I cannot remember why.

We can submit a follow-up MP once/if this is analyzed and improvements are designed and implemented.

[Stewart Smith (stewart)]

review: Approve

=== modified file 'Percona-Server/mysql-test/suite/perfschema/r/threads_innodb.result'
--- Percona-Server/mysql-test/suite/perfschema/r/threads_innodb.result	2012-02-15 02:19:04 +0000
+++ Percona-Server/mysql-test/suite/perfschema/r/threads_innodb.result	2013-10-23 12:17:08 +0000
@@ -6,6 +6,7 @@
 GROUP BY name;
 name	type	processlist_user	processlist_host	processlist_db	processlist_command	processlist_time	processlist_state	processlist_info	parent_thread_id	role	instrumented
 thread/innodb/io_handler_thread	BACKGROUND	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	YES
+thread/innodb/lru_manager_thread	BACKGROUND	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	YES
 thread/innodb/page_cleaner_thread	BACKGROUND	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	YES
 thread/innodb/srv_error_monitor_thread	BACKGROUND	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	YES
 thread/innodb/srv_lock_timeout_thread	BACKGROUND	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	YES

=== modified file 'Percona-Server/storage/innobase/buf/buf0flu.cc'
--- Percona-Server/storage/innobase/buf/buf0flu.cc	2013-10-23 08:48:28 +0000
+++ Percona-Server/storage/innobase/buf/buf0flu.cc	2013-10-23 12:17:08 +0000
@@ -59,8 +59,12 @@
 doing the shutdown */
 UNIV_INTERN ibool buf_page_cleaner_is_active = FALSE;
 
+/** Flag indicating if the lru_manager is in active state. */
+UNIV_INTERN bool buf_lru_manager_is_active = false;
+
 #ifdef UNIV_PFS_THREAD
 UNIV_INTERN mysql_pfs_key_t buf_page_cleaner_thread_key;
+UNIV_INTERN mysql_pfs_key_t buf_lru_manager_thread_key;
 #endif /* UNIV_PFS_THREAD */
 
 /** If LRU list of a buf_pool is less than this size then LRU eviction
@@ -550,6 +554,8 @@
 
 	switch (flush_type) {
 	case BUF_FLUSH_LIST:
+		return(true);
+
 	case BUF_FLUSH_LRU:
 	case BUF_FLUSH_SINGLE_PAGE:
 		/* Because any thread may call single page flush, even
@@ -2626,7 +2632,7 @@
 
 /******************************************************************//**
 page_cleaner thread tasked with flushing dirty pages from the buffer
-pools. As of now we'll have only one instance of this thread.
+pool flush lists. As of now we'll have only one instance of this thread.
 @return a dummy parameter */
 extern "C" UNIV_INTERN
 os_thread_ret_t
@@ -2639,7 +2645,6 @@
 	ulint	next_loop_time = ut_time_ms() + 1000;
 	ulint	n_flushed = 0;
 	ulint	last_activity = srv_get_activity_count();
-	ulint	lru_sleep_time = srv_cleaner_max_lru_time;
 
 	ut_ad(!srv_read_only_mode);
 
@@ -2660,7 +2665,6 @@
 
 	while (srv_shutdown_state == SRV_SHUTDOWN_NONE) {
 
-		ulint	flush_sleep_time;
 		ulint	page_cleaner_sleep_time;
 
 		srv_current_thread_priority = srv_cleaner_thread_priority;
@@ -2674,18 +2678,11 @@
 			page_cleaner_sleep_if_needed(next_loop_time);
 		}
 
-		page_cleaner_adapt_lru_sleep_time(&lru_sleep_time);
-
-		flush_sleep_time = page_cleaner_adapt_flush_sleep_time();
-
-		page_cleaner_sleep_time = ut_min(lru_sleep_time,
-						 flush_sleep_time);
+		page_cleaner_sleep_time
+			= page_cleaner_adapt_flush_sleep_time();
 
 		next_loop_time = ut_time_ms() + page_cleaner_sleep_time;
 
-		/* Flush pages from end of LRU if required */
-		n_flushed = buf_flush_LRU_tail();
-
 		if (srv_check_activity(last_activity)) {
 			last_activity = srv_get_activity_count();
 
@@ -2778,6 +2775,74 @@
 	OS_THREAD_DUMMY_RETURN;
 }
 
+/******************************************************************//**
+lru_manager thread tasked with performing LRU flushes and evictions to refill
+the buffer pool free lists.  As of now we'll have only one instance of this
+thread.
+@return a dummy parameter */
+extern "C" UNIV_INTERN
+os_thread_ret_t
+DECLARE_THREAD(buf_flush_lru_manager_thread)(
+/*==========================================*/
+	void*	arg __attribute__((unused)))
+			/*!< in: a dummy parameter required by
+			os_thread_create */
+{
+	ulint	next_loop_time = ut_time_ms() + 1000;
+	ulint	lru_sleep_time = srv_cleaner_max_lru_time;
+
+#ifdef UNIV_PFS_THREAD
+	pfs_register_thread(buf_lru_manager_thread_key);
+#endif /* UNIV_PFS_THREAD */
+
+	srv_lru_manager_tid = os_thread_get_tid();
+
+	os_thread_set_priority(srv_lru_manager_tid,
+			       srv_sched_priority_cleaner);
+
+#ifdef UNIV_DEBUG_THREAD_CREATION
+	fprintf(stderr, "InnoDB: lru_manager thread running, id %lu\n",
+		os_thread_pf(os_thread_get_curr_id()));
+#endif /* UNIV_DEBUG_THREAD_CREATION */
+
+	buf_lru_manager_is_active = true;
+
+	/* On server shutdown, the LRU manager thread runs through cleanup
+	phase to provide free pages for the master and purge threads.  */
+	while (srv_shutdown_state == SRV_SHUTDOWN_NONE
+	       || srv_shutdown_state == SRV_SHUTDOWN_CLEANUP) {
+
+		ulint n_flushed_lru;
+
+		srv_current_thread_priority = srv_cleaner_thread_priority;
+
+		page_cleaner_sleep_if_needed(next_loop_time);
+
+		page_cleaner_adapt_lru_sleep_time(&lru_sleep_time);
+
+		next_loop_time = ut_time_ms() + lru_sleep_time;
+
+		n_flushed_lru = buf_flush_LRU_tail();
+
+		if (n_flushed_lru) {
+
+			MONITOR_INC_VALUE_CUMULATIVE(
+				MONITOR_FLUSH_BACKGROUND_TOTAL_PAGE,
+				MONITOR_FLUSH_BACKGROUND_COUNT,
+				MONITOR_FLUSH_BACKGROUND_PAGES,
+				n_flushed_lru);
+		}
+	}
+
+	buf_lru_manager_is_active = false;
+
+	/* We count the number of threads in os_thread_exit(). A created
+	thread should always use that to exit and not use return() to exit. */
+	os_thread_exit(NULL);
+
+	OS_THREAD_DUMMY_RETURN;
+}
+
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 
 /** Functor to validate the flush list. */

=== modified file 'Percona-Server/storage/innobase/buf/buf0lru.cc'
--- Percona-Server/storage/innobase/buf/buf0lru.cc	2013-10-23 08:48:28 +0000
+++ Percona-Server/storage/innobase/buf/buf0lru.cc	2013-10-23 12:17:08 +0000
@@ -1365,8 +1365,9 @@
 	}
 
 	if (srv_empty_free_list_algorithm == SRV_EMPTY_FREE_LIST_BACKOFF
-	    && buf_page_cleaner_is_active
-	    && srv_shutdown_state == SRV_SHUTDOWN_NONE) {
+	    && buf_lru_manager_is_active
+	    && (srv_shutdown_state == SRV_SHUTDOWN_NONE
+		|| srv_shutdown_state == SRV_SHUTDOWN_CLEANUP)) {
 
 		/* Backoff to minimize the free list mutex contention while the
 		free list is empty */
@@ -1408,12 +1409,13 @@
 		goto loop;
 	} else {
 
-		/* The cleaner is not running or Oracle MySQL 5.6 algorithm was
-		requested, will perform a single page flush  */
+		/* The LRU manager is not running or Oracle MySQL 5.6 algorithm
+		was requested, will perform a single page flush  */
 		ut_ad((srv_empty_free_list_algorithm
 		       == SRV_EMPTY_FREE_LIST_LEGACY)
-		      || !buf_page_cleaner_is_active
-		      || (srv_shutdown_state != SRV_SHUTDOWN_NONE));
+		      || !buf_lru_manager_is_active
+		      || (srv_shutdown_state != SRV_SHUTDOWN_NONE
+			  && srv_shutdown_state != SRV_SHUTDOWN_CLEANUP));
 	}
 
 	mutex_enter(&buf_pool->flush_state_mutex);

=== modified file 'Percona-Server/storage/innobase/handler/ha_innodb.cc'
--- Percona-Server/storage/innobase/handler/ha_innodb.cc	2013-10-23 08:48:28 +0000
+++ Percona-Server/storage/innobase/handler/ha_innodb.cc	2013-10-23 12:17:08 +0000
@@ -457,6 +457,7 @@
 	{&srv_master_thread_key, "srv_master_thread", 0},
 	{&srv_purge_thread_key, "srv_purge_thread", 0},
 	{&buf_page_cleaner_thread_key, "page_cleaner_thread", 0},
+	{&buf_lru_manager_thread_key, "lru_manager_thread", 0},
 	{&recv_writer_thread_key, "recv_writer_thread", 0},
 	{&srv_log_tracking_thread_key, "srv_redo_log_follow_thread", 0}
 };
@@ -15847,7 +15848,7 @@
 
 /****************************************************************//**
 Update the innodb_sched_priority_cleaner variable and set the thread
-priority accordingly.  */
+priorities accordingly.  */
 static
 void
 innodb_sched_priority_cleaner_update(
@@ -15863,6 +15864,24 @@
 	ulint	priority = *static_cast<const ulint *>(save);
 	ulint	actual_priority;
 
+	/* Set the priority for the LRU manager thread */
+	ut_ad(buf_lru_manager_is_active);
+	actual_priority = os_thread_set_priority(srv_lru_manager_tid,
+						 priority);
+	if (UNIV_UNLIKELY(actual_priority != priority)) {
+
+		push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+				    ER_WRONG_ARGUMENTS,
+				    "Failed to set the LRU manager thread "
+				    "priority to %lu,  "
+				    "the current priority is %lu", priority,
+				    actual_priority);
+	} else {
+
+		srv_sched_priority_cleaner = priority;
+	}
+
+	/* Set the priority for the page cleaner thread */
 	if (srv_read_only_mode) {
 
 		return;
@@ -15878,9 +15897,6 @@
 				    "priority to %lu,  "
 				    "the current priority is %lu", priority,
 				    actual_priority);
-	} else {
-
-		srv_sched_priority_cleaner = priority;
 	}
 }
 
@@ -16874,7 +16890,7 @@
 
 static MYSQL_SYSVAR_ULONG(sched_priority_cleaner, srv_sched_priority_cleaner,
   PLUGIN_VAR_RQCMDARG,
-  "Nice value for the cleaner thread scheduling",
+  "Nice value for the cleaner and LRU manager thread scheduling",
   NULL, innodb_sched_priority_cleaner_update, 19, 0, 39, 0);
 
 #endif /* UNIV_LINUX */
@@ -16919,7 +16935,8 @@
 
 static MYSQL_SYSVAR_BOOL(priority_cleaner, srv_cleaner_thread_priority,
   PLUGIN_VAR_OPCMDARG,
-  "Make buffer pool cleaner thread acquire shared resources with priority",
+  "Make buffer pool cleaner and LRU manager threads acquire shared resources "
+  "with priority",
   NULL, NULL, FALSE);
 
 static MYSQL_SYSVAR_BOOL(priority_master, srv_master_thread_priority,

=== modified file 'Percona-Server/storage/innobase/include/buf0flu.h'
--- Percona-Server/storage/innobase/include/buf0flu.h	2013-10-23 08:48:28 +0000
+++ Percona-Server/storage/innobase/include/buf0flu.h	2013-10-23 12:17:08 +0000
@@ -36,6 +36,9 @@
 /** Flag indicating if the page_cleaner is in active state. */
 extern ibool buf_page_cleaner_is_active;
 
+/** Flag indicating if the lru_manager is in active state. */
+extern bool buf_lru_manager_is_active;
+
 /********************************************************************//**
 Remove a block from the flush list of modified blocks.  */
 UNIV_INTERN
@@ -175,7 +178,7 @@
 				buf_page_in_file(bpage) and in the LRU list */
 /******************************************************************//**
 page_cleaner thread tasked with flushing dirty pages from the buffer
-pools. As of now we'll have only one instance of this thread.
+pool flush lists. As of now we'll have only one instance of this thread.
 @return a dummy parameter */
 extern "C" UNIV_INTERN
 os_thread_ret_t
@@ -183,6 +186,17 @@
 /*==========================================*/
 	void*	arg);		/*!< in: a dummy parameter required by
 				os_thread_create */
+/******************************************************************//**
+lru_manager thread tasked with performing LRU flushes and evictions to refill
+the buffer pool free lists.  As of now we'll have only one instance of this
+thread.
+@return a dummy parameter */
+extern "C" UNIV_INTERN
+os_thread_ret_t
+DECLARE_THREAD(buf_flush_lru_manager_thread)(
+/*=========================================*/
+	void*	arg);		/*!< in: a dummy parameter required by
+				os_thread_create */
 /*********************************************************************//**
 Clears up tail of the LRU lists:
 * Put replaceable pages at the tail of LRU to the free list

=== modified file 'Percona-Server/storage/innobase/include/srv0srv.h'
--- Percona-Server/storage/innobase/include/srv0srv.h	2013-10-23 08:48:28 +0000
+++ Percona-Server/storage/innobase/include/srv0srv.h	2013-10-23 12:17:08 +0000
@@ -525,6 +525,9 @@
 /* The tid of the cleaner thread */
 extern os_tid_t	srv_cleaner_tid;
 
+/* The tid of the LRU manager thread */
+extern os_tid_t srv_lru_manager_tid;
+
 /* The tids of the purge threads */
 extern os_tid_t srv_purge_tids[];
 
@@ -534,7 +537,7 @@
 /* The tid of the master thread */
 extern os_tid_t	srv_master_tid;
 
-/* The relative scheduling priority of the cleaner thread */
+/* The relative scheduling priority of the cleaner and LRU manager threads */
 extern ulint	srv_sched_priority_cleaner;
 
 /* The relative scheduling priority of the purge threads */
@@ -586,6 +589,7 @@
 # ifdef UNIV_PFS_THREAD
 /* Keys to register InnoDB threads with performance schema */
 extern mysql_pfs_key_t	buf_page_cleaner_thread_key;
+extern mysql_pfs_key_t	buf_lru_manager_thread_key;
 extern mysql_pfs_key_t	trx_rollback_clean_thread_key;
 extern mysql_pfs_key_t	io_handler_thread_key;
 extern mysql_pfs_key_t	srv_lock_timeout_thread_key;

=== modified file 'Percona-Server/storage/innobase/srv/srv0srv.cc'
--- Percona-Server/storage/innobase/srv/srv0srv.cc	2013-10-23 08:48:28 +0000
+++ Percona-Server/storage/innobase/srv/srv0srv.cc	2013-10-23 12:17:08 +0000
@@ -359,6 +359,9 @@
 /* The tid of the cleaner thread */
 UNIV_INTERN os_tid_t	srv_cleaner_tid;
 
+/* The tid of the LRU manager thread */
+UNIV_INTERN os_tid_t	srv_lru_manager_tid;
+
 /* The tids of the purge threads */
 UNIV_INTERN os_tid_t	srv_purge_tids[SRV_MAX_N_PURGE_THREADS];
 
@@ -368,7 +371,7 @@
 /* The tid of the master thread */
 UNIV_INTERN os_tid_t	srv_master_tid;
 
-/* The relative scheduling priority of the cleaner thread */
+/* The relative scheduling priority of the cleaner and LRU manager threads */
 UNIV_INTERN ulint	srv_sched_priority_cleaner	= 19;
 
 /* The relative scheduling priority of the purge threads */

=== modified file 'Percona-Server/storage/innobase/srv/srv0start.cc'
--- Percona-Server/storage/innobase/srv/srv0start.cc	2013-10-23 08:48:28 +0000
+++ Percona-Server/storage/innobase/srv/srv0start.cc	2013-10-23 12:17:08 +0000
@@ -2683,6 +2683,7 @@
 	if (!srv_read_only_mode) {
 		os_thread_create(buf_flush_page_cleaner_thread, NULL, NULL);
 	}
+	os_thread_create(buf_flush_lru_manager_thread, NULL, NULL);
 
 #ifdef UNIV_DEBUG
 	/* buf_debug_prints = TRUE; */