Merge lp:~laurynas-biveinis/percona-server/ahi-partitions-5.6-5.6 into lp:percona-server/5.6

[Laurynas Biveinis]

Port AHI partitions from 5.5 to 5.6, implementing https://blueprints.launchpad.net/percona-server/+spec/ahi-part-5-6.

Default Jenkins run at
http://jenkins.percona.com/job/percona-server-5.6-param/233/
and additional MTR --mysqld=--mysqld=--innodb-adaptive-hash-index-partitions=8 run at
http://jenkins.percona.com/job/percona-server-5.6-param/234/.

Port adaptive hash index partitions from 5.5.

There are no major algorithmic differences from the 5.5 version. The
are minor differences from the 5.5 version:
- simplify latching changes in row_search_for_mysql() by spliting out
  a helper function trx_search_latch_lock(), by using
  trx_search_latch_release_if_reserved() where appropriate, by not
  bothering to compute an X waiters bit mask in phase 0 but checking
  whether any X waiter is present instead;
- add additional latching order enforcement code to
  sync_thread_add_level();
- some comments in surrounding code were updated to reflect the
  partitioning;
- added missing header and arg comments. Add function attributes to
  btr_search_get_hash_index(), btr_search_get_latch(). New helper
  function btr_search_own_all().
- merged btr_search_drop_page_hash_index() with 5.6 version and
  adjusted UNIV_LIKELY/UNIV_UNLIKELY annotations to better reflect my
  expected reality;
- instead of adding an outer loop to it as in 5.5, rename
  btr_search_validate() to btr_search_validate_one_table() and add a
  new function btr_search_validate() that calls the former in a loop;
- instead of disabling UNIV_SYNC_DEBUG checks in ha_clear(),
  ha_delete_hash_node(), and ha_search_and_update_if_found_func(),
  implement a helper function ha_assert_btr_x_locked() which is then
  called from them;
- fix AHI-related code formatting in
  xtradb_internal_hash_tables_fill_table().
- expanded the sys_vars suite test
  innodb_adaptive_hash_index_partitions_basic.test;

At the same time fix bug 1216815 /
http://bugs.mysql.com/bug.php?id=69617 (5.6.12 removed UNIV_SYNC_DEBUG
from UNIV_DEBUG) by re-enabling it in univ.i.

Merge bug 1214449 (Adaptive hash index partitions not tested in MTR)
fix by merging the testcase.

[Alexey Kopytov (akopytov)]

Same comments about excessive INSERT/SELECT statements as in https://code.launchpad.net/~laurynas-biveinis/percona-server/ahi-partitions-5.6-5.5/+merge/181713.

I haven't reviewed the actual code port yet.

review: Needs Fixing

[Alexey Kopytov (akopytov)]

More comments on test cases:

> === added file 'Percona-Server/mysql-test/suite/sys_vars/t/innodb_adaptive_hash_index_partitions_basic.test'
> --- Percona-Server/mysql-test/suite/sys_vars/t/innodb_adaptive_hash_index_partitions_basic.test 1970-01-01 00:00:00 +0000
> +++ Percona-Server/mysql-test/suite/sys_vars/t/innodb_adaptive_hash_index_partitions_basic.test 2013-08-26 13:16:30 +0000
> @@ -0,0 +1,32 @@
> +# A sys_vars suite test from innodb_adaptive_hash_index_partitions. Adapted from
> +# innodb_buffer_pool_instances_basic.test.
> +
> +--source include/have_innodb.inc
> +
> +SELECT COUNT(@@GLOBAL.innodb_adaptive_hash_index_partitions) AS should_be_1;
> +

I’m not sure what the above check is supposed to verify. Apparently that
the variable exists and is not NULL. But if that’s the case, the test
would fail anyway.

Just checking the default value would make sense. But it’s not checked
anywhere in the test.

> +--error ER_INCORRECT_GLOBAL_LOCAL_VAR
> +SET @@GLOBAL.innodb_adaptive_hash_index_partitions=1;
> +
> +SELECT COUNT(@@GLOBAL.innodb_adaptive_hash_index_partitions) AS should_be_1;
> +

The same check again?

> +SELECT COUNT(VARIABLE_VALUE) AS should_be_1
> +FROM INFORMATION_SCHEMA.GLOBAL_VARIABLES
> +WHERE VARIABLE_NAME='innodb_adaptive_hash_index_partitions';
> +
> +SELECT @@GLOBAL.innodb_adaptive_hash_index_partitions = VARIABLE_VALUE AS should_be_1
> +FROM INFORMATION_SCHEMA.GLOBAL_VARIABLES
> +WHERE VARIABLE_NAME='innodb_adaptive_hash_index_partitions';
> +
> +SELECT @@innodb_adaptive_hash_index_partitions = @@GLOBAL.innodb_adaptive_hash_index_partitions AS should_be_1;
> +
> +SELECT COUNT(@@innodb_adaptive_hash_index_partitions) AS should_be_1;
> +
> +--Error ER_INCORRECT_GLOBAL_LOCAL_VAR
> +SELECT COUNT(@@LOCAL.innodb_adaptive_hash_index_partitions);
> +
> +--Error ER_INCORRECT_GLOBAL_LOCAL_VAR
> +SELECT COUNT(@@SESSION.innodb_adaptive_hash_index_partitions);
> +
> +--Error ER_BAD_FIELD_ERROR
> +SELECT innodb_adaptive_hash_index_partitions = @@SESSION.innodb_adaptive_hash_index_partitions;

I don’t know the purpose of all these checks which are replicated from
one test case to another. It looks like some incompetent (to put it
mildly) person first wrote them, and then everyone else copies that
stuff whenever he needs to implement a variable test.

What I would expect to see in a sys_var.*_basic test is verifying
the variable type, and default/min/max values. Instead most tests do
some acrobatics with I_S and different syntax to access the variable.

Please also consider backporting it to 5.5 as I mentioned in the 5.5 MP.

review: Needs Fixing

[Laurynas Biveinis (laurynas-biveinis)]

> More comments on test cases:
...
> I don’t know the purpose of all these checks which are replicated from
> one test case to another. It looks like some incompetent (to put it
> mildly) person first wrote them, and then everyone else copies that
> stuff whenever he needs to implement a variable test.
>
> What I would expect to see in a sys_var.*_basic test is verifying
> the variable type, and default/min/max values. Instead most tests do
> some acrobatics with I_S and different syntax to access the variable.

I absolutely agree with all these comments and obviously I have cut some corners when copied/pasted/modified it.

What do you think about the following? The variable is global-only, read-only. Check the default, check the read-only-ness, check that global only. For 5.5 too.

# A sys_vars suite test from innodb_adaptive_hash_index_partitions.

--source include/have_innodb.inc

SELECT @@GLOBAL.innodb_adaptive_hash_index_partitions;

--error ER_INCORRECT_GLOBAL_LOCAL_VAR
SET @@GLOBAL.innodb_adaptive_hash_index_partitions=1;

--error ER_INCORRECT_GLOBAL_LOCAL_VAR
SELECT @@LOCAL.innodb_adaptive_hash_index_partitions;

--error ER_INCORRECT_GLOBAL_LOCAL_VAR
SELECT @@SESSION.innodb_adaptive_hash_index_partitions;

[Alexey Kopytov (akopytov)]

On Tue, Aug 27 2013 15:52:14 +0000, Laurynas Biveinis wrote:

>> More comments on test cases:
> ...
>> I don’t know the purpose of all these checks which are replicated from
>> one test case to another. It looks like some incompetent (to put it
>> mildly) person first wrote them, and then everyone else copies that
>> stuff whenever he needs to implement a variable test.
>>
>> What I would expect to see in a sys_var.*_basic test is verifying
>> the variable type, and default/min/max values. Instead most tests do
>> some acrobatics with I_S and different syntax to access the variable.
>
> I absolutely agree with all these comments and obviously I have cut some corners when copied/pasted/modified it.
>
> What do you think about the following? The variable is global-only, read-only. Check the default, check the read-only-ness, check that global only. For 5.5 too.
>
> # A sys_vars suite test from innodb_adaptive_hash_index_partitions.
>
> --source include/have_innodb.inc
>
> SELECT @@GLOBAL.innodb_adaptive_hash_index_partitions;
>
> --error ER_INCORRECT_GLOBAL_LOCAL_VAR
> SET @@GLOBAL.innodb_adaptive_hash_index_partitions=1;
>
> --error ER_INCORRECT_GLOBAL_LOCAL_VAR
> SELECT @@LOCAL.innodb_adaptive_hash_index_partitions;
>
> --error ER_INCORRECT_GLOBAL_LOCAL_VAR
> SELECT @@SESSION.innodb_adaptive_hash_index_partitions;

OK.

=== added file 'Percona-Server/mysql-test/suite/innodb/r/percona_ahi_partitions.result'
--- Percona-Server/mysql-test/suite/innodb/r/percona_ahi_partitions.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/innodb/r/percona_ahi_partitions.result	2013-08-28 08:09:39 +0000
@@ -0,0 +1,33 @@
+SELECT @@GLOBAL.innodb_adaptive_hash_index;
+@@GLOBAL.innodb_adaptive_hash_index
+1
+SELECT @@GLOBAL.innodb_adaptive_hash_index_partitions;
+@@GLOBAL.innodb_adaptive_hash_index_partitions
+4
+SET GLOBAL innodb_monitor_enable=module_adaptive_hash;
+CREATE TABLE t1 (a INT PRIMARY KEY, b INT, c CHAR(200), UNIQUE INDEX b(b)) ENGINE=InnoDB;
+CREATE TABLE t2 (a INT PRIMARY KEY, b INT, c CHAR(200), UNIQUE INDEX b(b)) ENGINE=InnoDB;
+CREATE TABLE t3 (a INT PRIMARY KEY, b INT, c CHAR(200), UNIQUE INDEX b(b)) ENGINE=InnoDB;
+Filling tables
+Querying
+SELECT COUNT >= 6 as should_be_1 FROM INFORMATION_SCHEMA.INNODB_METRICS WHERE NAME = 'adaptive_hash_pages_added';
+should_be_1
+1
+SELECT COUNT >= 6 as should_be_1 FROM INFORMATION_SCHEMA.INNODB_METRICS WHERE NAME = 'adaptive_hash_rows_added';
+should_be_1
+1
+SELECT COUNT > 0 as should_be_1 FROM INFORMATION_SCHEMA.INNODB_METRICS WHERE NAME = 'adaptive_hash_searches';
+should_be_1
+1
+SELECT COUNT(*) > 0 AS should_be_1 FROM INFORMATION_SCHEMA.INNODB_BUFFER_PAGE
+WHERE PAGE_STATE LIKE "MEMORY";
+should_be_1
+1
+SELECT COUNT(*) >= 6 AS should_be_1 FROM INFORMATION_SCHEMA.INNODB_BUFFER_PAGE
+WHERE IS_HASHED LIKE "YES";
+should_be_1
+1
+SET GLOBAL innodb_monitor_disable=module_adaptive_hash;
+DROP TABLE t1, t2, t3;
+SET GLOBAL innodb_monitor_enable=default;
+SET GLOBAL innodb_monitor_disable=default;

=== added file 'Percona-Server/mysql-test/suite/innodb/t/percona_ahi_partitions-master.opt'
--- Percona-Server/mysql-test/suite/innodb/t/percona_ahi_partitions-master.opt	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/innodb/t/percona_ahi_partitions-master.opt	2013-08-28 08:09:39 +0000
@@ -0,0 +1,1 @@
+--innodb-adaptive-hash-index-partitions=4

=== added file 'Percona-Server/mysql-test/suite/innodb/t/percona_ahi_partitions.test'
--- Percona-Server/mysql-test/suite/innodb/t/percona_ahi_partitions.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/innodb/t/percona_ahi_partitions.test	2013-08-28 08:09:39 +0000
@@ -0,0 +1,67 @@
+#
+# Basic test for InnoDB adaptive hash index partitions.
+# TODO: add another testcase that uses DEBUG_SYNC to check the partition locking
+#
+--source include/have_innodb.inc
+
+# Check setup
+SELECT @@GLOBAL.innodb_adaptive_hash_index;
+SELECT @@GLOBAL.innodb_adaptive_hash_index_partitions;
+
+SET GLOBAL innodb_monitor_enable=module_adaptive_hash;
+
+# 6 index trees across 4 AHI partitions
+CREATE TABLE t1 (a INT PRIMARY KEY, b INT, c CHAR(200), UNIQUE INDEX b(b)) ENGINE=InnoDB;
+CREATE TABLE t2 (a INT PRIMARY KEY, b INT, c CHAR(200), UNIQUE INDEX b(b)) ENGINE=InnoDB;
+CREATE TABLE t3 (a INT PRIMARY KEY, b INT, c CHAR(200), UNIQUE INDEX b(b)) ENGINE=InnoDB;
+
+--echo Filling tables
+--disable_query_log
+let $i=3;
+while ($i)
+{
+        eval INSERT INTO t1 VALUES ($i, $i, REPEAT("a", 200));
+        eval INSERT INTO t2 VALUES ($i, $i, REPEAT("a", 200));
+        eval INSERT INTO t3 VALUES ($i, $i, REPEAT("a", 200));
+        dec $i;
+}
+
+--echo Querying
+--disable_result_log
+let $i=200;
+while ($i)
+{
+        SELECT b FROM t1 WHERE a=1;
+        SELECT a FROM t1 WHERE b=1;
+        SELECT b FROM t2 WHERE a=2;
+        SELECT a FROM t2 WHERE b=2;
+        SELECT b FROM t3 WHERE a=3;
+        SELECT a FROM t3 WHERE b=3;
+        dec $i;
+}
+--enable_result_log
+--enable_query_log
+
+# Some buffer pool pages should be hashed
+SELECT COUNT >= 6 as should_be_1 FROM INFORMATION_SCHEMA.INNODB_METRICS WHERE NAME = 'adaptive_hash_pages_added';
+# Some rows should be hashed
+SELECT COUNT >= 6 as should_be_1 FROM INFORMATION_SCHEMA.INNODB_METRICS WHERE NAME = 'adaptive_hash_rows_added';
+# AHI should have been used for queries, but the exact lower bound is hard to determine
+SELECT COUNT > 0 as should_be_1 FROM INFORMATION_SCHEMA.INNODB_METRICS WHERE NAME = 'adaptive_hash_searches';
+
+# Buffer pool must contain AHI pages now
+SELECT COUNT(*) > 0 AS should_be_1 FROM INFORMATION_SCHEMA.INNODB_BUFFER_PAGE
+       WHERE PAGE_STATE LIKE "MEMORY";
+
+# Buffer pool must contain no less than the number of index trees hashed pages now
+SELECT COUNT(*) >= 6 AS should_be_1 FROM INFORMATION_SCHEMA.INNODB_BUFFER_PAGE
+       WHERE IS_HASHED LIKE "YES";
+
+SET GLOBAL innodb_monitor_disable=module_adaptive_hash;
+
+DROP TABLE t1, t2, t3;
+
+--disable_warnings
+SET GLOBAL innodb_monitor_enable=default;
+SET GLOBAL innodb_monitor_disable=default;
+--enable_warnings

=== added file 'Percona-Server/mysql-test/suite/sys_vars/r/innodb_adaptive_hash_index_partitions_basic.result'
--- Percona-Server/mysql-test/suite/sys_vars/r/innodb_adaptive_hash_index_partitions_basic.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/sys_vars/r/innodb_adaptive_hash_index_partitions_basic.result	2013-08-28 08:09:39 +0000
@@ -0,0 +1,9 @@
+SELECT @@GLOBAL.innodb_adaptive_hash_index_partitions;
+@@GLOBAL.innodb_adaptive_hash_index_partitions
+1
+SET @@GLOBAL.innodb_adaptive_hash_index_partitions=1;
+ERROR HY000: Variable 'innodb_adaptive_hash_index_partitions' is a read only variable
+SELECT @@LOCAL.innodb_adaptive_hash_index_partitions;
+ERROR HY000: Variable 'innodb_adaptive_hash_index_partitions' is a GLOBAL variable
+SELECT @@SESSION.innodb_adaptive_hash_index_partitions;
+ERROR HY000: Variable 'innodb_adaptive_hash_index_partitions' is a GLOBAL variable

=== added file 'Percona-Server/mysql-test/suite/sys_vars/t/innodb_adaptive_hash_index_partitions_basic.test'
--- Percona-Server/mysql-test/suite/sys_vars/t/innodb_adaptive_hash_index_partitions_basic.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/sys_vars/t/innodb_adaptive_hash_index_partitions_basic.test	2013-08-28 08:09:39 +0000
@@ -0,0 +1,14 @@
+# A sys_vars suite test for innodb_adaptive_hash_index_partitions.
+
+--source include/have_innodb.inc
+
+SELECT @@GLOBAL.innodb_adaptive_hash_index_partitions;
+
+--error ER_INCORRECT_GLOBAL_LOCAL_VAR
+SET @@GLOBAL.innodb_adaptive_hash_index_partitions=1;
+
+--error ER_INCORRECT_GLOBAL_LOCAL_VAR
+SELECT @@LOCAL.innodb_adaptive_hash_index_partitions;
+
+--error ER_INCORRECT_GLOBAL_LOCAL_VAR
+SELECT @@SESSION.innodb_adaptive_hash_index_partitions;

=== modified file 'Percona-Server/storage/innobase/btr/btr0cur.cc'
--- Percona-Server/storage/innobase/btr/btr0cur.cc	2013-08-14 03:57:21 +0000
+++ Percona-Server/storage/innobase/btr/btr0cur.cc	2013-08-28 08:09:39 +0000
@@ -536,7 +536,8 @@
 # ifdef UNIV_SEARCH_PERF_STAT
 	info->n_searches++;
 # endif
-	if (rw_lock_get_writer(&btr_search_latch) == RW_LOCK_NOT_LOCKED
+	if ((rw_lock_get_writer(btr_search_get_latch(cursor->index->id))
+	     == RW_LOCK_NOT_LOCKED)
 	    && latch_mode <= BTR_MODIFY_LEAF
 	    && info->last_hash_succ
 	    && !estimate
@@ -572,7 +573,7 @@
 
 	if (has_search_latch) {
 		/* Release possible search latch to obey latching order */
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(cursor->index->id));
 	}
 
 	/* Store the position of the tree latch we push to mtr so that we
@@ -895,7 +896,7 @@
 
 	if (has_search_latch) {
 
-		rw_lock_s_lock(&btr_search_latch);
+		rw_lock_s_lock(btr_search_get_latch(cursor->index->id));
 	}
 }
 
@@ -2162,13 +2163,13 @@
 			btr_search_update_hash_on_delete(cursor);
 		}
 
-		rw_lock_x_lock(&btr_search_latch);
+		rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
 	}
 
 	row_upd_rec_in_place(rec, index, offsets, update, page_zip);
 
 	if (is_hashed) {
-		rw_lock_x_unlock(&btr_search_latch);
+		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
 	}
 
 	btr_cur_update_in_place_log(flags, rec, index, update,

=== modified file 'Percona-Server/storage/innobase/btr/btr0sea.cc'
--- Percona-Server/storage/innobase/btr/btr0sea.cc	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/btr/btr0sea.cc	2013-08-28 08:09:39 +0000
@@ -47,6 +47,9 @@
 Protected by btr_search_latch. */
 UNIV_INTERN char		btr_search_enabled	= TRUE;
 
+/** Number of adaptive hash index partitions */
+UNIV_INTERN ulint		btr_search_index_num;
+
 /** A dummy variable to fool the compiler */
 UNIV_INTERN ulint		btr_search_this_is_zero = 0;
 
@@ -68,9 +71,9 @@
 being updated in-place! We can use fact (1) to perform unique searches to
 indexes. */
 
-/* We will allocate the latch from dynamic memory to get it to the
+/* We will allocate the latches from dynamic memory to get them to the
 same DRAM page as other hotspot semaphores */
-UNIV_INTERN rw_lock_t*		btr_search_latch_temp;
+UNIV_INTERN rw_lock_t**		btr_search_latch_temp_arr;
 
 /** padding to prevent other memory update hotspots from residing on
 the same memory cache line */
@@ -122,18 +125,19 @@
 will not guarantee success. */
 static
 void
-btr_search_check_free_space_in_heap(void)
-/*=====================================*/
+btr_search_check_free_space_in_heap(
+/*================================*/
+	index_id_t	key)	/*!<in: id of the hashed index tree */
 {
 	hash_table_t*	table;
 	mem_heap_t*	heap;
 
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(!rw_lock_own(btr_search_get_latch(key), RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(key), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	table = btr_search_sys->hash_index;
+	table = btr_search_get_hash_index(key);
 
 	heap = table->heap;
 
@@ -144,7 +148,7 @@
 	if (heap->free_block == NULL) {
 		buf_block_t*	block = buf_block_alloc(NULL);
 
-		rw_lock_x_lock(&btr_search_latch);
+		rw_lock_x_lock(btr_search_get_latch(key));
 
 		if (heap->free_block == NULL) {
 			heap->free_block = block;
@@ -152,7 +156,7 @@
 			buf_block_free(block);
 		}
 
-		rw_lock_x_unlock(&btr_search_latch);
+		rw_lock_x_unlock(btr_search_get_latch(key));
 	}
 }
 
@@ -164,23 +168,48 @@
 /*==================*/
 	ulint	hash_size)	/*!< in: hash index hash table size */
 {
+	ulint	i;
+
+	/* PS bug lp:1018264 - Multiple hash index partitions causes overly
+	large hash index: When multiple adaptive hash index partitions are
+	specified, _each_ partition was being created with hash_size which
+	should be 1/64 of the total size of all buffer pools which is
+	incorrect and can cause overly high memory usage. hash_size
+	should be representing the _total_ size of all partitions, not the
+	individual size of each partition. */
+	hash_size /= btr_search_index_num;
+
 	/* We allocate the search latch from dynamic memory:
 	see above at the global variable definition */
 
-	btr_search_latch_temp = (rw_lock_t*) mem_alloc(sizeof(rw_lock_t));
+	/* btr_search_index_num should be <= 32. (bits of
+	trx->has_search_latch) */
+	ut_ad(btr_search_index_num <= 32);
 
-	rw_lock_create(btr_search_latch_key, &btr_search_latch,
-		       SYNC_SEARCH_SYS);
+	btr_search_latch_temp_arr = (rw_lock_t**)
+		mem_alloc(sizeof(rw_lock_t *) * btr_search_index_num);
 
 	btr_search_sys = (btr_search_sys_t*)
 		mem_alloc(sizeof(btr_search_sys_t));
 
-	btr_search_sys->hash_index = ha_create(hash_size, 0,
-					MEM_HEAP_FOR_BTR_SEARCH, 0);
+	btr_search_sys->hash_index = (hash_table_t **)
+		mem_alloc(sizeof(hash_table_t *) * btr_search_index_num);
+
+	for (i = 0; i < btr_search_index_num; i++) {
+		btr_search_latch_temp_arr[i] = (rw_lock_t *)
+			mem_alloc(sizeof(rw_lock_t));
+
+		rw_lock_create(btr_search_latch_key,
+			       btr_search_latch_temp_arr[i],
+			       SYNC_SEARCH_SYS);
+
+		btr_search_sys->hash_index[i]
+			= ha_create(hash_size, 0, MEM_HEAP_FOR_BTR_SEARCH, 0);
+
 #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
-	btr_search_sys->hash_index->adaptive = TRUE;
+		btr_search_sys->hash_index[i]->adaptive = TRUE;
 #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
-
+	}
 }
 
 /*****************************************************************//**
@@ -190,11 +219,25 @@
 btr_search_sys_free(void)
 /*=====================*/
 {
-	rw_lock_free(&btr_search_latch);
-	mem_free(btr_search_latch_temp);
-	btr_search_latch_temp = NULL;
-	mem_heap_free(btr_search_sys->hash_index->heap);
-	hash_table_free(btr_search_sys->hash_index);
+	ulint	i;
+
+	for (i = 0; i < btr_search_index_num; i++) {
+
+		rw_lock_free(btr_search_latch_temp_arr[i]);
+
+		mem_free(btr_search_latch_temp_arr[i]);
+
+		mem_heap_free(btr_search_sys->hash_index[i]->heap);
+
+		hash_table_free(btr_search_sys->hash_index[i]);
+
+	}
+
+	mem_free(btr_search_latch_temp_arr);
+	btr_search_latch_temp_arr = NULL;
+
+	mem_free(btr_search_sys->hash_index);
+
 	mem_free(btr_search_sys);
 	btr_search_sys = NULL;
 }
@@ -210,13 +253,14 @@
 	dict_index_t*	index;
 
 	ut_ad(mutex_own(&dict_sys->mutex));
-#ifdef UNIV_SYNC_DEBUG
-	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
-#endif /* UNIV_SYNC_DEBUG */
 
 	for (index = dict_table_get_first_index(table); index;
 	     index = dict_table_get_next_index(index)) {
 
+#ifdef UNIV_SYNC_DEBUG
+		ut_ad(rw_lock_own(btr_search_get_latch(index->id),
+				  RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
 		index->search_info->ref_count = 0;
 	}
 }
@@ -229,9 +273,10 @@
 /*====================*/
 {
 	dict_table_t*	table;
+	ulint		i;
 
 	mutex_enter(&dict_sys->mutex);
-	rw_lock_x_lock(&btr_search_latch);
+	btr_search_x_lock_all();
 
 	btr_search_enabled = FALSE;
 
@@ -255,10 +300,12 @@
 	buf_pool_clear_hash_index();
 
 	/* Clear the adaptive hash index. */
-	hash_table_clear(btr_search_sys->hash_index);
-	mem_heap_empty(btr_search_sys->hash_index->heap);
+	for (i = 0; i < btr_search_index_num; i++) {
+		hash_table_clear(btr_search_sys->hash_index[i]);
+		mem_heap_empty(btr_search_sys->hash_index[i]->heap);
+	}
 
-	rw_lock_x_unlock(&btr_search_latch);
+	btr_search_x_unlock_all();
 }
 
 /********************************************************************//**
@@ -268,11 +315,11 @@
 btr_search_enable(void)
 /*====================*/
 {
-	rw_lock_x_lock(&btr_search_latch);
+	btr_search_x_lock_all();
 
 	btr_search_enabled = TRUE;
 
-	rw_lock_x_unlock(&btr_search_latch);
+	btr_search_x_unlock_all();
 }
 
 /*****************************************************************//**
@@ -324,20 +371,21 @@
 ulint
 btr_search_info_get_ref_count(
 /*==========================*/
-	btr_search_t*   info)	/*!< in: search info. */
+	btr_search_t*   info,	/*!< in: search info. */
+	index_id_t	key)	/*!< in: id of the index owning search info */
 {
 	ulint ret;
 
 	ut_ad(info);
 
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(!rw_lock_own(btr_search_get_latch(key), RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(key), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	rw_lock_s_lock(&btr_search_latch);
+	rw_lock_s_lock(btr_search_get_latch(key));
 	ret = info->ref_count;
-	rw_lock_s_unlock(&btr_search_latch);
+	rw_lock_s_unlock(btr_search_get_latch(key));
 
 	return(ret);
 }
@@ -353,17 +401,15 @@
 	btr_search_t*	info,	/*!< in/out: search info */
 	btr_cur_t*	cursor)	/*!< in: cursor which was just positioned */
 {
-	dict_index_t*	index;
+	dict_index_t*	index = cursor->index;
 	ulint		n_unique;
 	int		cmp;
 
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	index = cursor->index;
-
 	if (dict_index_is_ibuf(index)) {
 		/* So many deletes are performed on an insert buffer tree
 		that we do not consider a hash index useful on it: */
@@ -477,8 +523,10 @@
 				/*!< in: cursor */
 {
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id),
+			   RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id),
+			   RW_LOCK_EX));
 	ut_ad(rw_lock_own(&block->lock, RW_LOCK_SHARED)
 	      || rw_lock_own(&block->lock, RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
@@ -562,7 +610,8 @@
 
 	ut_ad(cursor->flag == BTR_CUR_HASH_FAIL);
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(rw_lock_own(btr_search_get_latch(cursor->index->id),
+			  RW_LOCK_EX));
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
 	      || rw_lock_own(&(block->lock), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
@@ -603,11 +652,13 @@
 			mem_heap_free(heap);
 		}
 #ifdef UNIV_SYNC_DEBUG
-		ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+		ut_ad(rw_lock_own(btr_search_get_latch(cursor->index->id),
+				  RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-		ha_insert_for_fold(btr_search_sys->hash_index, fold,
-				   block, rec);
+		ha_insert_for_fold(
+			btr_search_get_hash_index(cursor->index->id), fold,
+			block, rec);
 
 		MONITOR_INC(MONITOR_ADAPTIVE_HASH_ROW_ADDED);
 	}
@@ -628,8 +679,10 @@
 	ulint*		params2;
 
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id),
+			   RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id),
+			   RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
 	block = btr_cur_get_block(cursor);
@@ -647,7 +700,7 @@
 
 	if (build_index || (cursor->flag == BTR_CUR_HASH_FAIL)) {
 
-		btr_search_check_free_space_in_heap();
+		btr_search_check_free_space_in_heap(cursor->index->id);
 	}
 
 	if (cursor->flag == BTR_CUR_HASH_FAIL) {
@@ -657,11 +710,11 @@
 		btr_search_n_hash_fail++;
 #endif /* UNIV_SEARCH_PERF_STAT */
 
-		rw_lock_x_lock(&btr_search_latch);
+		rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
 
 		btr_search_update_hash_ref(info, block, cursor);
 
-		rw_lock_x_unlock(&btr_search_latch);
+		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
 	}
 
 	if (build_index) {
@@ -906,17 +959,19 @@
 	cursor->flag = BTR_CUR_HASH;
 
 	if (UNIV_LIKELY(!has_search_latch)) {
-		rw_lock_s_lock(&btr_search_latch);
+		rw_lock_s_lock(btr_search_get_latch(index_id));
 
 		if (UNIV_UNLIKELY(!btr_search_enabled)) {
 			goto failure_unlock;
 		}
 	}
 
-	ut_ad(rw_lock_get_writer(&btr_search_latch) != RW_LOCK_EX);
-	ut_ad(rw_lock_get_reader_count(&btr_search_latch) > 0);
+	ut_ad(rw_lock_get_writer(btr_search_get_latch(index_id))
+	      != RW_LOCK_EX);
+	ut_ad(rw_lock_get_reader_count(btr_search_get_latch(index_id)) > 0);
 
-	rec = (rec_t*) ha_search_and_get_data(btr_search_sys->hash_index, fold);
+	rec = (rec_t*) ha_search_and_get_data(
+		btr_search_get_hash_index(index_id), fold);
 
 	if (UNIV_UNLIKELY(!rec)) {
 		goto failure_unlock;
@@ -934,7 +989,7 @@
 			goto failure_unlock;
 		}
 
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(index_id));
 
 		buf_block_dbg_add_level(block, SYNC_TREE_NODE_FROM_HASH);
 	}
@@ -1031,7 +1086,7 @@
 	/*-------------------------------------------*/
 failure_unlock:
 	if (UNIV_LIKELY(!has_search_latch)) {
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(index_id));
 	}
 failure:
 	cursor->flag = BTR_CUR_HASH_FAIL;
@@ -1079,12 +1134,9 @@
 	const dict_index_t*	index;
 	ulint*			offsets;
 	btr_search_t*		info;
-
-#ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
-#endif /* UNIV_SYNC_DEBUG */
-
+	rw_lock_t*		btr_search_latch;
+
+retry:
 	/* Do a dirty check on block->index, return if the block is
 	not in the adaptive hash index. This is to avoid acquiring
 	shared btr_search_latch for performance consideration. */
@@ -1092,17 +1144,31 @@
 		return;
 	}
 
-retry:
-	rw_lock_s_lock(&btr_search_latch);
+	btr_search_latch = block->btr_search_latch;
+
+	if (UNIV_UNLIKELY(!btr_search_latch)) {
+		return;
+	}
+
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!rw_lock_own(btr_search_latch, RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_latch, RW_LOCK_EX));
+#endif /* UNIV_SYNC_DEBUG */
+
+	rw_lock_s_lock(btr_search_latch);
+	if (UNIV_UNLIKELY(btr_search_latch != block->btr_search_latch)) {
+		rw_lock_s_unlock(btr_search_latch);
+		goto retry;
+	}
+
 	index = block->index;
-
-	if (UNIV_LIKELY(!index)) {
-
-		rw_lock_s_unlock(&btr_search_latch);
-
+	if (UNIV_UNLIKELY(!index)) {
+		rw_lock_s_unlock(btr_search_latch);
 		return;
 	}
 
+	ut_a(btr_search_latch == btr_search_get_latch(index->id));
+
 	ut_a(!dict_index_is_ibuf(index));
 #ifdef UNIV_DEBUG
 	switch (dict_index_get_online_status(index)) {
@@ -1125,7 +1191,7 @@
 	}
 #endif /* UNIV_DEBUG */
 
-	table = btr_search_sys->hash_index;
+	table = btr_search_get_hash_index(index->id);
 
 #ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
@@ -1141,7 +1207,7 @@
 	releasing btr_search_latch, as the index page might only
 	be s-latched! */
 
-	rw_lock_s_unlock(&btr_search_latch);
+	rw_lock_s_unlock(btr_search_latch);
 
 	ut_a(n_fields + n_bytes > 0);
 
@@ -1192,7 +1258,7 @@
 		mem_heap_free(heap);
 	}
 
-	rw_lock_x_lock(&btr_search_latch);
+	rw_lock_x_lock(btr_search_get_latch(index->id));
 
 	if (UNIV_UNLIKELY(!block->index)) {
 		/* Someone else has meanwhile dropped the hash index */
@@ -1208,7 +1274,7 @@
 		/* Someone else has meanwhile built a new hash index on the
 		page, with different parameters */
 
-		rw_lock_x_unlock(&btr_search_latch);
+		rw_lock_x_unlock(btr_search_get_latch(index->id));
 
 		mem_free(folds);
 		goto retry;
@@ -1224,6 +1290,7 @@
 	info->ref_count--;
 
 	block->index = NULL;
+	block->btr_search_latch = NULL;
 
 	MONITOR_INC(MONITOR_ADAPTIVE_HASH_PAGE_REMOVED);
 	MONITOR_INC_VALUE(MONITOR_ADAPTIVE_HASH_ROW_REMOVED, n_cached);
@@ -1239,14 +1306,14 @@
 			"InnoDB: the hash index to a page of %s,"
 			" still %lu hash nodes remain.\n",
 			index->name, (ulong) block->n_pointers);
-		rw_lock_x_unlock(&btr_search_latch);
+		rw_lock_x_unlock(btr_search_get_latch(index->id));
 
 		ut_ad(btr_search_validate());
 	} else {
-		rw_lock_x_unlock(&btr_search_latch);
+		rw_lock_x_unlock(btr_search_get_latch(index->id));
 	}
 #else /* UNIV_AHI_DEBUG || UNIV_DEBUG */
-	rw_lock_x_unlock(&btr_search_latch);
+	rw_lock_x_unlock(btr_search_get_latch(index->id));
 #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
 
 	mem_free(folds);
@@ -1325,30 +1392,30 @@
 	ut_a(!dict_index_is_ibuf(index));
 
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_EX));
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
 	      || rw_lock_own(&(block->lock), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	rw_lock_s_lock(&btr_search_latch);
+	rw_lock_s_lock(btr_search_get_latch(index->id));
 
 	if (!btr_search_enabled) {
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(index->id));
 		return;
 	}
 
-	table = btr_search_sys->hash_index;
+	table = btr_search_get_hash_index(index->id);
 	page = buf_block_get_frame(block);
 
 	if (block->index && ((block->curr_n_fields != n_fields)
 			     || (block->curr_n_bytes != n_bytes)
 			     || (block->curr_left_side != left_side))) {
 
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(index->id));
 
 		btr_search_drop_page_hash_index(block);
 	} else {
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(index->id));
 	}
 
 	n_recs = page_get_n_recs(page);
@@ -1442,9 +1509,9 @@
 		fold = next_fold;
 	}
 
-	btr_search_check_free_space_in_heap();
+	btr_search_check_free_space_in_heap(index->id);
 
-	rw_lock_x_lock(&btr_search_latch);
+	rw_lock_x_lock(btr_search_get_latch(index->id));
 
 	if (UNIV_UNLIKELY(!btr_search_enabled)) {
 		goto exit_func;
@@ -1471,6 +1538,7 @@
 	block->curr_n_bytes = n_bytes;
 	block->curr_left_side = left_side;
 	block->index = index;
+	block->btr_search_latch = btr_search_get_latch(index->id);
 
 	for (i = 0; i < n_cached; i++) {
 
@@ -1480,7 +1548,7 @@
 	MONITOR_INC(MONITOR_ADAPTIVE_HASH_PAGE_ADDED);
 	MONITOR_INC_VALUE(MONITOR_ADAPTIVE_HASH_ROW_ADDED, n_cached);
 exit_func:
-	rw_lock_x_unlock(&btr_search_latch);
+	rw_lock_x_unlock(btr_search_get_latch(index->id));
 
 	mem_free(folds);
 	mem_free(recs);
@@ -1515,7 +1583,7 @@
 	ut_ad(rw_lock_own(&(new_block->lock), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	rw_lock_s_lock(&btr_search_latch);
+	rw_lock_s_lock(btr_search_get_latch(index->id));
 
 	ut_a(!new_block->index || new_block->index == index);
 	ut_a(!block->index || block->index == index);
@@ -1524,7 +1592,7 @@
 
 	if (new_block->index) {
 
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(index->id));
 
 		btr_search_drop_page_hash_index(block);
 
@@ -1541,7 +1609,7 @@
 		new_block->n_bytes = block->curr_n_bytes;
 		new_block->left_side = left_side;
 
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(index->id));
 
 		ut_a(n_fields + n_bytes > 0);
 
@@ -1553,7 +1621,7 @@
 		return;
 	}
 
-	rw_lock_s_unlock(&btr_search_latch);
+	rw_lock_s_unlock(btr_search_get_latch(index->id));
 }
 
 /********************************************************************//**
@@ -1592,7 +1660,7 @@
 	ut_a(block->curr_n_fields + block->curr_n_bytes > 0);
 	ut_a(!dict_index_is_ibuf(index));
 
-	table = btr_search_sys->hash_index;
+	table = btr_search_get_hash_index(cursor->index->id);
 
 	rec = btr_cur_get_rec(cursor);
 
@@ -1603,7 +1671,7 @@
 		mem_heap_free(heap);
 	}
 
-	rw_lock_x_lock(&btr_search_latch);
+	rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
 
 	if (block->index) {
 		ut_a(block->index == index);
@@ -1616,7 +1684,7 @@
 		}
 	}
 
-	rw_lock_x_unlock(&btr_search_latch);
+	rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
 }
 
 /********************************************************************//**
@@ -1653,7 +1721,7 @@
 	ut_a(cursor->index == index);
 	ut_a(!dict_index_is_ibuf(index));
 
-	rw_lock_x_lock(&btr_search_latch);
+	rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
 
 	if (!block->index) {
 
@@ -1667,7 +1735,7 @@
 	    && (cursor->n_bytes == block->curr_n_bytes)
 	    && !block->curr_left_side) {
 
-		table = btr_search_sys->hash_index;
+		table = btr_search_get_hash_index(cursor->index->id);
 
 		if (ha_search_and_update_if_found(
 			table, cursor->fold, rec, block,
@@ -1676,9 +1744,9 @@
 		}
 
 func_exit:
-		rw_lock_x_unlock(&btr_search_latch);
+		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
 	} else {
-		rw_lock_x_unlock(&btr_search_latch);
+		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
 
 		btr_search_update_hash_on_insert(cursor);
 	}
@@ -1726,9 +1794,9 @@
 		return;
 	}
 
-	btr_search_check_free_space_in_heap();
+	btr_search_check_free_space_in_heap(cursor->index->id);
 
-	table = btr_search_sys->hash_index;
+	table = btr_search_get_hash_index(cursor->index->id);
 
 	rec = btr_cur_get_rec(cursor);
 
@@ -1760,7 +1828,7 @@
 	} else {
 		if (left_side) {
 
-			rw_lock_x_lock(&btr_search_latch);
+			rw_lock_x_lock(btr_search_get_latch(index->id));
 
 			locked = TRUE;
 
@@ -1778,7 +1846,7 @@
 
 		if (!locked) {
 
-			rw_lock_x_lock(&btr_search_latch);
+			rw_lock_x_lock(btr_search_get_latch(index->id));
 
 			locked = TRUE;
 
@@ -1800,7 +1868,8 @@
 		if (!left_side) {
 
 			if (!locked) {
-				rw_lock_x_lock(&btr_search_latch);
+				rw_lock_x_lock(btr_search_get_latch(
+						   index->id));
 
 				locked = TRUE;
 
@@ -1819,7 +1888,7 @@
 
 		if (!locked) {
 
-			rw_lock_x_lock(&btr_search_latch);
+			rw_lock_x_lock(btr_search_get_latch(index->id));
 
 			locked = TRUE;
 
@@ -1846,18 +1915,19 @@
 		mem_heap_free(heap);
 	}
 	if (locked) {
-		rw_lock_x_unlock(&btr_search_latch);
+		rw_lock_x_unlock(btr_search_get_latch(index->id));
 	}
 }
 
 #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
 /********************************************************************//**
-Validates the search system.
+Validates one hash table in the search system.
 @return	TRUE if ok */
-UNIV_INTERN
+static
 ibool
-btr_search_validate(void)
-/*=====================*/
+btr_search_validate_one_table(
+/*==========================*/
+	ulint	t)
 {
 	ha_node_t*	node;
 	ulint		n_page_dumps	= 0;
@@ -1874,24 +1944,20 @@
 
 	rec_offs_init(offsets_);
 
-	rw_lock_x_lock(&btr_search_latch);
-	buf_pool_mutex_enter_all();
-
-	cell_count = hash_get_n_cells(btr_search_sys->hash_index);
+	cell_count = hash_get_n_cells(btr_search_sys->hash_index[t]);
 
 	for (i = 0; i < cell_count; i++) {
 		/* We release btr_search_latch every once in a while to
 		give other queries a chance to run. */
 		if ((i != 0) && ((i % chunk_size) == 0)) {
-			buf_pool_mutex_exit_all();
-			rw_lock_x_unlock(&btr_search_latch);
+			btr_search_x_unlock_all();
 			os_thread_yield();
-			rw_lock_x_lock(&btr_search_latch);
-			buf_pool_mutex_enter_all();
+			btr_search_x_lock_all();
 		}
 
 		node = (ha_node_t*)
-			hash_get_nth_cell(btr_search_sys->hash_index, i)->node;
+			hash_get_nth_cell(btr_search_sys->hash_index[t],
+					  i)->node;
 
 		for (; node != NULL; node = node->next) {
 			const buf_block_t*	block
@@ -1999,24 +2065,47 @@
 		/* We release btr_search_latch every once in a while to
 		give other queries a chance to run. */
 		if (i != 0) {
-			buf_pool_mutex_exit_all();
-			rw_lock_x_unlock(&btr_search_latch);
+			btr_search_x_unlock_all();
 			os_thread_yield();
-			rw_lock_x_lock(&btr_search_latch);
-			buf_pool_mutex_enter_all();
+			btr_search_x_lock_all();
 		}
 
-		if (!ha_validate(btr_search_sys->hash_index, i, end_index)) {
+		if (!ha_validate(btr_search_sys->hash_index[t], i,
+				 end_index)) {
 			ok = FALSE;
 		}
 	}
 
-	buf_pool_mutex_exit_all();
-	rw_lock_x_unlock(&btr_search_latch);
 	if (UNIV_LIKELY_NULL(heap)) {
 		mem_heap_free(heap);
 	}
 
 	return(ok);
 }
+
+/********************************************************************//**
+Validates the search system.
+@return	TRUE if ok */
+UNIV_INTERN
+ibool
+btr_search_validate(void)
+/*=====================*/
+{
+	ulint	i;
+	ibool	ok	= TRUE;
+
+	btr_search_x_lock_all();
+
+	for (i = 0; i < btr_search_index_num; i++) {
+
+		if (!btr_search_validate_one_table(i))
+			ok = FALSE;
+	}
+
+	btr_search_x_unlock_all();
+
+	return(ok);
+}
+
+
 #endif /* defined UNIV_AHI_DEBUG || defined UNIV_DEBUG */

=== modified file 'Percona-Server/storage/innobase/buf/buf0buf.cc'
--- Percona-Server/storage/innobase/buf/buf0buf.cc	2013-08-26 15:36:54 +0000
+++ Percona-Server/storage/innobase/buf/buf0buf.cc	2013-08-28 08:09:39 +0000
@@ -1013,6 +1013,7 @@
 
 	block->check_index_page_at_flush = FALSE;
 	block->index = NULL;
+	block->btr_search_latch = NULL;
 
 #ifdef UNIV_DEBUG
 	block->page.in_page_hash = FALSE;
@@ -1484,7 +1485,7 @@
 	ulint	p;
 
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(btr_search_own_all(RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 	ut_ad(!btr_search_enabled);
 
@@ -2208,6 +2209,7 @@
 {
 	block->check_index_page_at_flush = FALSE;
 	block->index		= NULL;
+	block->btr_search_latch = NULL;
 
 	block->n_hash_helps	= 0;
 	block->n_fields		= 1;

=== modified file 'Percona-Server/storage/innobase/dict/dict0dict.cc'
--- Percona-Server/storage/innobase/dict/dict0dict.cc	2013-08-14 03:57:21 +0000
+++ Percona-Server/storage/innobase/dict/dict0dict.cc	2013-08-28 08:09:39 +0000
@@ -1208,7 +1208,8 @@
 
 			See also: dict_index_remove_from_cache_low() */
 
-			if (btr_search_info_get_ref_count(info) > 0) {
+			if (btr_search_info_get_ref_count(info, index->id)
+			    > 0) {
 				return(FALSE);
 			}
 		}
@@ -2483,7 +2484,8 @@
 	zero. See also: dict_table_can_be_evicted() */
 
 	do {
-		ulint ref_count = btr_search_info_get_ref_count(info);
+		ulint ref_count = btr_search_info_get_ref_count(info,
+								index->id);
 
 		if (ref_count == 0) {
 			break;

=== modified file 'Percona-Server/storage/innobase/ha/ha0ha.cc'
--- Percona-Server/storage/innobase/ha/ha0ha.cc	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/ha/ha0ha.cc	2013-08-28 08:09:39 +0000
@@ -98,6 +98,31 @@
 	return(table);
 }
 
+#ifdef UNIV_SYNC_DEBUG
+/*************************************************************//**
+Verifies that the specified hash table is a part of adaptive hash index and
+that its corresponding latch is X-latched by the current thread.  */
+static
+bool
+ha_assert_btr_x_locked(
+/*===================*/
+	const hash_table_t* table)	/*!<in: hash table to check */
+{
+	ulint i;
+
+	ut_ad(table->adaptive);
+
+	for (i = 0; i < btr_search_index_num; i++)
+		if (btr_search_sys->hash_index[i] == table)
+			break;
+
+	ut_ad(i < btr_search_index_num);
+	ut_ad(rw_lock_own(btr_search_latch_temp_arr[i], RW_LOCK_EX));
+
+	return(true);
+}
+#endif /* UNIV_SYNC_DEBUG */
+
 /*************************************************************//**
 Empties a hash table and frees the memory heaps. */
 UNIV_INTERN
@@ -112,8 +137,7 @@
 	ut_ad(table);
 	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!table->adaptive
-	       || rw_lock_own(&btr_search_latch, RW_LOCK_EXCLUSIVE));
+	ut_ad(!table->adaptive || ha_assert_btr_x_locked(table));
 #endif /* UNIV_SYNC_DEBUG */
 
 	/* Free the memory heaps. */
@@ -274,7 +298,7 @@
 	ut_ad(table);
 	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(ha_assert_btr_x_locked(table));
 #endif /* UNIV_SYNC_DEBUG */
 	ut_ad(btr_search_enabled);
 #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
@@ -313,7 +337,7 @@
 	ut_a(new_block->frame == page_align(new_data));
 #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(ha_assert_btr_x_locked(table));
 #endif /* UNIV_SYNC_DEBUG */
 
 	if (!btr_search_enabled) {

=== modified file 'Percona-Server/storage/innobase/handler/ha_innodb.cc'
--- Percona-Server/storage/innobase/handler/ha_innodb.cc	2013-08-22 13:38:28 +0000
+++ Percona-Server/storage/innobase/handler/ha_innodb.cc	2013-08-28 08:09:39 +0000
@@ -16398,6 +16398,12 @@
   "Disable with --skip-innodb-adaptive-hash-index.",
   NULL, innodb_adaptive_hash_index_update, TRUE);
 
+static MYSQL_SYSVAR_ULONG(adaptive_hash_index_partitions, btr_search_index_num,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Number of InnoDB adaptive hash index partitions (default 1: disable "
+  "partitioning)",
+  NULL, NULL, 1, 1, sizeof(ulint) * 8, 0);
+
 static MYSQL_SYSVAR_ULONG(replication_delay, srv_replication_delay,
   PLUGIN_VAR_RQCMDARG,
   "Replication thread delay (ms) on the slave server if "
@@ -17057,6 +17063,7 @@
   MYSQL_SYSVAR(stats_persistent_sample_pages),
   MYSQL_SYSVAR(stats_auto_recalc),
   MYSQL_SYSVAR(adaptive_hash_index),
+  MYSQL_SYSVAR(adaptive_hash_index_partitions),
   MYSQL_SYSVAR(stats_method),
   MYSQL_SYSVAR(replication_delay),
   MYSQL_SYSVAR(status_file),

=== modified file 'Percona-Server/storage/innobase/handler/xtradb_i_s.cc'
--- Percona-Server/storage/innobase/handler/xtradb_i_s.cc	2012-09-11 06:54:10 +0000
+++ Percona-Server/storage/innobase/handler/xtradb_i_s.cc	2013-08-28 08:09:39 +0000
@@ -329,34 +329,34 @@
 
 	if (btr_search_sys)
 	{
-	  ulint btr_search_sys_subtotal= 0;
-
-	  rw_lock_s_lock(&btr_search_latch);
-	  if (btr_search_sys->hash_index->heap) {
-	    btr_search_sys_subtotal = mem_heap_get_size(btr_search_sys->hash_index->heap);
-	  } else {
-	    btr_search_sys_subtotal = 0;
-	    for (unsigned int i=0;
-		 i < btr_search_sys->hash_index->n_sync_obj;
-		 i++) {
-	      btr_search_sys_subtotal += mem_heap_get_size(btr_search_sys->hash_index->heaps[i]);
-	    }
-	  }
-	  rw_lock_s_unlock(&btr_search_latch);
-
-	  OK(field_store_string(fields[INT_HASH_TABLES_NAME],
-				"Adaptive hash index"));
-	  OK(field_store_ulint(fields[INT_HASH_TABLES_TOTAL],
-			       btr_search_sys_subtotal
-			       + (btr_search_sys->hash_index->n_cells
-				  * sizeof(hash_cell_t))));
-	  OK(field_store_ulint(fields[INT_HASH_TABLES_CONSTANT],
-			       (btr_search_sys->hash_index->n_cells
-				* sizeof(hash_cell_t))));
-	  OK(field_store_ulint(fields[INT_HASH_TABLES_VARIABLE],
-			       btr_search_sys_subtotal));
-	  OK(schema_table_store_record(thd, table));
-
+		ulint			btr_search_sys_subtotal;
+		const hash_table_t*	hash_index_0
+			= btr_search_sys->hash_index[0];
+
+		if (hash_index_0->heap) {
+			btr_search_sys_subtotal
+				= mem_heap_get_size(hash_index_0->heap);
+		} else {
+			for (ulint i = 0; i < hash_index_0->n_sync_obj; i++) {
+				btr_search_sys_subtotal
+					+= mem_heap_get_size(hash_index_0
+							     ->heaps[i]);
+			}
+		}
+		btr_search_sys_subtotal *= btr_search_index_num;
+
+		OK(field_store_string(fields[INT_HASH_TABLES_NAME],
+				      "Adaptive hash index"));
+		OK(field_store_ulint(fields[INT_HASH_TABLES_TOTAL],
+				     btr_search_sys_subtotal
+				     + (hash_index_0->n_cells
+					* sizeof(hash_cell_t))));
+		OK(field_store_ulint(fields[INT_HASH_TABLES_CONSTANT],
+				     (hash_index_0->n_cells
+				      * sizeof(hash_cell_t))));
+		OK(field_store_ulint(fields[INT_HASH_TABLES_VARIABLE],
+				     btr_search_sys_subtotal));
+		OK(schema_table_store_record(thd, table));
 	}
 
 	{

=== modified file 'Percona-Server/storage/innobase/include/btr0sea.h'
--- Percona-Server/storage/innobase/include/btr0sea.h	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/btr0sea.h	2013-08-28 08:09:39 +0000
@@ -86,7 +86,8 @@
 ulint
 btr_search_info_get_ref_count(
 /*==========================*/
-	btr_search_t*   info);	/*!< in: search info. */
+	btr_search_t*   info,	/*!< in: search info. */
+	index_id_t	key);	/*!< in: id of the index owning search info */
 /*********************************************************************//**
 Updates the search info. */
 UNIV_INLINE
@@ -193,6 +194,69 @@
 # define btr_search_validate()	TRUE
 #endif /* defined UNIV_AHI_DEBUG || defined UNIV_DEBUG */
 
+/********************************************************************//**
+Returns the adaptive hash index table for a given index key.
+@return the adaptive hash index table for a given index key */
+UNIV_INLINE
+hash_table_t*
+btr_search_get_hash_index(
+/*======================*/
+	index_id_t	key)	/*!< in: index key */
+	__attribute__((pure,warn_unused_result));
+
+/********************************************************************//**
+Returns the adaptive hash index latch for a given index key.
+@return the adaptive hash index latch for a given index key */
+UNIV_INLINE
+rw_lock_t*
+btr_search_get_latch(
+/*=================*/
+	index_id_t	key)	/*!< in: index key */
+	__attribute__((pure,warn_unused_result));
+
+/********************************************************************//**
+Latches all adaptive hash index latches in exclusive mode.  */
+UNIV_INLINE
+void
+btr_search_x_lock_all(void);
+/*========================*/
+
+/********************************************************************//**
+Unlatches all adaptive hash index latches in exclusive mode.  */
+UNIV_INLINE
+void
+btr_search_x_unlock_all(void);
+/*==========================*/
+
+/********************************************************************//**
+Latches all adaptive hash index latches in shared mode.  */
+UNIV_INLINE
+void
+btr_search_s_lock_all(void);
+/*========================*/
+
+/********************************************************************//**
+Unlatches all adaptive hash index latches in shared mode.  */
+UNIV_INLINE
+void
+btr_search_s_unlock_all(void);
+/*==========================*/
+
+#ifdef UNIV_SYNC_DEBUG
+/******************************************************************//**
+Checks if the thread has locked all the adaptive hash index latches in the
+specified mode.
+
+@return true if all latches are locked by the current thread, false
+otherwise.  */
+UNIV_INLINE
+bool
+btr_search_own_all(
+/*===============*/
+	ulint lock_type)
+	__attribute__((warn_unused_result));
+#endif /* UNIV_SYNC_DEBUG */
+
 /** The search info struct in an index */
 struct btr_search_t{
 	ulint	ref_count;	/*!< Number of blocks in this index tree
@@ -250,7 +314,7 @@
 
 /** The hash index system */
 struct btr_search_sys_t{
-	hash_table_t*	hash_index;	/*!< the adaptive hash index,
+	hash_table_t**	hash_index;	/*!< the adaptive hash index,
 					mapping dtuple_fold values
 					to rec_t pointers on index pages */
 };

=== modified file 'Percona-Server/storage/innobase/include/btr0sea.ic'
--- Percona-Server/storage/innobase/include/btr0sea.ic	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/btr0sea.ic	2013-08-28 08:09:39 +0000
@@ -60,8 +60,8 @@
 	btr_search_t*	info;
 
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
-	ut_ad(!rw_lock_own(&btr_search_latch, RW_LOCK_EX));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
 	info = btr_search_get_info(index);
@@ -80,3 +80,108 @@
 
 	btr_search_info_update_slow(info, cursor);
 }
+
+/********************************************************************//**
+Returns the adaptive hash index table for a given index key.
+@return the adaptive hash index table for a given index key */
+UNIV_INLINE
+hash_table_t*
+btr_search_get_hash_index(
+/*======================*/
+	index_id_t	key)	/*!< in: index key */
+{
+	return(btr_search_sys->hash_index[key % btr_search_index_num]);
+}
+
+/********************************************************************//**
+Returns the adaptive hash index latch for a given index key.
+@return the adaptive hash index latch for a given index key */
+UNIV_INLINE
+rw_lock_t*
+btr_search_get_latch(
+/*=================*/
+	index_id_t	key)	/*!< in: index key */
+{
+	return(btr_search_latch_temp_arr[key % btr_search_index_num]);
+}
+
+/********************************************************************//**
+Latches all adaptive hash index latches in exclusive mode.  */
+UNIV_INLINE
+void
+btr_search_x_lock_all(void)
+/*=======================*/
+{
+	ulint	i;
+
+	for (i = 0; i < btr_search_index_num; i++) {
+		rw_lock_x_lock(btr_search_latch_temp_arr[i]);
+	}
+}
+
+/********************************************************************//**
+Unlatches all adaptive hash index latches in exclusive mode.  */
+UNIV_INLINE
+void
+btr_search_x_unlock_all(void)
+/*==========================*/
+{
+	ulint	i;
+
+	for (i = 0; i < btr_search_index_num; i++) {
+		rw_lock_x_unlock(btr_search_latch_temp_arr[i]);
+	}
+}
+
+/********************************************************************//**
+Latches all adaptive hash index latches in shared mode.  */
+UNIV_INLINE
+void
+btr_search_s_lock_all(void)
+/*=======================*/
+{
+	ulint	i;
+
+	for (i = 0; i < btr_search_index_num; i++) {
+		rw_lock_s_lock(btr_search_latch_temp_arr[i]);
+	}
+}
+
+/********************************************************************//**
+Unlatches all adaptive hash index latches in shared mode.  */
+UNIV_INLINE
+void
+btr_search_s_unlock_all(void)
+/*=========================*/
+{
+	ulint	i;
+
+	for (i = 0; i < btr_search_index_num; i++) {
+		rw_lock_s_unlock(btr_search_latch_temp_arr[i]);
+	}
+}
+
+#ifdef UNIV_SYNC_DEBUG
+/******************************************************************//**
+Checks if the thread has locked all the adaptive hash index latches in the
+specified mode.
+
+@return true if all latches are locked by the current thread, false
+otherwise.  */
+UNIV_INLINE
+bool
+btr_search_own_all(
+/*===============*/
+	ulint lock_type)
+{
+	ulint	i;
+
+	for (i = 0; i < btr_search_index_num; i++) {
+		if (!rw_lock_own(btr_search_latch_temp_arr[i], lock_type)) {
+			return(false);
+		}
+	}
+
+	return(true);
+}
+#endif /* UNIV_SYNC_DEBUG */

=== modified file 'Percona-Server/storage/innobase/include/btr0types.h'
--- Percona-Server/storage/innobase/include/btr0types.h	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/btr0types.h	2013-08-28 08:09:39 +0000
@@ -54,17 +54,17 @@
 
 Bear in mind (3) and (4) when using the hash index.
 */
-extern rw_lock_t*	btr_search_latch_temp;
+extern rw_lock_t**	btr_search_latch_temp_arr;
 
 #endif /* UNIV_HOTBACKUP */
 
-/** The latch protecting the adaptive search system */
-#define btr_search_latch	(*btr_search_latch_temp)
-
 /** Flag: has the search system been enabled?
 Protected by btr_search_latch. */
 extern char	btr_search_enabled;
 
+/** Number of adaptive hash index partitions */
+extern ulint	btr_search_index_num;
+
 #ifdef UNIV_BLOB_DEBUG
 # include "buf0types.h"
 /** An index->blobs entry for keeping track of off-page column references */

=== modified file 'Percona-Server/storage/innobase/include/buf0buf.h'
--- Percona-Server/storage/innobase/include/buf0buf.h	2013-08-26 15:36:54 +0000
+++ Percona-Server/storage/innobase/include/buf0buf.h	2013-08-28 08:09:39 +0000
@@ -1700,6 +1700,8 @@
 					complete, though: there may
 					have been hash collisions,
 					record deletions, etc. */
+	rw_lock_t*	btr_search_latch;/*!< Adaptive hash index latch for the
+					 index this block belongs to or NULL */
 	/* @} */
 # ifdef UNIV_SYNC_DEBUG
 	/** @name Debug fields */

=== modified file 'Percona-Server/storage/innobase/include/mtr0log.ic'
--- Percona-Server/storage/innobase/include/mtr0log.ic	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/mtr0log.ic	2013-08-28 08:09:39 +0000
@@ -28,6 +28,7 @@
 #include "buf0buf.h"
 #include "buf0dblwr.h"
 #include "fsp0types.h"
+#include "btr0types.h"
 #include "trx0sys.h"
 
 /********************************************************//**

=== modified file 'Percona-Server/storage/innobase/include/que0que.h'
--- Percona-Server/storage/innobase/include/que0que.h	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/que0que.h	2013-08-28 08:09:39 +0000
@@ -29,6 +29,7 @@
 #include "univ.i"
 #include "data0data.h"
 #include "dict0types.h"
+#include "btr0sea.h"
 #include "trx0trx.h"
 #include "trx0roll.h"
 #include "srv0srv.h"

=== modified file 'Percona-Server/storage/innobase/include/read0read.h'
--- Percona-Server/storage/innobase/include/read0read.h	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/read0read.h	2013-08-28 08:09:39 +0000
@@ -31,6 +31,7 @@
 
 #include "ut0byte.h"
 #include "ut0lst.h"
+#include "btr0types.h"
 #include "trx0trx.h"
 #include "trx0sys.h"
 #include "read0types.h"

=== modified file 'Percona-Server/storage/innobase/include/trx0roll.h'
--- Percona-Server/storage/innobase/include/trx0roll.h	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/trx0roll.h	2013-08-28 08:09:39 +0000
@@ -27,6 +27,7 @@
 #define trx0roll_h
 
 #include "univ.i"
+#include "btr0types.h"
 #include "trx0trx.h"
 #include "trx0types.h"
 #include "mtr0mtr.h"

=== modified file 'Percona-Server/storage/innobase/include/trx0trx.h'
--- Percona-Server/storage/innobase/include/trx0trx.h	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/trx0trx.h	2013-08-28 08:09:39 +0000
@@ -1136,10 +1136,7 @@
 
 Bear in mind (3) and (4) when using the hash index.
 */
-extern rw_lock_t*	btr_search_latch_temp;
-
-/** The latch protecting the adaptive search system */
-#define btr_search_latch	(*btr_search_latch_temp)
+extern rw_lock_t**	btr_search_latch_temp_arr;
 
 #ifndef UNIV_NONINL
 #include "trx0trx.ic"

=== modified file 'Percona-Server/storage/innobase/include/trx0trx.ic'
--- Percona-Server/storage/innobase/include/trx0trx.ic	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/trx0trx.ic	2013-08-28 08:09:39 +0000
@@ -164,7 +164,7 @@
 }
 
 /********************************************************************//**
-Releases the search latch if trx has reserved it. */
+Releases the search latches if trx has reserved them. */
 UNIV_INLINE
 void
 trx_search_latch_release_if_reserved(
@@ -172,7 +172,13 @@
 	trx_t*	   trx) /*!< in: transaction */
 {
 	if (trx->has_search_latch) {
-		rw_lock_s_unlock(&btr_search_latch);
+		ulint i;
+
+		for (i = 0; i < btr_search_index_num; i++) {
+			if (trx->has_search_latch & (1UL << i)) {
+				rw_lock_s_unlock(btr_search_latch_temp_arr[i]);
+			}
+		}
 
 		trx->has_search_latch = FALSE;
 	}

=== modified file 'Percona-Server/storage/innobase/include/univ.i'
--- Percona-Server/storage/innobase/include/univ.i	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/include/univ.i	2013-08-28 08:09:39 +0000
@@ -179,7 +179,6 @@
 #define UNIV_COMPILE_TEST_FUNCS
 */
 
-#undef UNIV_SYNC_DEBUG
 #if defined HAVE_VALGRIND
 # define UNIV_DEBUG_VALGRIND
 #endif /* HAVE_VALGRIND */

=== modified file 'Percona-Server/storage/innobase/os/os0file.cc'
--- Percona-Server/storage/innobase/os/os0file.cc	2013-08-21 07:19:25 +0000
+++ Percona-Server/storage/innobase/os/os0file.cc	2013-08-28 08:09:39 +0000
@@ -43,6 +43,7 @@
 #include "srv0start.h"
 #include "fil0fil.h"
 #include "buf0buf.h"
+#include "btr0types.h"
 #include "trx0trx.h"
 #include "srv0mon.h"
 #ifndef UNIV_HOTBACKUP

=== modified file 'Percona-Server/storage/innobase/row/row0sel.cc'
--- Percona-Server/storage/innobase/row/row0sel.cc	2013-08-14 03:57:21 +0000
+++ Percona-Server/storage/innobase/row/row0sel.cc	2013-08-28 08:09:39 +0000
@@ -1233,7 +1233,8 @@
 	ut_ad(!plan->must_get_clust);
 #ifdef UNIV_SYNC_DEBUG
 	if (search_latch_locked) {
-		ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
+		ut_ad(rw_lock_own(btr_search_get_latch(index->id),
+				  RW_LOCK_SHARED));
 	}
 #endif /* UNIV_SYNC_DEBUG */
 
@@ -1405,10 +1406,11 @@
 	    && !plan->must_get_clust
 	    && !plan->table->big_rows) {
 		if (!search_latch_locked) {
-			rw_lock_s_lock(&btr_search_latch);
+			rw_lock_s_lock(btr_search_get_latch(index->id));
 
 			search_latch_locked = TRUE;
-		} else if (rw_lock_get_writer(&btr_search_latch) == RW_LOCK_WAIT_EX) {
+		} else if (rw_lock_get_writer(btr_search_get_latch(index->id))
+			   == RW_LOCK_WAIT_EX) {
 
 			/* There is an x-latch request waiting: release the
 			s-latch for a moment; as an s-latch here is often
@@ -1417,8 +1419,8 @@
 			from acquiring an s-latch for a long time, lowering
 			performance significantly in multiprocessors. */
 
-			rw_lock_s_unlock(&btr_search_latch);
-			rw_lock_s_lock(&btr_search_latch);
+			rw_lock_s_unlock(btr_search_get_latch(index->id));
+			rw_lock_s_lock(btr_search_get_latch(index->id));
 		}
 
 		found_flag = row_sel_try_search_shortcut(node, plan,
@@ -1443,7 +1445,7 @@
 	}
 
 	if (search_latch_locked) {
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(index->id));
 
 		search_latch_locked = FALSE;
 	}
@@ -2019,7 +2021,7 @@
 
 func_exit:
 	if (search_latch_locked) {
-		rw_lock_s_unlock(&btr_search_latch);
+		rw_lock_s_unlock(btr_search_get_latch(index->id));
 	}
 	if (UNIV_LIKELY_NULL(heap)) {
 		mem_heap_free(heap);
@@ -3597,6 +3599,47 @@
 }
 
 /********************************************************************//**
+Acquires an S latch for the adaptive hash index for a given index tree if is
+not acquired already.  If the current transaction already owns a latch with
+a higher index in the latch array, release all the already-held S latches
+and reacquire them together with the desired latch to honor the latching
+order. */
+static
+void
+trx_search_latch_lock(
+/*==================*/
+	trx_t*	trx,		/*!< in: latching transcation */
+	ulint	index_id)	/*!< in: index to latch AHI for */
+{
+	ulint	latch_mask = 1UL << (index_id % btr_search_index_num);
+
+	if (!(trx->has_search_latch & latch_mask)) {
+
+		if (trx->has_search_latch < latch_mask) {
+
+			rw_lock_s_lock(btr_search_get_latch(index_id));
+			trx->has_search_latch |= latch_mask;
+		} else {
+
+			ibool	taken_latches = trx->has_search_latch;
+
+			trx_search_latch_release_if_reserved(trx);
+
+			trx->has_search_latch = taken_latches | latch_mask;
+
+			for (ulint i = 0; i < btr_search_index_num; i++) {
+				if (trx->has_search_latch & (1UL << i)) {
+
+					rw_lock_s_lock(
+						btr_search_latch_temp_arr[i]);
+				}
+			}
+		}
+	}
+}
+
+
+/********************************************************************//**
 Searches for rows in the database. This is used in the interface to
 MySQL. This function opens a cursor, and also implements fetch next
 and fetch prev. NOTE that if we do a search with a full key value
@@ -3658,6 +3701,7 @@
 	ulint*		offsets				= offsets_;
 	ibool		table_lock_waited		= FALSE;
 	byte*		next_buf			= 0;
+	bool		should_release;
 
 	rec_offs_init(offsets_);
 
@@ -3733,19 +3777,29 @@
 		(ulong) trx->mysql_n_tables_locked);
 #endif
 	/*-------------------------------------------------------------*/
-	/* PHASE 0: Release a possible s-latch we are holding on the
-	adaptive hash index latch if there is someone waiting behind */
-
-	if (UNIV_UNLIKELY(rw_lock_get_writer(&btr_search_latch) != RW_LOCK_NOT_LOCKED)
-	    && trx->has_search_latch) {
+	/* PHASE 0: Release possible latches we are holding on the
+	adaptive hash index latches if there is someone waiting behind */
+
+	should_release = false;
+	for (ulint i = 0; i < btr_search_index_num; i++) {
+		/* we should check all latches (fix Bug#791030) */
+		if (UNIV_UNLIKELY(rw_lock_get_writer(
+					  btr_search_latch_temp_arr[i])
+				  != RW_LOCK_NOT_LOCKED)) {
+			should_release = true;
+			break;
+		}
+	}
+
+	if (UNIV_UNLIKELY(should_release)) {
 
 		/* There is an x-latch request on the adaptive hash index:
 		release the s-latch to reduce starvation and wait for
 		BTR_SEA_TIMEOUT rounds before trying to keep it again over
 		calls from MySQL */
 
-		rw_lock_s_unlock(&btr_search_latch);
-		trx->has_search_latch = FALSE;
+		/* We should release all s-latches (fix Bug#791030) */
+		trx_search_latch_release_if_reserved(trx);
 
 		trx->search_latch_timeout = BTR_SEA_TIMEOUT;
 	}
@@ -3896,10 +3950,7 @@
 			hash index semaphore! */
 
 #ifndef UNIV_SEARCH_DEBUG
-			if (!trx->has_search_latch) {
-				rw_lock_s_lock(&btr_search_latch);
-				trx->has_search_latch = TRUE;
-			}
+			trx_search_latch_lock(trx, index->id);
 #endif
 			switch (row_sel_try_search_shortcut_for_mysql(
 					&rec, prebuilt, &offsets, &heap,
@@ -3969,8 +4020,8 @@
 
 					trx->search_latch_timeout--;
 
-					rw_lock_s_unlock(&btr_search_latch);
-					trx->has_search_latch = FALSE;
+					trx_search_latch_release_if_reserved(
+						trx);
 				}
 
 				/* NOTE that we do NOT store the cursor
@@ -3992,10 +4043,7 @@
 	/*-------------------------------------------------------------*/
 	/* PHASE 3: Open or restore index cursor position */
 
-	if (trx->has_search_latch) {
-		rw_lock_s_unlock(&btr_search_latch);
-		trx->has_search_latch = FALSE;
-	}
+	trx_search_latch_release_if_reserved(trx);
 
 	/* The state of a running trx can only be changed by the
 	thread that is currently serving the transaction. Because we

=== modified file 'Percona-Server/storage/innobase/srv/srv0conc.cc'
--- Percona-Server/storage/innobase/srv/srv0conc.cc	2013-05-10 08:51:53 +0000
+++ Percona-Server/storage/innobase/srv/srv0conc.cc	2013-08-28 08:09:39 +0000
@@ -39,6 +39,7 @@
 
 #include "srv0srv.h"
 #include "sync0sync.h"
+#include "btr0types.h"
 #include "trx0trx.h"
 
 #include "mysql/plugin.h"

=== modified file 'Percona-Server/storage/innobase/srv/srv0srv.cc'
--- Percona-Server/storage/innobase/srv/srv0srv.cc	2013-08-14 03:57:21 +0000
+++ Percona-Server/storage/innobase/srv/srv0srv.cc	2013-08-28 08:09:39 +0000
@@ -1308,17 +1308,20 @@
 		os_atomic_increment_lint(&srv_read_views_memory, 0));
 
 	/* Calculate reserved memories */
-	if (btr_search_sys && btr_search_sys->hash_index->heap) {
+	if (btr_search_sys && btr_search_sys->hash_index[0]->heap) {
 		btr_search_sys_subtotal
-			= mem_heap_get_size(btr_search_sys->hash_index->heap);
+			= mem_heap_get_size(btr_search_sys->hash_index[0]
+					    ->heap);
 	} else {
 		btr_search_sys_subtotal = 0;
-		for (i=0; i < btr_search_sys->hash_index->n_sync_obj; i++) {
+		for (i=0; i < btr_search_sys->hash_index[0]->n_sync_obj; i++) {
 			btr_search_sys_subtotal
 				+= mem_heap_get_size(
-					btr_search_sys->hash_index->heaps[i]);
+					btr_search_sys->hash_index[0]
+					->heaps[i]);
 		}
 	}
+	btr_search_sys_subtotal *= btr_search_index_num;
 
 	lock_sys_subtotal = 0;
 	if (trx_sys) {
@@ -1347,13 +1350,15 @@
 			"    Recovery system     %lu \t(%lu + " ULINTPF ")\n",
 
 			(ulong) (btr_search_sys
-				? (btr_search_sys->hash_index->n_cells
-				   * sizeof(hash_cell_t))
+				? (btr_search_sys->hash_index[0]->n_cells
+				   * sizeof(hash_cell_t)
+				   * btr_search_index_num)
 				 : 0)
 			+ btr_search_sys_subtotal,
 			(ulong) (btr_search_sys
-				? (btr_search_sys->hash_index->n_cells
-				   * sizeof(hash_cell_t))
+				? (btr_search_sys->hash_index[0]->n_cells
+				   * sizeof(hash_cell_t)
+				   * btr_search_index_num)
 				 : 0),
 			btr_search_sys_subtotal,
 
@@ -1504,21 +1509,23 @@
 	buf_get_total_list_len(&LRU_len, &free_len, &flush_list_len);
 	buf_get_total_list_size_in_bytes(&buf_pools_list_size);
 
-	if (btr_search_sys && btr_search_sys->hash_index->heap) {
+	if (btr_search_sys && btr_search_sys->hash_index[0]->heap) {
 		mem_adaptive_hash
-			= mem_heap_get_size(btr_search_sys->hash_index->heap);
+			= mem_heap_get_size(btr_search_sys
+					    ->hash_index[0]->heap);
 	} else {
 		mem_adaptive_hash = 0;
-		for (i=0; i < btr_search_sys->hash_index->n_sync_obj; i++) {
+		for (i=0; i < btr_search_sys->hash_index[0]->n_sync_obj; i++) {
 			mem_adaptive_hash
 				+= mem_heap_get_size
-				(btr_search_sys->hash_index->heaps[i]);
+				(btr_search_sys->hash_index[0]->heaps[i]);
 		}
 	}
 	if (btr_search_sys) {
-		mem_adaptive_hash += (btr_search_sys->hash_index->n_cells
+		mem_adaptive_hash += (btr_search_sys->hash_index[0]->n_cells
 				      * sizeof(hash_cell_t));
 	}
+	mem_adaptive_hash *= btr_search_index_num;
 
 	mem_dictionary = (dict_sys ? ((dict_sys->table_hash->n_cells
 					+ dict_sys->table_id_hash->n_cells

=== modified file 'Percona-Server/storage/innobase/sync/sync0sync.cc'
--- Percona-Server/storage/innobase/sync/sync0sync.cc	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/sync/sync0sync.cc	2013-08-28 08:09:39 +0000
@@ -38,6 +38,7 @@
 #include "sync0rw.h"
 #include "buf0buf.h"
 #include "srv0srv.h"
+#include "btr0types.h"
 #include "buf0types.h"
 #include "os0sync.h" /* for HAVE_ATOMIC_BUILTINS */
 #ifdef UNIV_SYNC_DEBUG
@@ -1149,7 +1150,6 @@
 	case SYNC_ANY_LATCH:
 	case SYNC_FILE_FORMAT_TAG:
 	case SYNC_DOUBLEWRITE:
-	case SYNC_SEARCH_SYS:
 	case SYNC_THREADS:
 	case SYNC_LOCK_SYS:
 	case SYNC_LOCK_WAIT_SYS:
@@ -1182,6 +1182,26 @@
 			ut_a(sync_thread_levels_contain(array, SYNC_LOCK_SYS));
 		}
 		break;
+	case SYNC_SEARCH_SYS: {
+		/* Verify the lock order inside the split btr_search_latch
+		array */
+		bool found_current = false;
+		for (ulint i = 0; i < btr_search_index_num; i++) {
+			if (btr_search_latch_temp_arr[i] == latch) {
+				found_current = true;
+			} else if (found_current) {
+				ut_ad(!rw_lock_own(
+					      btr_search_latch_temp_arr[i],
+					      RW_LOCK_SHARED));
+				ut_ad(!rw_lock_own(
+					      btr_search_latch_temp_arr[i],
+					      RW_LOCK_EX));
+			}
+		}
+		ut_ad(found_current);
+
+		/* fallthrough */
+	}
 	case SYNC_BUF_FLUSH_LIST:
 	case SYNC_BUF_POOL:
 		/* We can have multiple mutexes of this type therefore we

=== modified file 'Percona-Server/storage/innobase/trx/trx0trx.cc'
--- Percona-Server/storage/innobase/trx/trx0trx.cc	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/trx/trx0trx.cc	2013-08-28 08:09:39 +0000
@@ -23,6 +23,7 @@
 Created 3/26/1996 Heikki Tuuri
 *******************************************************/
 
+#include "btr0types.h"
 #include "trx0trx.h"
 
 #ifdef UNIV_NONINL

=== modified file 'Percona-Server/storage/innobase/ut/ut0ut.cc'
--- Percona-Server/storage/innobase/ut/ut0ut.cc	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/ut/ut0ut.cc	2013-08-28 08:09:39 +0000
@@ -39,6 +39,7 @@
 #include <ctype.h>
 
 #ifndef UNIV_HOTBACKUP
+# include "btr0types.h"
 # include "trx0trx.h"
 # include "ha_prototypes.h"
 # include "mysql_com.h" /* NAME_LEN */