Merge lp:~akopytov/percona-server/ahi-fixes-5.6 into lp:percona-server/5.6

[Alexey Kopytov]

Fixes for bug #1218321, bug #1218330 and bug #1218347.

http://jenkins.percona.com/view/PS%205.6/job/percona-server-5.6-param/246/

[Laurynas Biveinis (laurynas-biveinis)]

    - Same comments as for the 5.5 MP.
    - Diff line 182--185: missing arg comment, and, uhm, why add more
      "=====" ?
    - Diff line 385--391 drops MONITOR_INC call.

review: Needs Fixing

[Alexey Kopytov (akopytov)]

Hi Laurynas,

On Wed, 04 Sep 2013 15:00:11 -0000, Laurynas Biveinis wrote:
> Review: Needs Fixing
>
> - Same comments as for the 5.5 MP.
> - Diff line 182--185: missing arg comment, and, uhm, why add more
> "=====" ?

Oh noes :)

> - Diff line 385--391 drops MONITOR_INC call.
>

This is a good catch, will fix.

[Alexey Kopytov (akopytov)]

Hi Laurynas,

On Wed, 04 Sep 2013 15:00:11 -0000, Laurynas Biveinis wrote:
> Review: Needs Fixing
>
> - Same comments as for the 5.5 MP.
> - Diff line 182--185: missing arg comment, and, uhm, why add more
> "=====" ?

Actually, this is how the diff looks in my tree:

@@ -133,17 +130,17 @@
  void
  btr_search_check_free_space_in_heap(
  /*=====================================*/
- index_id_t key)
+ dict_index_t* index)

I.e. it doesn't touch the comment part. But will fix anyway.

[Alexey Kopytov (akopytov)]

Hi Laurynas,

On Wed, 04 Sep 2013 15:00:11 -0000, Laurynas Biveinis wrote:
> - Diff line 385--391 drops MONITOR_INC call.
>

Same here. It appears to be some bogus change. This is how rev. diff
looks in my tree:

  #ifdef UNIV_SYNC_DEBUG
- ut_ad(rw_lock_own(btr_search_get_latch(cursor->index->id), RW_LOCK_EX));
+ ut_ad(rw_lock_own(btr_search_get_latch(cursor->index),
+ RW_LOCK_EX));
  #endif /* UNIV_SYNC_DEBUG */

- ha_insert_for_fold(btr_search_get_hash_index(cursor->index->id), fold,
- block, rec);
+ ha_insert_for_fold(btr_search_get_hash_table(cursor->index),
+ fold, block, rec);
   }
  }

I.e. there was simply no MONITOR_INC call. Not sure whom to blame here,
bzr or LP diff viewer.

[Laurynas Biveinis (laurynas-biveinis)]

review: Approve

=== added file 'Percona-Server/mysql-test/r/percona_bug1218330.result'
--- Percona-Server/mysql-test/r/percona_bug1218330.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/r/percona_bug1218330.result	2013-09-02 14:08:46 +0000
@@ -0,0 +1,14 @@
+CREATE TABLE t1 (
+a INT PRIMARY KEY, b INT,
+c CHAR(200),
+UNIQUE INDEX b(b)) ENGINE=InnoDB;
+INSERT INTO t1 VALUES (1, 1, REPEAT("a", 200));
+should_be_1
+1
+should_be_1
+1
+should_be_1
+1
+should_be_1
+1
+DROP TABLE t1;

=== added file 'Percona-Server/mysql-test/t/percona_bug1218330-master.opt'
--- Percona-Server/mysql-test/t/percona_bug1218330-master.opt	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/t/percona_bug1218330-master.opt	2013-09-02 14:08:46 +0000
@@ -0,0 +1,1 @@
+--innodb-adaptive-hash-index-partitions=32

=== added file 'Percona-Server/mysql-test/t/percona_bug1218330.test'
--- Percona-Server/mysql-test/t/percona_bug1218330.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/t/percona_bug1218330.test	2013-09-02 14:08:46 +0000
@@ -0,0 +1,72 @@
+############################################################################
+# Bug #1218330: Adaptive hash index memory is incorrectly calculated in SHOW
+#               ENGINE INNODB STATUS and I_S
+############################################################################
+
+--source include/have_innodb.inc
+
+let $adaptive_hash_mem_1=`SELECT VARIABLE_VALUE FROM
+    INFORMATION_SCHEMA.GLOBAL_STATUS WHERE
+    VARIABLE_NAME='Innodb_mem_adaptive_hash'`;
+
+let $is_adaptive_hash_mem_constant_1=`SELECT CONSTANT_MEMORY FROM
+    INFORMATION_SCHEMA.XTRADB_INTERNAL_HASH_TABLES WHERE
+    INTERNAL_HASH_TABLE_NAME='Adaptive hash index'`;
+
+let $is_adaptive_hash_mem_variable_1=`SELECT VARIABLE_MEMORY FROM
+    INFORMATION_SCHEMA.XTRADB_INTERNAL_HASH_TABLES WHERE
+    INTERNAL_HASH_TABLE_NAME='Adaptive hash index'`;
+    
+let $is_adaptive_hash_mem_total_1=`SELECT TOTAL_MEMORY FROM
+    INFORMATION_SCHEMA.XTRADB_INTERNAL_HASH_TABLES WHERE
+    INTERNAL_HASH_TABLE_NAME='Adaptive hash index'`;
+   
+CREATE TABLE t1 (
+       a INT PRIMARY KEY, b INT,
+       c CHAR(200),
+       UNIQUE INDEX b(b)) ENGINE=InnoDB;
+
+INSERT INTO t1 VALUES (1, 1, REPEAT("a", 200));
+
+--disable_query_log
+
+--let $i=200
+--disable_result_log
+while ($i)
+{
+        SELECT a FROM t1 WHERE a=1;
+        SELECT b FROM t1 WHERE b=1;
+        --dec $i
+}
+--enable_result_log
+
+let $adaptive_hash_mem_2=`SELECT VARIABLE_VALUE FROM
+    INFORMATION_SCHEMA.GLOBAL_STATUS WHERE
+    VARIABLE_NAME='Innodb_mem_adaptive_hash'`;
+
+let $is_adaptive_hash_mem_constant_2=`SELECT CONSTANT_MEMORY FROM
+    INFORMATION_SCHEMA.XTRADB_INTERNAL_HASH_TABLES WHERE
+    INTERNAL_HASH_TABLE_NAME='Adaptive hash index'`;
+
+let $is_adaptive_hash_mem_variable_2=`SELECT VARIABLE_MEMORY FROM
+    INFORMATION_SCHEMA.XTRADB_INTERNAL_HASH_TABLES WHERE
+    INTERNAL_HASH_TABLE_NAME='Adaptive hash index'`;
+    
+let $is_adaptive_hash_mem_total_2=`SELECT TOTAL_MEMORY FROM
+    INFORMATION_SCHEMA.XTRADB_INTERNAL_HASH_TABLES WHERE
+    INTERNAL_HASH_TABLE_NAME='Adaptive hash index'`;
+
+# The original implementation would should identical values in
+# adaptive_hash_mem_1 and adaptive_hash_mem_2
+
+--eval SELECT $adaptive_hash_mem_1 != $adaptive_hash_mem_2 as should_be_1
+
+# Should show identical constant, but different variable parts
+
+--eval SELECT $is_adaptive_hash_mem_total_1 != $is_adaptive_hash_mem_total_2 as should_be_1
+--eval SELECT $is_adaptive_hash_mem_constant_1 = $is_adaptive_hash_mem_constant_2 as should_be_1
+--eval SELECT $is_adaptive_hash_mem_variable_1 != $is_adaptive_hash_mem_variable_2 as should_be_1
+
+--enable_query_log
+
+DROP TABLE t1;

=== modified file 'Percona-Server/storage/innobase/btr/btr0cur.cc'
--- Percona-Server/storage/innobase/btr/btr0cur.cc	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/btr/btr0cur.cc	2013-09-02 14:08:46 +0000
@@ -535,9 +535,9 @@
 
 # ifdef UNIV_SEARCH_PERF_STAT
 	info->n_searches++;
-# endif
-	if ((rw_lock_get_writer(btr_search_get_latch(cursor->index->id))
-	     == RW_LOCK_NOT_LOCKED)
+#endif
+	if (rw_lock_get_writer(btr_search_get_latch(cursor->index)) ==
+	    RW_LOCK_NOT_LOCKED
 	    && latch_mode <= BTR_MODIFY_LEAF
 	    && info->last_hash_succ
 	    && !estimate
@@ -573,7 +573,7 @@
 
 	if (has_search_latch) {
 		/* Release possible search latch to obey latching order */
-		rw_lock_s_unlock(btr_search_get_latch(cursor->index->id));
+		rw_lock_s_unlock(btr_search_get_latch(cursor->index));
 	}
 
 	/* Store the position of the tree latch we push to mtr so that we
@@ -896,7 +896,7 @@
 
 	if (has_search_latch) {
 
-		rw_lock_s_lock(btr_search_get_latch(cursor->index->id));
+		rw_lock_s_lock(btr_search_get_latch(cursor->index));
 	}
 }
 
@@ -2163,13 +2163,13 @@
 			btr_search_update_hash_on_delete(cursor);
 		}
 
-		rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
+		rw_lock_x_lock(btr_search_get_latch(cursor->index));
 	}
 
 	row_upd_rec_in_place(rec, index, offsets, update, page_zip);
 
 	if (is_hashed) {
-		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+		rw_lock_x_unlock(btr_search_get_latch(cursor->index));
 	}
 
 	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-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/btr/btr0sea.cc	2013-09-02 14:08:46 +0000
@@ -65,15 +65,14 @@
 cache line as btr_search_latch */
 UNIV_INTERN byte		btr_sea_pad1[64];
 
-/** The latch protecting the adaptive search system: this latch protects the
-(1) positions of records on those pages where a hash index has been built.
-NOTE: It does not protect values of non-ordering fields within a record from
+/** Array of latches protecting individual AHI partitions. The latches
+protect: (1) positions of records on those pages where a hash index from the
+corresponding AHI partition has been built.
+NOTE: They do not protect values of non-ordering fields within a record from
 being updated in-place! We can use fact (1) to perform unique searches to
 indexes. */
 
-/* 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_arr;
+UNIV_INTERN rw_lock_t*		btr_search_latch_arr;
 
 /** padding to prevent other memory update hotspots from residing on
 the same memory cache line */
@@ -126,18 +125,18 @@
 static
 void
 btr_search_check_free_space_in_heap(
-/*================================*/
-	index_id_t	key)	/*!<in: id of the hashed index tree */
+/*=====================================*/
+	dict_index_t*	index)
 {
 	hash_table_t*	table;
 	mem_heap_t*	heap;
 
 #ifdef UNIV_SYNC_DEBUG
-	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));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	table = btr_search_get_hash_index(key);
+	table = btr_search_get_hash_table(index);
 
 	heap = table->heap;
 
@@ -148,7 +147,7 @@
 	if (heap->free_block == NULL) {
 		buf_block_t*	block = buf_block_alloc(NULL);
 
-		rw_lock_x_lock(btr_search_get_latch(key));
+		rw_lock_x_lock(btr_search_get_latch(index));
 
 		if (heap->free_block == NULL) {
 			heap->free_block = block;
@@ -156,7 +155,7 @@
 			buf_block_free(block);
 		}
 
-		rw_lock_x_unlock(btr_search_get_latch(key));
+		rw_lock_x_unlock(btr_search_get_latch(index));
 	}
 }
 
@@ -182,31 +181,28 @@
 	/* We allocate the search latch from dynamic memory:
 	see above at the global variable definition */
 
-	/* btr_search_index_num should be no greater than bits of
-	trx->has_search_latch, which is ulint. */
-	ut_ad(btr_search_index_num <= sizeof(ulint));
+	/* btr_search_index_num is constrained to machine word size for
+	historical reasons. This limitation can be easily removed later. */
 
-	btr_search_latch_arr = (rw_lock_t**)
-		mem_alloc(sizeof(rw_lock_t *) * btr_search_index_num);
+	btr_search_latch_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 = (hash_table_t **)
+	btr_search_sys->hash_tables = (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_arr[i] = (rw_lock_t *)
-			mem_alloc(sizeof(rw_lock_t));
-
-		rw_lock_create(btr_search_latch_key, btr_search_latch_arr[i],
-			       SYNC_SEARCH_SYS);
-
-		btr_search_sys->hash_index[i]
+
+		rw_lock_create(btr_search_latch_key,
+				&btr_search_latch_arr[i], SYNC_SEARCH_SYS);
+
+		btr_search_sys->hash_tables[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[i]->adaptive = TRUE;
+		btr_search_sys->hash_tables[i]->adaptive = TRUE;
 #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
 	}
 }
@@ -222,20 +218,18 @@
 
 	for (i = 0; i < btr_search_index_num; i++) {
 
-		rw_lock_free(btr_search_latch_arr[i]);
-
-		mem_free(btr_search_latch_arr[i]);
-
-		mem_heap_free(btr_search_sys->hash_index[i]->heap);
-
-		hash_table_free(btr_search_sys->hash_index[i]);
+		rw_lock_free(&btr_search_latch_arr[i]);
+
+		mem_heap_free(btr_search_sys->hash_tables[i]->heap);
+
+		hash_table_free(btr_search_sys->hash_tables[i]);
 
 	}
 
 	mem_free(btr_search_latch_arr);
 	btr_search_latch_arr = NULL;
 
-	mem_free(btr_search_sys->hash_index);
+	mem_free(btr_search_sys->hash_tables);
 
 	mem_free(btr_search_sys);
 	btr_search_sys = NULL;
@@ -257,7 +251,7 @@
 	     index = dict_table_get_next_index(index)) {
 
 #ifdef UNIV_SYNC_DEBUG
-		ut_ad(rw_lock_own(btr_search_get_latch(index->id),
+		ut_ad(rw_lock_own(btr_search_get_latch(index),
 				  RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 		index->search_info->ref_count = 0;
@@ -300,8 +294,8 @@
 
 	/* Clear the adaptive hash index. */
 	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);
+		hash_table_clear(btr_search_sys->hash_tables[i]);
+		mem_heap_empty(btr_search_sys->hash_tables[i]->heap);
 	}
 
 	btr_search_x_unlock_all();
@@ -364,27 +358,27 @@
 
 /*****************************************************************//**
 Returns the value of ref_count. The value is protected by
-btr_search_latch.
+the .
 @return	ref_count value. */
 UNIV_INTERN
 ulint
 btr_search_info_get_ref_count(
 /*==========================*/
 	btr_search_t*   info,	/*!< in: search info. */
-	index_id_t	key)	/*!< in: id of the index owning search info */
+	dict_index_t*	index)	/*!< in: index */
 {
 	ulint ret;
 
 	ut_ad(info);
 
 #ifdef UNIV_SYNC_DEBUG
-	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));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	rw_lock_s_lock(btr_search_get_latch(key));
+	rw_lock_s_lock(btr_search_get_latch(index));
 	ret = info->ref_count;
-	rw_lock_s_unlock(btr_search_get_latch(key));
+	rw_lock_s_unlock(btr_search_get_latch(index));
 
 	return(ret);
 }
@@ -405,8 +399,8 @@
 	int		cmp;
 
 #ifdef UNIV_SYNC_DEBUG
-	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));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
 	if (dict_index_is_ibuf(index)) {
@@ -522,9 +516,9 @@
 				/*!< in: cursor */
 {
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id),
+	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index),
 			   RW_LOCK_SHARED));
-	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id),
+	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index),
 			   RW_LOCK_EX));
 	ut_ad(rw_lock_own(&block->lock, RW_LOCK_SHARED)
 	      || rw_lock_own(&block->lock, RW_LOCK_EX));
@@ -609,7 +603,7 @@
 
 	ut_ad(cursor->flag == BTR_CUR_HASH_FAIL);
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(rw_lock_own(btr_search_get_latch(cursor->index->id),
+	ut_ad(rw_lock_own(btr_search_get_latch(cursor->index),
 			  RW_LOCK_EX));
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
 	      || rw_lock_own(&(block->lock), RW_LOCK_EX));
@@ -651,15 +645,12 @@
 			mem_heap_free(heap);
 		}
 #ifdef UNIV_SYNC_DEBUG
-		ut_ad(rw_lock_own(btr_search_get_latch(cursor->index->id),
+		ut_ad(rw_lock_own(btr_search_get_latch(cursor->index),
 				  RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-		ha_insert_for_fold(
-			btr_search_get_hash_index(cursor->index->id), fold,
-			block, rec);
-
-		MONITOR_INC(MONITOR_ADAPTIVE_HASH_ROW_ADDED);
+		ha_insert_for_fold(btr_search_get_hash_table(cursor->index),
+				   fold, block, rec);
 	}
 }
 
@@ -678,9 +669,9 @@
 	ulint*		params2;
 
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id),
+	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index),
 			   RW_LOCK_SHARED));
-	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index->id),
+	ut_ad(!rw_lock_own(btr_search_get_latch(cursor->index),
 			   RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
@@ -699,7 +690,7 @@
 
 	if (build_index || (cursor->flag == BTR_CUR_HASH_FAIL)) {
 
-		btr_search_check_free_space_in_heap(cursor->index->id);
+		btr_search_check_free_space_in_heap(cursor->index);
 	}
 
 	if (cursor->flag == BTR_CUR_HASH_FAIL) {
@@ -709,11 +700,11 @@
 		btr_search_n_hash_fail++;
 #endif /* UNIV_SEARCH_PERF_STAT */
 
-		rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
+		rw_lock_x_lock(btr_search_get_latch(cursor->index));
 
 		btr_search_update_hash_ref(info, block, cursor);
 
-		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+		rw_lock_x_unlock(btr_search_get_latch(cursor->index));
 	}
 
 	if (build_index) {
@@ -958,19 +949,18 @@
 	cursor->flag = BTR_CUR_HASH;
 
 	if (UNIV_LIKELY(!has_search_latch)) {
-		rw_lock_s_lock(btr_search_get_latch(index_id));
+		rw_lock_s_lock(btr_search_get_latch(index));
 
 		if (UNIV_UNLIKELY(!btr_search_enabled)) {
 			goto failure_unlock;
 		}
 	}
 
-	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);
+	ut_ad(rw_lock_get_writer(btr_search_get_latch(index)) != RW_LOCK_EX);
+	ut_ad(rw_lock_get_reader_count(btr_search_get_latch(index)) > 0);
 
 	rec = (rec_t*) ha_search_and_get_data(
-		btr_search_get_hash_index(index_id), fold);
+		btr_search_get_hash_table(index), fold);
 
 	if (UNIV_UNLIKELY(!rec)) {
 		goto failure_unlock;
@@ -988,7 +978,7 @@
 			goto failure_unlock;
 		}
 
-		rw_lock_s_unlock(btr_search_get_latch(index_id));
+		rw_lock_s_unlock(btr_search_get_latch(index));
 
 		buf_block_dbg_add_level(block, SYNC_TREE_NODE_FROM_HASH);
 	}
@@ -1085,7 +1075,7 @@
 	/*-------------------------------------------*/
 failure_unlock:
 	if (UNIV_LIKELY(!has_search_latch)) {
-		rw_lock_s_unlock(btr_search_get_latch(index_id));
+		rw_lock_s_unlock(btr_search_get_latch(index));
 	}
 failure:
 	cursor->flag = BTR_CUR_HASH_FAIL;
@@ -1133,41 +1123,31 @@
 	const dict_index_t*	index;
 	ulint*			offsets;
 	btr_search_t*		info;
-	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. */
-	if (!block->index) {
-		return;
-	}
-
-	btr_search_latch = block->btr_search_latch;
-
-	if (UNIV_UNLIKELY(!btr_search_latch)) {
+	/* Do a dirty check on block->index, return if the block is not in the
+	adaptive hash index. This is to avoid acquiring an AHI latch for
+	performance considerations. */
+
+	index = block->index;
+	if (!index) {
+
 		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));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), 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);
+	rw_lock_s_lock(btr_search_get_latch(index));
+
+	if (UNIV_UNLIKELY(index != block->index)) {
+
+		rw_lock_s_unlock(btr_search_get_latch(index));
+
 		goto retry;
 	}
 
-	index = block->index;
-	if (UNIV_UNLIKELY(!index)) {
-		rw_lock_s_unlock(btr_search_latch);
-		return;
-	}
-
-	ut_ad(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)) {
@@ -1190,7 +1170,7 @@
 	}
 #endif /* UNIV_DEBUG */
 
-	table = btr_search_get_hash_index(index->id);
+	table = btr_search_get_hash_table(index);
 
 #ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
@@ -1206,7 +1186,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_get_latch(index));
 
 	ut_a(n_fields + n_bytes > 0);
 
@@ -1257,7 +1237,7 @@
 		mem_heap_free(heap);
 	}
 
-	rw_lock_x_lock(btr_search_get_latch(index->id));
+	rw_lock_x_lock(btr_search_get_latch(index));
 
 	if (UNIV_UNLIKELY(!block->index)) {
 		/* Someone else has meanwhile dropped the hash index */
@@ -1273,7 +1253,7 @@
 		/* Someone else has meanwhile built a new hash index on the
 		page, with different parameters */
 
-		rw_lock_x_unlock(btr_search_get_latch(index->id));
+		rw_lock_x_unlock(btr_search_get_latch(index));
 
 		mem_free(folds);
 		goto retry;
@@ -1289,7 +1269,6 @@
 	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);
@@ -1305,14 +1284,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_get_latch(index->id));
+		rw_lock_x_unlock(btr_search_get_latch(index));
 
 		ut_ad(btr_search_validate());
 	} else {
-		rw_lock_x_unlock(btr_search_get_latch(index->id));
+		rw_lock_x_unlock(btr_search_get_latch(index));
 	}
 #else /* UNIV_AHI_DEBUG || UNIV_DEBUG */
-	rw_lock_x_unlock(btr_search_get_latch(index->id));
+	rw_lock_x_unlock(btr_search_get_latch(index));
 #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
 
 	mem_free(folds);
@@ -1391,30 +1370,30 @@
 	ut_a(!dict_index_is_ibuf(index));
 
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad(!rw_lock_own(btr_search_get_latch(index->id), RW_LOCK_EX));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), 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_get_latch(index->id));
+	rw_lock_s_lock(btr_search_get_latch(index));
 
 	if (!btr_search_enabled) {
-		rw_lock_s_unlock(btr_search_get_latch(index->id));
+		rw_lock_s_unlock(btr_search_get_latch(index));
 		return;
 	}
 
-	table = btr_search_get_hash_index(index->id);
+	table = btr_search_get_hash_table(index);
 	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_get_latch(index->id));
+		rw_lock_s_unlock(btr_search_get_latch(index));
 
 		btr_search_drop_page_hash_index(block);
 	} else {
-		rw_lock_s_unlock(btr_search_get_latch(index->id));
+		rw_lock_s_unlock(btr_search_get_latch(index));
 	}
 
 	n_recs = page_get_n_recs(page);
@@ -1508,9 +1487,9 @@
 		fold = next_fold;
 	}
 
-	btr_search_check_free_space_in_heap(index->id);
+	btr_search_check_free_space_in_heap(index);
 
-	rw_lock_x_lock(btr_search_get_latch(index->id));
+	rw_lock_x_lock(btr_search_get_latch(index));
 
 	if (UNIV_UNLIKELY(!btr_search_enabled)) {
 		goto exit_func;
@@ -1537,7 +1516,6 @@
 	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++) {
 
@@ -1547,7 +1525,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_get_latch(index->id));
+	rw_lock_x_unlock(btr_search_get_latch(index));
 
 	mem_free(folds);
 	mem_free(recs);
@@ -1582,7 +1560,7 @@
 	ut_ad(rw_lock_own(&(new_block->lock), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	rw_lock_s_lock(btr_search_get_latch(index->id));
+	rw_lock_s_lock(btr_search_get_latch(index));
 
 	ut_a(!new_block->index || new_block->index == index);
 	ut_a(!block->index || block->index == index);
@@ -1591,7 +1569,7 @@
 
 	if (new_block->index) {
 
-		rw_lock_s_unlock(btr_search_get_latch(index->id));
+		rw_lock_s_unlock(btr_search_get_latch(index));
 
 		btr_search_drop_page_hash_index(block);
 
@@ -1608,7 +1586,7 @@
 		new_block->n_bytes = block->curr_n_bytes;
 		new_block->left_side = left_side;
 
-		rw_lock_s_unlock(btr_search_get_latch(index->id));
+		rw_lock_s_unlock(btr_search_get_latch(index));
 
 		ut_a(n_fields + n_bytes > 0);
 
@@ -1620,7 +1598,7 @@
 		return;
 	}
 
-	rw_lock_s_unlock(btr_search_get_latch(index->id));
+	rw_lock_s_unlock(btr_search_get_latch(index));
 }
 
 /********************************************************************//**
@@ -1659,7 +1637,7 @@
 	ut_a(block->curr_n_fields + block->curr_n_bytes > 0);
 	ut_a(!dict_index_is_ibuf(index));
 
-	table = btr_search_get_hash_index(cursor->index->id);
+	table = btr_search_get_hash_table(cursor->index);
 
 	rec = btr_cur_get_rec(cursor);
 
@@ -1670,7 +1648,7 @@
 		mem_heap_free(heap);
 	}
 
-	rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
+	rw_lock_x_lock(btr_search_get_latch(cursor->index));
 
 	if (block->index) {
 		ut_a(block->index == index);
@@ -1683,7 +1661,7 @@
 		}
 	}
 
-	rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+	rw_lock_x_unlock(btr_search_get_latch(cursor->index));
 }
 
 /********************************************************************//**
@@ -1720,7 +1698,7 @@
 	ut_a(cursor->index == index);
 	ut_a(!dict_index_is_ibuf(index));
 
-	rw_lock_x_lock(btr_search_get_latch(cursor->index->id));
+	rw_lock_x_lock(btr_search_get_latch(cursor->index));
 
 	if (!block->index) {
 
@@ -1734,7 +1712,7 @@
 	    && (cursor->n_bytes == block->curr_n_bytes)
 	    && !block->curr_left_side) {
 
-		table = btr_search_get_hash_index(cursor->index->id);
+		table = btr_search_get_hash_table(cursor->index);
 
 		if (ha_search_and_update_if_found(
 			table, cursor->fold, rec, block,
@@ -1743,9 +1721,9 @@
 		}
 
 func_exit:
-		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+		rw_lock_x_unlock(btr_search_get_latch(cursor->index));
 	} else {
-		rw_lock_x_unlock(btr_search_get_latch(cursor->index->id));
+		rw_lock_x_unlock(btr_search_get_latch(cursor->index));
 
 		btr_search_update_hash_on_insert(cursor);
 	}
@@ -1793,9 +1771,9 @@
 		return;
 	}
 
-	btr_search_check_free_space_in_heap(cursor->index->id);
+	btr_search_check_free_space_in_heap(cursor->index);
 
-	table = btr_search_get_hash_index(cursor->index->id);
+	table = btr_search_get_hash_table(cursor->index);
 
 	rec = btr_cur_get_rec(cursor);
 
@@ -1827,7 +1805,7 @@
 	} else {
 		if (left_side) {
 
-			rw_lock_x_lock(btr_search_get_latch(index->id));
+			rw_lock_x_lock(btr_search_get_latch(index));
 
 			locked = TRUE;
 
@@ -1845,7 +1823,7 @@
 
 		if (!locked) {
 
-			rw_lock_x_lock(btr_search_get_latch(index->id));
+			rw_lock_x_lock(btr_search_get_latch(index));
 
 			locked = TRUE;
 
@@ -1867,8 +1845,7 @@
 		if (!left_side) {
 
 			if (!locked) {
-				rw_lock_x_lock(btr_search_get_latch(
-						   index->id));
+				rw_lock_x_lock(btr_search_get_latch(index));
 
 				locked = TRUE;
 
@@ -1887,7 +1864,7 @@
 
 		if (!locked) {
 
-			rw_lock_x_lock(btr_search_get_latch(index->id));
+			rw_lock_x_lock(btr_search_get_latch(index));
 
 			locked = TRUE;
 
@@ -1914,7 +1891,7 @@
 		mem_heap_free(heap);
 	}
 	if (locked) {
-		rw_lock_x_unlock(btr_search_get_latch(index->id));
+		rw_lock_x_unlock(btr_search_get_latch(index));
 	}
 }
 
@@ -1945,7 +1922,7 @@
 
 	buf_pool_mutex_enter_all();
 
-	cell_count = hash_get_n_cells(btr_search_sys->hash_index[t]);
+	cell_count = hash_get_n_cells(btr_search_sys->hash_tables[t]);
 
 	for (i = 0; i < cell_count; i++) {
 		/* We release btr_search_latch every once in a while to
@@ -1959,7 +1936,7 @@
 		}
 
 		node = (ha_node_t*)
-			hash_get_nth_cell(btr_search_sys->hash_index[t],
+			hash_get_nth_cell(btr_search_sys->hash_tables[t],
 					  i)->node;
 
 		for (; node != NULL; node = node->next) {
@@ -2075,7 +2052,7 @@
 			buf_pool_mutex_enter_all();
 		}
 
-		if (!ha_validate(btr_search_sys->hash_index[t], i,
+		if (!ha_validate(btr_search_sys->hash_tables[t], i,
 				 end_index)) {
 			ok = FALSE;
 		}

=== modified file 'Percona-Server/storage/innobase/buf/buf0buf.cc'
--- Percona-Server/storage/innobase/buf/buf0buf.cc	2013-08-29 17:46:30 +0000
+++ Percona-Server/storage/innobase/buf/buf0buf.cc	2013-09-02 14:08:46 +0000
@@ -1013,7 +1013,6 @@
 
 	block->check_index_page_at_flush = FALSE;
 	block->index = NULL;
-	block->btr_search_latch = NULL;
 
 #ifdef UNIV_DEBUG
 	block->page.in_page_hash = FALSE;
@@ -2209,7 +2208,6 @@
 {
 	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/dict0boot.cc'
--- Percona-Server/storage/innobase/dict/dict0boot.cc	2013-08-06 15:16:34 +0000
+++ Percona-Server/storage/innobase/dict/dict0boot.cc	2013-09-02 14:08:46 +0000
@@ -31,6 +31,7 @@
 
 #include "dict0crea.h"
 #include "btr0btr.h"
+#include "btr0sea.h"
 #include "dict0load.h"
 #include "trx0trx.h"
 #include "srv0srv.h"
@@ -331,6 +332,7 @@
 	dict_mem_index_add_field(index, "NAME", 0);
 
 	index->id = DICT_TABLES_ID;
+	btr_search_index_init(index);
 
 	error = dict_index_add_to_cache(table, index,
 					mtr_read_ulint(dict_hdr
@@ -345,6 +347,7 @@
 	dict_mem_index_add_field(index, "ID", 0);
 
 	index->id = DICT_TABLE_IDS_ID;
+	btr_search_index_init(index);
 	error = dict_index_add_to_cache(table, index,
 					mtr_read_ulint(dict_hdr
 						       + DICT_HDR_TABLE_IDS,
@@ -377,6 +380,7 @@
 	dict_mem_index_add_field(index, "POS", 0);
 
 	index->id = DICT_COLUMNS_ID;
+	btr_search_index_init(index);
 	error = dict_index_add_to_cache(table, index,
 					mtr_read_ulint(dict_hdr
 						       + DICT_HDR_COLUMNS,
@@ -409,6 +413,7 @@
 	dict_mem_index_add_field(index, "ID", 0);
 
 	index->id = DICT_INDEXES_ID;
+	btr_search_index_init(index);
 	error = dict_index_add_to_cache(table, index,
 					mtr_read_ulint(dict_hdr
 						       + DICT_HDR_INDEXES,
@@ -437,6 +442,7 @@
 	dict_mem_index_add_field(index, "POS", 0);
 
 	index->id = DICT_FIELDS_ID;
+	btr_search_index_init(index);
 	error = dict_index_add_to_cache(table, index,
 					mtr_read_ulint(dict_hdr
 						       + DICT_HDR_FIELDS,

=== modified file 'Percona-Server/storage/innobase/dict/dict0dict.cc'
--- Percona-Server/storage/innobase/dict/dict0dict.cc	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/dict/dict0dict.cc	2013-09-02 14:08:46 +0000
@@ -1208,8 +1208,7 @@
 
 			See also: dict_index_remove_from_cache_low() */
 
-			if (btr_search_info_get_ref_count(info, index->id)
-			    > 0) {
+			if (btr_search_info_get_ref_count(info, index) > 0) {
 				return(FALSE);
 			}
 		}
@@ -2485,7 +2484,7 @@
 
 	do {
 		ulint ref_count = btr_search_info_get_ref_count(info,
-								index->id);
+								index);
 
 		if (ref_count == 0) {
 			break;
@@ -2777,6 +2776,7 @@
 	new_index->n_user_defined_cols = index->n_fields;
 
 	new_index->id = index->id;
+	btr_search_index_init(new_index);
 
 	/* Copy the fields of index */
 	dict_index_copy(new_index, index, table, 0, index->n_fields);
@@ -2948,6 +2948,7 @@
 	new_index->n_user_defined_cols = index->n_fields;
 
 	new_index->id = index->id;
+	btr_search_index_init(new_index);
 
 	/* Copy fields from index to new_index */
 	dict_index_copy(new_index, index, table, 0, index->n_fields);
@@ -3031,6 +3032,7 @@
 	new_index->n_user_defined_cols = index->n_fields;
 
 	new_index->id = index->id;
+	btr_search_index_init(new_index);
 
 	/* Copy fields from index to new_index */
 	dict_index_copy(new_index, index, table, 0, index->n_fields);

=== modified file 'Percona-Server/storage/innobase/dict/dict0load.cc'
--- Percona-Server/storage/innobase/dict/dict0load.cc	2013-08-14 03:57:21 +0000
+++ Percona-Server/storage/innobase/dict/dict0load.cc	2013-09-02 14:08:46 +0000
@@ -1748,6 +1748,7 @@
 
 	(*index)->id = id;
 	(*index)->page = mach_read_from_4(field);
+	btr_search_index_init(*index);
 	ut_ad((*index)->page);
 
 	return(NULL);

=== modified file 'Percona-Server/storage/innobase/ha/ha0ha.cc'
--- Percona-Server/storage/innobase/ha/ha0ha.cc	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/ha/ha0ha.cc	2013-09-02 14:08:46 +0000
@@ -113,13 +113,13 @@
 	ut_ad(table->adaptive);
 
 	for (i = 0; i < btr_search_index_num; i++) {
-		if (btr_search_sys->hash_index[i] == table) {
+		if (btr_search_sys->hash_tables[i] == table) {
 			break;
 		}
 	}
 
 	ut_ad(i < btr_search_index_num);
-	ut_ad(rw_lock_own(btr_search_latch_arr[i], RW_LOCK_EX));
+	ut_ad(rw_lock_own(&btr_search_latch_arr[i], RW_LOCK_EX));
 
 	return(true);
 }

=== modified file 'Percona-Server/storage/innobase/handler/ha_innodb.cc'
--- Percona-Server/storage/innobase/handler/ha_innodb.cc	2013-08-29 17:46:30 +0000
+++ Percona-Server/storage/innobase/handler/ha_innodb.cc	2013-09-02 14:08:46 +0000
@@ -1473,20 +1473,21 @@
 }
 
 /********************************************************************//**
-Call this function when mysqld passes control to the client. That is to
-avoid deadlocks on the adaptive hash S-latch possibly held by thd. For more
-documentation, see handler.cc.
-@return	0 */
+In XtraDB it is impossible for a transaction to own a search latch outside of
+InnoDB code, so there is nothing to release on demand.  We keep this function to
+simplify maintenance.
+@return 0 */
 static
 int
 innobase_release_temporary_latches(
 /*===============================*/
-	handlerton*	hton,	/*!< in: handlerton */
-	THD*		thd)	/*!< in: MySQL thread */
+	handlerton*	hton __attribute__((unused)),	/*!< in: handlerton */
+	THD*		thd __attribute__((unused)))	/*!< in: MySQL thread */
 {
+#ifdef UNIV_DEBUG
 	DBUG_ASSERT(hton == innodb_hton_ptr);
 
-	if (!innodb_inited) {
+	if (!innodb_inited || thd == NULL) {
 
 		return(0);
 	}
@@ -1494,8 +1495,12 @@
 	trx_t*	trx = thd_to_trx(thd);
 
 	if (trx != NULL) {
+#ifdef UNIV_SYNC_DEBUG
+		ut_ad(!btr_search_own_any());
+#endif
 		trx_search_latch_release_if_reserved(trx);
 	}
+#endif
 
 	return(0);
 }
@@ -3772,9 +3777,8 @@
 	/* Since we will reserve the trx_sys->mutex, we have to release
 	the search system latch first to obey the latching order. */
 
-	if (trx->has_search_latch) {
-		trx_search_latch_release_if_reserved(trx);
-	}
+	/* No-op in XtraDB */
+	trx_search_latch_release_if_reserved(trx);
 
 	if (trx->fake_changes &&
 	    (commit_trx ||
@@ -4972,12 +4976,8 @@
 
 	thd = ha_thd();
 
-	/* Under some cases MySQL seems to call this function while
-	holding btr_search_latch. This breaks the latching order as
-	we acquire dict_sys->mutex below and leads to a deadlock. */
-	if (thd != NULL) {
-		innobase_release_temporary_latches(ht, thd);
-	}
+	/* No-op in XtraDB */
+	innobase_release_temporary_latches(ht, thd);
 
 	normalize_table_name(norm_name, name);
 
@@ -5398,9 +5398,9 @@
 	DBUG_ENTER("ha_innobase::close");
 
 	thd = ha_thd();
-	if (thd != NULL) {
-		innobase_release_temporary_latches(ht, thd);
-	}
+
+	/* No-op in XtraDB */
+	innobase_release_temporary_latches(ht, thd);
 
 	row_prebuilt_free(prebuilt, FALSE);
 
@@ -16398,6 +16398,8 @@
   "Disable with --skip-innodb-adaptive-hash-index.",
   NULL, innodb_adaptive_hash_index_update, TRUE);
 
+/* btr_search_index_num is constrained to machine word size for historical
+reasons. This limitation can be easily removed later. */
 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 "

=== modified file 'Percona-Server/storage/innobase/handler/xtradb_i_s.cc'
--- Percona-Server/storage/innobase/handler/xtradb_i_s.cc	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/handler/xtradb_i_s.cc	2013-09-02 14:08:46 +0000
@@ -309,9 +309,11 @@
 
 static int xtradb_internal_hash_tables_fill_table(THD* thd, TABLE_LIST* tables, Item*)
 {
-	const char*		table_name;
-	Field**	fields;
-	TABLE* table;
+	const char*	table_name;
+	Field**		fields;
+	TABLE*		table;
+	ulong		btr_search_sys_constant;
+	ulong		btr_search_sys_variable;
 
 	DBUG_ENTER("xtradb_internal_hash_tables_fill_table");
 
@@ -327,38 +329,38 @@
 
 	RETURN_IF_INNODB_NOT_STARTED(table_name);
 
-	if (btr_search_sys)
-	{
-		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));
+	/* Calculate AHI constant and variable memory allocations */
+
+	btr_search_sys_constant = 0;
+	btr_search_sys_variable = 0;
+
+	ut_ad(btr_search_sys->hash_tables);
+
+	for (ulint i = 0; i < btr_search_index_num; i++) {
+		hash_table_t* ht = btr_search_sys->hash_tables[i];
+
+		ut_ad(ht);
+		ut_ad(ht->heap);
+
+		/* Multiple mutexes/heaps are currently never used for adaptive
+		hash index tables. */
+		ut_ad(!ht->n_sync_obj);
+		ut_ad(!ht->heaps);
+
+		btr_search_sys_variable += mem_heap_get_size(ht->heap);
+		btr_search_sys_constant += ht->n_cells * sizeof(hash_cell_t);
 	}
 
+	OK(field_store_string(fields[INT_HASH_TABLES_NAME],
+			      "Adaptive hash index"));
+	OK(field_store_ulint(fields[INT_HASH_TABLES_TOTAL],
+			     btr_search_sys_variable + btr_search_sys_constant));
+	OK(field_store_ulint(fields[INT_HASH_TABLES_CONSTANT],
+			     btr_search_sys_constant));
+	OK(field_store_ulint(fields[INT_HASH_TABLES_VARIABLE],
+			     btr_search_sys_variable));
+	OK(schema_table_store_record(thd, table));
+
 	{
 	  OK(field_store_string(fields[INT_HASH_TABLES_NAME],
 				"Page hash (buffer pool 0 only)"));

=== modified file 'Percona-Server/storage/innobase/ibuf/ibuf0ibuf.cc'
--- Percona-Server/storage/innobase/ibuf/ibuf0ibuf.cc	2013-08-14 03:57:21 +0000
+++ Percona-Server/storage/innobase/ibuf/ibuf0ibuf.cc	2013-09-02 14:08:46 +0000
@@ -52,6 +52,7 @@
 #include "btr0cur.h"
 #include "btr0pcur.h"
 #include "btr0btr.h"
+#include "btr0sea.h"
 #include "row0upd.h"
 #include "sync0sync.h"
 #include "dict0boot.h"
@@ -626,6 +627,7 @@
 	dict_mem_index_add_field(index, "DUMMY_COLUMN", 0);
 
 	index->id = DICT_IBUF_ID_MIN + IBUF_SPACE_ID;
+	btr_search_index_init(index);
 
 	error = dict_index_add_to_cache(table, index,
 					FSP_IBUF_TREE_ROOT_PAGE_NO, FALSE);

=== modified file 'Percona-Server/storage/innobase/include/btr0sea.h'
--- Percona-Server/storage/innobase/include/btr0sea.h	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/include/btr0sea.h	2013-09-02 14:08:46 +0000
@@ -87,7 +87,7 @@
 btr_search_info_get_ref_count(
 /*==========================*/
 	btr_search_t*   info,	/*!< in: search info. */
-	index_id_t	key);	/*!< in: id of the index owning search info */
+	dict_index_t*	index); /*!< in: index */
 /*********************************************************************//**
 Updates the search info. */
 UNIV_INLINE
@@ -199,9 +199,9 @@
 @return the adaptive hash index table for a given index key */
 UNIV_INLINE
 hash_table_t*
-btr_search_get_hash_index(
+btr_search_get_hash_table(
 /*======================*/
-	index_id_t	key)	/*!< in: index key */
+	const dict_index_t*	index)	/*!< in: index */
 	__attribute__((pure,warn_unused_result));
 
 /********************************************************************//**
@@ -211,8 +211,26 @@
 rw_lock_t*
 btr_search_get_latch(
 /*=================*/
-	index_id_t	key)	/*!< in: index key */
-	__attribute__((pure,warn_unused_result));
+	const dict_index_t*	index)	/*!< in: index */
+	__attribute__((pure,warn_unused_result));
+
+/*********************************************************************//**
+Returns the AHI partition number corresponding to a give index ID. */
+UNIV_INLINE
+ulint
+btr_search_get_key(
+/*===============*/
+	index_id_t	index_id)	/*!< in: index ID */
+	__attribute__((pure,warn_unused_result));
+
+/*********************************************************************//**
+Initializes AHI-related fields in a newly created index. */
+UNIV_INLINE
+void
+btr_search_index_init(
+/*===============*/
+	dict_index_t*	index)	/*!< in: index */
+	__attribute__((nonnull));
 
 /********************************************************************//**
 Latches all adaptive hash index latches in exclusive mode.  */
@@ -241,7 +259,15 @@
 /*===============*/
 	ulint lock_type)
 	__attribute__((warn_unused_result));
-#endif /* UNIV_SYNC_DEBUG */
+/********************************************************************//**
+Checks if the thread owns any adaptive hash latches in either S or X mode.
+@return	true if the thread owns at least one latch in any mode. */
+UNIV_INLINE
+bool
+btr_search_own_any(void)
+/*=====================*/
+	 __attribute__((warn_unused_result));
+#endif
 
 /** The search info struct in an index */
 struct btr_search_t{
@@ -300,9 +326,9 @@
 
 /** The hash index system */
 struct btr_search_sys_t{
-	hash_table_t**	hash_index;	/*!< the adaptive hash index,
-					mapping dtuple_fold values
-					to rec_t pointers on index pages */
+	hash_table_t**	hash_tables;	/*!< the array of adaptive hash index
+					tables, mapping dtuple_fold values to
+					rec_t pointers on index pages */
 };
 
 /** The adaptive hash index */

=== modified file 'Percona-Server/storage/innobase/include/btr0sea.ic'
--- Percona-Server/storage/innobase/include/btr0sea.ic	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/include/btr0sea.ic	2013-09-02 14:08:46 +0000
@@ -60,8 +60,8 @@
 	btr_search_t*	info;
 
 #ifdef UNIV_SYNC_DEBUG
-	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));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), RW_LOCK_SHARED));
+	ut_ad(!rw_lock_own(btr_search_get_latch(index), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
 	info = btr_search_get_info(index);
@@ -86,11 +86,14 @@
 @return the adaptive hash index table for a given index key */
 UNIV_INLINE
 hash_table_t*
-btr_search_get_hash_index(
+btr_search_get_hash_table(
 /*======================*/
-	index_id_t	key)	/*!< in: index key */
+	const dict_index_t*	index)	/*!< in: index */
 {
-	return(btr_search_sys->hash_index[key % btr_search_index_num]);
+	ut_ad(index);
+	ut_ad(index->search_table);
+
+	return(index->search_table);
 }
 
 /********************************************************************//**
@@ -100,9 +103,41 @@
 rw_lock_t*
 btr_search_get_latch(
 /*=================*/
-	index_id_t	key)	/*!< in: index key */
-{
-	return(btr_search_latch_arr[key % btr_search_index_num]);
+	const dict_index_t*	index)	/*!< in: index */
+{
+	ut_ad(index);
+	ut_ad(index->search_latch >= btr_search_latch_arr &&
+	      index->search_latch < btr_search_latch_arr +
+	      btr_search_index_num);
+
+	return(index->search_latch);
+}
+
+/*********************************************************************//**
+Returns the AHI partition number corresponding to a give index ID. */
+UNIV_INLINE
+ulint
+btr_search_get_key(
+/*===============*/
+	index_id_t	index_id)	/*!< in: index ID */
+{
+	return(index_id % btr_search_index_num);
+}
+
+/*********************************************************************//**
+Initializes AHI-related fields in a newly created index. */
+UNIV_INLINE
+void
+btr_search_index_init(
+/*===============*/
+	dict_index_t*	index)	/*!< in: index */
+{
+	ut_ad(index);
+
+	index->search_latch =
+		&btr_search_latch_arr[btr_search_get_key(index->id)];
+	index->search_table =
+		btr_search_sys->hash_tables[btr_search_get_key(index->id)];
 }
 
 /********************************************************************//**
@@ -115,7 +150,7 @@
 	ulint	i;
 
 	for (i = 0; i < btr_search_index_num; i++) {
-		rw_lock_x_lock(btr_search_latch_arr[i]);
+		rw_lock_x_lock(&btr_search_latch_arr[i]);
 	}
 }
 
@@ -129,7 +164,7 @@
 	ulint	i;
 
 	for (i = 0; i < btr_search_index_num; i++) {
-		rw_lock_x_unlock(btr_search_latch_arr[i]);
+		rw_lock_x_unlock(&btr_search_latch_arr[i]);
 	}
 }
 
@@ -149,11 +184,31 @@
 	ulint	i;
 
 	for (i = 0; i < btr_search_index_num; i++) {
-		if (!rw_lock_own(btr_search_latch_arr[i], lock_type)) {
+		if (!rw_lock_own(&btr_search_latch_arr[i], lock_type)) {
 			return(false);
 		}
 	}
 
 	return(true);
 }
+
+/********************************************************************//**
+Checks if the thread owns any adaptive hash latches in either S or X mode.
+@return	true if the thread owns at least one latch in any mode. */
+UNIV_INLINE
+bool
+btr_search_own_any(void)
+/*====================*/
+{
+	ulint	i;
+
+	for (i = 0; i < btr_search_index_num; i++) {
+		if (rw_lock_own(&btr_search_latch_arr[i], RW_LOCK_SHARED) ||
+		    rw_lock_own(&btr_search_latch_arr[i], RW_LOCK_EX)) {
+			return(true);
+		}
+	}
+
+	return(false);
+}
 #endif /* UNIV_SYNC_DEBUG */

=== modified file 'Percona-Server/storage/innobase/include/btr0types.h'
--- Percona-Server/storage/innobase/include/btr0types.h	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/include/btr0types.h	2013-09-02 14:08:46 +0000
@@ -41,20 +41,21 @@
 
 #ifndef UNIV_HOTBACKUP
 
-/** @brief The latch protecting the adaptive search system
+/** @brief The array of latches protecting the adaptive search partitions
 
-This latch protects the
-(1) hash index;
+These latch protect the
+(1) hash index from the corresponding AHI partition;
 (2) columns of a record to which we have a pointer in the hash index;
 
-but does NOT protect:
+but do NOT protect:
 
 (3) next record offset field in a record;
 (4) next or previous records on the same page.
 
-Bear in mind (3) and (4) when using the hash index.
+Bear in mind (3) and (4) when using the hash indexes.
 */
-extern rw_lock_t**	btr_search_latch_arr;
+
+extern rw_lock_t*	btr_search_latch_arr;
 
 #endif /* UNIV_HOTBACKUP */
 

=== modified file 'Percona-Server/storage/innobase/include/buf0buf.h'
--- Percona-Server/storage/innobase/include/buf0buf.h	2013-08-29 17:46:30 +0000
+++ Percona-Server/storage/innobase/include/buf0buf.h	2013-09-02 14:08:46 +0000
@@ -1700,8 +1700,6 @@
 					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/dict0mem.h'
--- Percona-Server/storage/innobase/include/dict0mem.h	2013-08-14 03:57:21 +0000
+++ Percona-Server/storage/innobase/include/dict0mem.h	2013-09-02 14:08:46 +0000
@@ -544,6 +544,10 @@
 initialized to 0, NULL or FALSE in dict_mem_index_create(). */
 struct dict_index_t{
 	index_id_t	id;	/*!< id of the index */
+	rw_lock_t*	search_latch; /*!< latch protecting the AHI partition
+				      corresponding to this index */
+	hash_table_t*	search_table; /*!< hash table protected by
+				      search_latch */
 	mem_heap_t*	heap;	/*!< memory heap */
 	const char*	name;	/*!< index name */
 	const char*	table_name;/*!< table name */

=== modified file 'Percona-Server/storage/innobase/include/trx0trx.h'
--- Percona-Server/storage/innobase/include/trx0trx.h	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/include/trx0trx.h	2013-09-02 14:08:46 +0000
@@ -44,12 +44,14 @@
 extern sess_t*	trx_dummy_sess;
 
 /********************************************************************//**
-Releases the search latch if trx has reserved it. */
+In XtraDB it is impossible for a transaction to own a search latch outside of
+InnoDB code, so there is nothing to release on demand.  We keep this function to
+simplify maintenance.*/
 UNIV_INLINE
 void
 trx_search_latch_release_if_reserved(
 /*=================================*/
-	trx_t*		trx); /*!< in: transaction */
+	trx_t*	   trx __attribute__((unused))); /*!< in: transaction */
 /******************************************************************//**
 Set detailed error message for the transaction. */
 UNIV_INTERN
@@ -815,8 +817,8 @@
 					flush the log in
 					trx_commit_complete_for_mysql() */
 	ulint		duplicates;	/*!< TRX_DUP_IGNORE | TRX_DUP_REPLACE */
-	ulint		has_search_latch;
-					/*!< TRUE if this trx has latched the
+	bool		has_search_latch;
+					/*!< true if this trx has latched any
 					search system latch in S-mode */
 	ulint		search_latch_timeout;
 					/*!< If we notice that someone is
@@ -1136,7 +1138,7 @@
 
 Bear in mind (3) and (4) when using the hash index.
 */
-extern rw_lock_t**	btr_search_latch_arr;
+extern rw_lock_t*	btr_search_latch_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-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/include/trx0trx.ic	2013-09-02 14:08:46 +0000
@@ -164,21 +164,14 @@
 }
 
 /********************************************************************//**
-Releases the search latches if trx has reserved them. */
+In XtraDB it is impossible for a transaction to own a search latch outside of
+InnoDB code, so there is nothing to release on demand.  We keep this function to
+simplify maintenance.*/
 UNIV_INLINE
 void
 trx_search_latch_release_if_reserved(
 /*=================================*/
-	trx_t*	   trx) /*!< in: transaction */
+	trx_t*	   trx __attribute__((unused))) /*!< in: transaction */
 {
-	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_arr[i]);
-		}
-	}
-
-	trx->has_search_latch = 0;
+	ut_ad(!trx->has_search_latch);
 }
-

=== modified file 'Percona-Server/storage/innobase/row/row0ftsort.cc'
--- Percona-Server/storage/innobase/row/row0ftsort.cc	2013-02-12 07:47:19 +0000
+++ Percona-Server/storage/innobase/row/row0ftsort.cc	2013-09-02 14:08:46 +0000
@@ -30,6 +30,7 @@
 #include "row0merge.h"
 #include "row0row.h"
 #include "btr0cur.h"
+#include "btr0sea.h"
 
 /** Read the next record to buffer N.
 @param N	index into array of merge info structure */
@@ -87,6 +88,8 @@
 	new_index->n_def = FTS_NUM_FIELDS_SORT;
 	new_index->cached = TRUE;
 
+	btr_search_index_init(new_index);
+
 	idx_field = dict_index_get_nth_field(index, 0);
 	charset = fts_index_get_charset(index);
 

=== modified file 'Percona-Server/storage/innobase/row/row0sel.cc'
--- Percona-Server/storage/innobase/row/row0sel.cc	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/row/row0sel.cc	2013-09-02 14:08:46 +0000
@@ -1233,7 +1233,7 @@
 	ut_ad(!plan->must_get_clust);
 #ifdef UNIV_SYNC_DEBUG
 	if (search_latch_locked) {
-		ut_ad(rw_lock_own(btr_search_get_latch(index->id),
+		ut_ad(rw_lock_own(btr_search_get_latch(index),
 				  RW_LOCK_SHARED));
 	}
 #endif /* UNIV_SYNC_DEBUG */
@@ -1406,10 +1406,10 @@
 	    && !plan->must_get_clust
 	    && !plan->table->big_rows) {
 		if (!search_latch_locked) {
-			rw_lock_s_lock(btr_search_get_latch(index->id));
+			rw_lock_s_lock(btr_search_get_latch(index));
 
 			search_latch_locked = TRUE;
-		} else if (rw_lock_get_writer(btr_search_get_latch(index->id))
+		} else if (rw_lock_get_writer(btr_search_get_latch(index))
 			   == RW_LOCK_WAIT_EX) {
 
 			/* There is an x-latch request waiting: release the
@@ -1419,8 +1419,8 @@
 			from acquiring an s-latch for a long time, lowering
 			performance significantly in multiprocessors. */
 
-			rw_lock_s_unlock(btr_search_get_latch(index->id));
-			rw_lock_s_lock(btr_search_get_latch(index->id));
+			rw_lock_s_unlock(btr_search_get_latch(index));
+			rw_lock_s_lock(btr_search_get_latch(index));
 		}
 
 		found_flag = row_sel_try_search_shortcut(node, plan,
@@ -1445,7 +1445,7 @@
 	}
 
 	if (search_latch_locked) {
-		rw_lock_s_unlock(btr_search_get_latch(index->id));
+		rw_lock_s_unlock(btr_search_get_latch(index));
 
 		search_latch_locked = FALSE;
 	}
@@ -2021,7 +2021,7 @@
 
 func_exit:
 	if (search_latch_locked) {
-		rw_lock_s_unlock(btr_search_get_latch(index->id));
+		rw_lock_s_unlock(btr_search_get_latch(index));
 	}
 	if (UNIV_LIKELY_NULL(heap)) {
 		mem_heap_free(heap);
@@ -2796,6 +2796,9 @@
 		/* Copy an externally stored field to a temporary heap */
 
 		ut_a(!prebuilt->trx->has_search_latch);
+#ifdef UNIV_SYNC_DEBUG
+		ut_ad(!btr_search_own_any());
+#endif
 		ut_ad(field_no == templ->clust_rec_field_no);
 
 		if (UNIV_UNLIKELY(templ->type == DATA_BLOB)) {
@@ -3468,11 +3471,11 @@
 	ut_ad(!prebuilt->templ_contains_blob);
 
 #ifndef UNIV_SEARCH_DEBUG
+	ut_ad(trx->has_search_latch);
+
 	btr_pcur_open_with_no_init(index, search_tuple, PAGE_CUR_GE,
 				   BTR_SEARCH_LEAF, pcur,
-				   (trx->has_search_latch)
-				    ? RW_S_LATCH
-				    : 0,
+				   RW_S_LATCH,
 				   mtr);
 #else /* UNIV_SEARCH_DEBUG */
 	btr_pcur_open_with_no_init(index, search_tuple, PAGE_CUR_GE,
@@ -3599,47 +3602,6 @@
 }
 
 /********************************************************************//**
-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 {
-
-			ulint	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_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
@@ -3701,7 +3663,6 @@
 	ulint*		offsets				= offsets_;
 	ibool		table_lock_waited		= FALSE;
 	byte*		next_buf			= 0;
-	bool		should_release;
 
 	rec_offs_init(offsets_);
 
@@ -3715,7 +3676,9 @@
 		return(DB_END_OF_INDEX);
 	}
 
+	ut_ad(!trx->has_search_latch);
 #ifdef UNIV_SYNC_DEBUG
+	ut_ad(!btr_search_own_any());
 	ut_ad(!sync_thread_levels_nonempty_trx(trx->has_search_latch));
 #endif /* UNIV_SYNC_DEBUG */
 
@@ -3776,33 +3739,6 @@
 	fprintf(stderr, "N tables locked %lu\n",
 		(ulong) trx->mysql_n_tables_locked);
 #endif
-	/*-------------------------------------------------------------*/
-	/* 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_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 */
-
-		/* We should release all s-latches (fix Bug#791030) */
-		trx_search_latch_release_if_reserved(trx);
-
-		trx->search_latch_timeout = BTR_SEA_TIMEOUT;
-	}
-
 	/* Reset the new record lock info if srv_locks_unsafe_for_binlog
 	is set or session is using a READ COMMITED isolation level. Then
 	we are able to remove the record locks set here on an individual
@@ -3949,7 +3885,9 @@
 			hash index semaphore! */
 
 #ifndef UNIV_SEARCH_DEBUG
-			trx_search_latch_lock(trx, index->id);
+			ut_ad(!trx->has_search_latch);
+			rw_lock_s_lock(btr_search_get_latch(index));
+			trx->has_search_latch = TRUE;
 #endif
 			switch (row_sel_try_search_shortcut_for_mysql(
 					&rec, prebuilt, &offsets, &heap,
@@ -4003,7 +3941,7 @@
 				fputs(" shortcut\n", stderr); */
 
 				err = DB_SUCCESS;
-				goto release_search_latch_if_needed;
+				goto release_search_latch;
 
 			case SEL_EXHAUSTED:
 			shortcut_mismatch:
@@ -4013,15 +3951,10 @@
 				fputs(" record not found 2\n", stderr); */
 
 				err = DB_RECORD_NOT_FOUND;
-release_search_latch_if_needed:
-				if (trx->search_latch_timeout > 0
-				    && trx->has_search_latch) {
-
-					trx->search_latch_timeout--;
-
-					trx_search_latch_release_if_reserved(
-						trx);
-				}
+release_search_latch:
+				rw_lock_s_unlock(
+					btr_search_get_latch(index));
+				trx->has_search_latch = FALSE;
 
 				/* NOTE that we do NOT store the cursor
 				position */
@@ -4036,13 +3969,19 @@
 
 			mtr_commit(&mtr);
 			mtr_start(&mtr);
+
+			rw_lock_s_unlock(btr_search_get_latch(index));
+			trx->has_search_latch = FALSE;
 		}
 	}
 
 	/*-------------------------------------------------------------*/
 	/* PHASE 3: Open or restore index cursor position */
 
-	trx_search_latch_release_if_reserved(trx);
+	ut_ad(!trx->has_search_latch);
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!btr_search_own_any());
+#endif
 
 	/* The state of a running trx can only be changed by the
 	thread that is currently serving the transaction. Because we
@@ -5184,7 +5123,9 @@
 		}
 	}
 
+	ut_ad(!trx->has_search_latch);
 #ifdef UNIV_SYNC_DEBUG
+	ut_ad(!btr_search_own_any());
 	ut_ad(!sync_thread_levels_nonempty_trx(trx->has_search_latch));
 #endif /* UNIV_SYNC_DEBUG */
 

=== modified file 'Percona-Server/storage/innobase/srv/srv0srv.cc'
--- Percona-Server/storage/innobase/srv/srv0srv.cc	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/srv/srv0srv.cc	2013-09-02 14:08:46 +0000
@@ -1182,7 +1182,8 @@
 	ulint	n_reserved;
 	ibool	ret;
 
-	ulint	btr_search_sys_subtotal;
+	ulong	btr_search_sys_constant;
+	ulong	btr_search_sys_variable;
 	ulint	lock_sys_subtotal;
 	ulint	recv_sys_subtotal;
 
@@ -1307,21 +1308,27 @@
 		"Total memory allocated by read views " ULINTPF "\n",
 		os_atomic_increment_lint(&srv_read_views_memory, 0));
 
-	/* Calculate reserved memories */
-	if (btr_search_sys && btr_search_sys->hash_index[0]->heap) {
-		btr_search_sys_subtotal
-			= 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[0]->n_sync_obj; i++) {
-			btr_search_sys_subtotal
-				+= mem_heap_get_size(
-					btr_search_sys->hash_index[0]
-					->heaps[i]);
-		}
+	/* Calculate AHI constant and variable memory allocations */
+
+	btr_search_sys_constant = 0;
+	btr_search_sys_variable = 0;
+
+	ut_ad(btr_search_sys->hash_tables);
+
+	for (i = 0; i < btr_search_index_num; i++) {
+		hash_table_t* ht = btr_search_sys->hash_tables[i];
+
+		ut_ad(ht);
+		ut_ad(ht->heap);
+
+		/* Multiple mutexes/heaps are currently never used for adaptive
+		hash index tables. */
+		ut_ad(!ht->n_sync_obj);
+		ut_ad(!ht->heaps);
+
+		btr_search_sys_variable += mem_heap_get_size(ht->heap);
+		btr_search_sys_constant += ht->n_cells * sizeof(hash_cell_t);
 	}
-	btr_search_sys_subtotal *= btr_search_index_num;
 
 	lock_sys_subtotal = 0;
 	if (trx_sys) {
@@ -1349,18 +1356,9 @@
 			"    Lock system         %lu \t(%lu + " ULINTPF ")\n"
 			"    Recovery system     %lu \t(%lu + " ULINTPF ")\n",
 
-			(ulong) (btr_search_sys
-				? (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[0]->n_cells
-				   * sizeof(hash_cell_t)
-				   * btr_search_index_num)
-				 : 0),
-			btr_search_sys_subtotal,
+			btr_search_sys_constant + btr_search_sys_variable,
+			btr_search_sys_constant,
+			btr_search_sys_variable,
 
 			(ulong) (buf_pool_from_array(0)->page_hash->n_cells * sizeof(hash_cell_t)),
 
@@ -1509,23 +1507,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[0]->heap) {
-		mem_adaptive_hash
-			= 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[0]->n_sync_obj; i++) {
-			mem_adaptive_hash
-				+= mem_heap_get_size
-				(btr_search_sys->hash_index[0]->heaps[i]);
-		}
-	}
-	if (btr_search_sys) {
-		mem_adaptive_hash += (btr_search_sys->hash_index[0]->n_cells
-				      * sizeof(hash_cell_t));
-	}
-	mem_adaptive_hash *= btr_search_index_num;
+	mem_adaptive_hash = 0;
+
+	ut_ad(btr_search_sys->hash_tables);
+
+	for (i = 0; i < btr_search_index_num; i++) {
+		hash_table_t*	ht = btr_search_sys->hash_tables[i];
+
+		ut_ad(ht);
+		ut_ad(ht->heap);
+		/* Multiple mutexes/heaps are currently never used for adaptive
+		hash index tables. */
+		ut_ad(!ht->n_sync_obj);
+		ut_ad(!ht->heaps);
+
+		mem_adaptive_hash += mem_heap_get_size(ht->heap);
+		mem_adaptive_hash += ht->n_cells * sizeof(hash_cell_t);
+	}
 
 	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-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/sync/sync0sync.cc	2013-09-02 14:08:46 +0000
@@ -1187,12 +1187,12 @@
 		array */
 		bool found_current = false;
 		for (ulint i = 0; i < btr_search_index_num; i++) {
-			if (btr_search_latch_arr[i] == latch) {
+			if (&btr_search_latch_arr[i] == latch) {
 				found_current = true;
 			} else if (found_current) {
-				ut_ad(!rw_lock_own(btr_search_latch_arr[i],
+				ut_ad(!rw_lock_own(&btr_search_latch_arr[i],
 						   RW_LOCK_SHARED));
-				ut_ad(!rw_lock_own(btr_search_latch_arr[i],
+				ut_ad(!rw_lock_own(&btr_search_latch_arr[i],
 						   RW_LOCK_EX));
 			}
 		}

=== modified file 'Percona-Server/storage/innobase/trx/trx0trx.cc'
--- Percona-Server/storage/innobase/trx/trx0trx.cc	2013-08-29 17:05:40 +0000
+++ Percona-Server/storage/innobase/trx/trx0trx.cc	2013-09-02 14:08:46 +0000
@@ -360,6 +360,9 @@
 	ut_a(trx->lock.wait_thr == NULL);
 
 	ut_a(!trx->has_search_latch);
+#ifdef UNIV_SYNC_DEBUG
+	ut_ad(!btr_search_own_any());
+#endif
 
 	ut_a(trx->dict_operation_lock_mode == 0);