Merge from innodb-branches-innodb+ (2)

39 files changed, 2827 insertions, 1408 deletions

diff --git a/storage/innobase/btr/btr0btr.c b/storage/innobase/btr/btr0btr.c
index 8589d415131..6cc9b48936a 100644
--- a/storage/innobase/btr/btr0btr.c
+++ b/storage/innobase/btr/btr0btr.c
@@ -952,6 +952,7 @@ btr_page_reorganize_low(
 	dict_index_t*	index,	/*!< in: record descriptor */
 	mtr_t*		mtr)	/*!< in: mtr */
 {
+	buf_pool_t*	buf_pool	= buf_pool_from_bpage(&block->page);
 	page_t*		page		= buf_block_get_frame(block);
 	page_zip_des_t*	page_zip	= buf_block_get_page_zip(block);
 	buf_block_t*	temp_block;
@@ -982,7 +983,7 @@ btr_page_reorganize_low(
 	log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
 
 #ifndef UNIV_HOTBACKUP
-	temp_block = buf_block_alloc(0);
+	temp_block = buf_block_alloc(buf_pool, 0);
 #else /* !UNIV_HOTBACKUP */
 	ut_ad(block == back_block1);
 	temp_block = back_block2;
diff --git a/storage/innobase/btr/btr0cur.c b/storage/innobase/btr/btr0cur.c
index 3ca2b02bb4b..57d6973f623 100644
--- a/storage/innobase/btr/btr0cur.c
+++ b/storage/innobase/btr/btr0cur.c
@@ -3882,14 +3882,15 @@ btr_blob_free(
 				if there is one */
 	mtr_t*		mtr)	/*!< in: mini-transaction to commit */
 {
-	ulint	space	= buf_block_get_space(block);
-	ulint	page_no	= buf_block_get_page_no(block);
+	buf_pool_t*	buf_pool = buf_pool_from_block(block);
+	ulint		space	= buf_block_get_space(block);
+	ulint		page_no	= buf_block_get_page_no(block);
 
 	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 
 	mtr_commit(mtr);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 	mutex_enter(&block->mutex);
 
 	/* Only free the block if it is still allocated to
@@ -3910,7 +3911,7 @@ btr_blob_free(
 		}
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 	mutex_exit(&block->mutex);
 }
 
diff --git a/storage/innobase/btr/btr0sea.c b/storage/innobase/btr/btr0sea.c
index 7f8a9af1dd8..3f130405810 100644
--- a/storage/innobase/btr/btr0sea.c
+++ b/storage/innobase/btr/btr0sea.c
@@ -150,7 +150,7 @@ btr_search_check_free_space_in_heap(void)
 	be enough free space in the hash table. */
 
 	if (heap->free_block == NULL) {
-		buf_block_t*	block = buf_block_alloc(0);
+		buf_block_t*	block = buf_block_alloc(NULL, 0);
 
 		rw_lock_x_lock(&btr_search_latch);
 
@@ -825,6 +825,7 @@ btr_search_guess_on_hash(
 					RW_S_LATCH, RW_X_LATCH, or 0 */
 	mtr_t*		mtr)		/*!< in: mtr */
 {
+	buf_pool_t*	buf_pool;
 	buf_block_t*	block;
 	rec_t*		rec;
 	ulint		fold;
@@ -983,7 +984,7 @@ btr_search_guess_on_hash(
 
 	/* Increment the page get statistics though we did not really
 	fix the page: for user info only */
-
+	buf_pool = buf_pool_from_bpage(&block->page);
 	buf_pool->stat.n_page_gets++;
 
 	return(TRUE);
@@ -1760,7 +1761,7 @@ btr_search_validate(void)
 	rec_offs_init(offsets_);
 
 	rw_lock_x_lock(&btr_search_latch);
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter_all();
 
 	cell_count = hash_get_n_cells(btr_search_sys->hash_index);
 
@@ -1768,11 +1769,11 @@ btr_search_validate(void)
 		/* 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();
+			buf_pool_mutex_exit_all();
 			rw_lock_x_unlock(&btr_search_latch);
 			os_thread_yield();
 			rw_lock_x_lock(&btr_search_latch);
-			buf_pool_mutex_enter();
+			buf_pool_mutex_enter_all();
 		}
 
 		node = hash_get_nth_cell(btr_search_sys->hash_index, i)->node;
@@ -1781,6 +1782,9 @@ btr_search_validate(void)
 			const buf_block_t*	block
 				= buf_block_align(node->data);
 			const buf_block_t*	hash_block;
+			buf_pool_t*		buf_pool;
+
+			buf_pool = buf_pool_from_bpage((buf_page_t*) block);
 
 			if (UNIV_LIKELY(buf_block_get_state(block)
 					== BUF_BLOCK_FILE_PAGE)) {
@@ -1791,6 +1795,7 @@ btr_search_validate(void)
 				(BUF_BLOCK_REMOVE_HASH, see the
 				assertion and the comment below) */
 				hash_block = buf_block_hash_get(
+					buf_pool,
 					buf_block_get_space(block),
 					buf_block_get_page_no(block));
 			} else {
@@ -1879,11 +1884,11 @@ btr_search_validate(void)
 		/* 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();
+			buf_pool_mutex_exit_all();
 			rw_lock_x_unlock(&btr_search_latch);
 			os_thread_yield();
 			rw_lock_x_lock(&btr_search_latch);
-			buf_pool_mutex_enter();
+			buf_pool_mutex_enter_all();
 		}
 
 		if (!ha_validate(btr_search_sys->hash_index, i, end_index)) {
@@ -1891,7 +1896,7 @@ btr_search_validate(void)
 		}
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit_all();
 	rw_lock_x_unlock(&btr_search_latch);
 	if (UNIV_LIKELY_NULL(heap)) {
 		mem_heap_free(heap);
diff --git a/storage/innobase/buf/buf0buddy.c b/storage/innobase/buf/buf0buddy.c
index 7118cb376ab..695aed2d0cb 100644
--- a/storage/innobase/buf/buf0buddy.c
+++ b/storage/innobase/buf/buf0buddy.c
@@ -34,17 +34,6 @@ Created December 2006 by Marko Makela
 #include "buf0flu.h"
 #include "page0zip.h"
 
-/* Statistic counters */
-
-#ifdef UNIV_DEBUG
-/** Number of frames allocated from the buffer pool to the buddy system.
-Protected by buf_pool_mutex. */
-static ulint buf_buddy_n_frames;
-#endif /* UNIV_DEBUG */
-/** Statistics of the buddy system, indexed by block size.
-Protected by buf_pool_mutex. */
-UNIV_INTERN buf_buddy_stat_t buf_buddy_stat[BUF_BUDDY_SIZES + 1];
-
 /**********************************************************************//**
 Get the offset of the buddy of a compressed page frame.
 @return	the buddy relative of page */
@@ -73,8 +62,10 @@ UNIV_INLINE
 void
 buf_buddy_add_to_free(
 /*==================*/
-	buf_page_t*	bpage,	/*!< in,own: block to be freed */
-	ulint		i)	/*!< in: index of buf_pool->zip_free[] */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	buf_page_t*	bpage,		/*!< in,own: block to be freed */
+	ulint		i)		/*!< in: index of
+					buf_pool->zip_free[] */
 {
 #ifdef UNIV_DEBUG_VALGRIND
 	buf_page_t*	b  = UT_LIST_GET_FIRST(buf_pool->zip_free[i]);
@@ -82,7 +73,7 @@ buf_buddy_add_to_free(
 	if (b) UNIV_MEM_VALID(b, BUF_BUDDY_LOW << i);
 #endif /* UNIV_DEBUG_VALGRIND */
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(buf_page_get_state(bpage) == BUF_BLOCK_ZIP_FREE);
 	ut_ad(buf_pool->zip_free[i].start != bpage);
 	UT_LIST_ADD_FIRST(list, buf_pool->zip_free[i], bpage);
@@ -99,8 +90,10 @@ UNIV_INLINE
 void
 buf_buddy_remove_from_free(
 /*=======================*/
-	buf_page_t*	bpage,	/*!< in: block to be removed */
-	ulint		i)	/*!< in: index of buf_pool->zip_free[] */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	buf_page_t*	bpage,		/*!< in: block to be removed */
+	ulint		i)		/*!< in: index of
+					buf_pool->zip_free[] */
 {
 #ifdef UNIV_DEBUG_VALGRIND
 	buf_page_t*	prev = UT_LIST_GET_PREV(list, bpage);
@@ -113,7 +106,7 @@ buf_buddy_remove_from_free(
 	ut_ad(!next || buf_page_get_state(next) == BUF_BLOCK_ZIP_FREE);
 #endif /* UNIV_DEBUG_VALGRIND */
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(buf_page_get_state(bpage) == BUF_BLOCK_ZIP_FREE);
 	UT_LIST_REMOVE(list, buf_pool->zip_free[i], bpage);
 
@@ -130,11 +123,12 @@ static
 void*
 buf_buddy_alloc_zip(
 /*================*/
-	ulint	i)	/*!< in: index of buf_pool->zip_free[] */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		i)		/*!< in: index of buf_pool->zip_free[] */
 {
 	buf_page_t*	bpage;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_a(i < BUF_BUDDY_SIZES);
 
 #ifndef UNIV_DEBUG_VALGRIND
@@ -149,19 +143,19 @@ buf_buddy_alloc_zip(
 		UNIV_MEM_VALID(bpage, BUF_BUDDY_LOW << i);
 		ut_a(buf_page_get_state(bpage) == BUF_BLOCK_ZIP_FREE);
 
-		buf_buddy_remove_from_free(bpage, i);
+		buf_buddy_remove_from_free(buf_pool, bpage, i);
 	} else if (i + 1 < BUF_BUDDY_SIZES) {
 		/* Attempt to split. */
-		bpage = buf_buddy_alloc_zip(i + 1);
+		bpage = buf_buddy_alloc_zip(buf_pool, i + 1);
 
 		if (bpage) {
 			buf_page_t*	buddy = (buf_page_t*)
 				(((char*) bpage) + (BUF_BUDDY_LOW << i));
 
-			ut_ad(!buf_pool_contains_zip(buddy));
+			ut_ad(!buf_pool_contains_zip(buf_pool, buddy));
 			ut_d(memset(buddy, i, BUF_BUDDY_LOW << i));
 			buddy->state = BUF_BLOCK_ZIP_FREE;
-			buf_buddy_add_to_free(buddy, i);
+			buf_buddy_add_to_free(buf_pool, buddy, i);
 		}
 	}
 
@@ -182,14 +176,15 @@ static
 void
 buf_buddy_block_free(
 /*=================*/
-	void*	buf)	/*!< in: buffer frame to deallocate */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	void*		buf)		/*!< in: buffer frame to deallocate */
 {
 	const ulint	fold	= BUF_POOL_ZIP_FOLD_PTR(buf);
 	buf_page_t*	bpage;
 	buf_block_t*	block;
 
-	ut_ad(buf_pool_mutex_own());
-	ut_ad(!mutex_own(&buf_pool_zip_mutex));
+	ut_ad(buf_pool_mutex_own(buf_pool));
+	ut_ad(!mutex_own(&buf_pool->zip_mutex));
 	ut_a(!ut_align_offset(buf, UNIV_PAGE_SIZE));
 
 	HASH_SEARCH(hash, buf_pool->zip_hash, fold, buf_page_t*, bpage,
@@ -211,8 +206,8 @@ buf_buddy_block_free(
 	buf_LRU_block_free_non_file_page(block);
 	mutex_exit(&block->mutex);
 
-	ut_ad(buf_buddy_n_frames > 0);
-	ut_d(buf_buddy_n_frames--);
+	ut_ad(buf_pool->buddy_n_frames > 0);
+	ut_d(buf_pool->buddy_n_frames--);
 }
 
 /**********************************************************************//**
@@ -223,9 +218,10 @@ buf_buddy_block_register(
 /*=====================*/
 	buf_block_t*	block)	/*!< in: buffer frame to allocate */
 {
+	buf_pool_t*	buf_pool = buf_pool_from_block(block);
 	const ulint	fold = BUF_POOL_ZIP_FOLD(block);
-	ut_ad(buf_pool_mutex_own());
-	ut_ad(!mutex_own(&buf_pool_zip_mutex));
+	ut_ad(buf_pool_mutex_own(buf_pool));
+	ut_ad(!mutex_own(&buf_pool->zip_mutex));
 	ut_ad(buf_block_get_state(block) == BUF_BLOCK_READY_FOR_USE);
 
 	buf_block_set_state(block, BUF_BLOCK_MEMORY);
@@ -238,7 +234,7 @@ buf_buddy_block_register(
 	ut_d(block->page.in_zip_hash = TRUE);
 	HASH_INSERT(buf_page_t, hash, buf_pool->zip_hash, fold, &block->page);
 
-	ut_d(buf_buddy_n_frames++);
+	ut_d(buf_pool->buddy_n_frames++);
 }
 
 /**********************************************************************//**
@@ -248,10 +244,12 @@ static
 void*
 buf_buddy_alloc_from(
 /*=================*/
-	void*		buf,	/*!< in: a block that is free to use */
-	ulint		i,	/*!< in: index of buf_pool->zip_free[] */
-	ulint		j)	/*!< in: size of buf as an index
-				of buf_pool->zip_free[] */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	void*		buf,		/*!< in: a block that is free to use */
+	ulint		i,		/*!< in: index of
+					buf_pool->zip_free[] */
+	ulint		j)		/*!< in: size of buf as an index
+					of buf_pool->zip_free[] */
 {
 	ulint	offs	= BUF_BUDDY_LOW << j;
 	ut_ad(j <= BUF_BUDDY_SIZES);
@@ -275,7 +273,7 @@ buf_buddy_alloc_from(
 						    ut_list_node_313)
 					    == BUF_BLOCK_ZIP_FREE)));
 #endif /* !UNIV_DEBUG_VALGRIND */
-		buf_buddy_add_to_free(bpage, j);
+		buf_buddy_add_to_free(buf_pool, bpage, j);
 	}
 
 	return(buf);
@@ -283,37 +281,39 @@ buf_buddy_alloc_from(
 
 /**********************************************************************//**
 Allocate a block.  The thread calling this function must hold
-buf_pool_mutex and must not hold buf_pool_zip_mutex or any block->mutex.
-The buf_pool_mutex may only be released and reacquired if lru != NULL.
+buf_pool->mutex and must not hold buf_pool_zip_mutex or any block->mutex.
+The buf_pool->mutex may only be released and reacquired if lru != NULL.
 @return	allocated block, possibly NULL if lru==NULL */
 UNIV_INTERN
 void*
 buf_buddy_alloc_low(
 /*================*/
-	ulint	i,	/*!< in: index of buf_pool->zip_free[],
-			or BUF_BUDDY_SIZES */
-	ibool*	lru)	/*!< in: pointer to a variable that will be assigned
-			TRUE if storage was allocated from the LRU list
-			and buf_pool_mutex was temporarily released,
-			or NULL if the LRU list should not be used */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		i,		/*!< in: index of buf_pool->zip_free[],
+					or BUF_BUDDY_SIZES */
+	ibool*		lru)		/*!< in: pointer to a variable that
+					will be assigned TRUE if storage was
+					allocated from the LRU list and
+					buf_pool->mutex was temporarily
+					released, or NULL if the LRU list
+					should not be used */
 {
 	buf_block_t*	block;
 
-	ut_ad(buf_pool_mutex_own());
-	ut_ad(!mutex_own(&buf_pool_zip_mutex));
+	ut_ad(buf_pool_mutex_own(buf_pool));
+	ut_ad(!mutex_own(&buf_pool->zip_mutex));
 
 	if (i < BUF_BUDDY_SIZES) {
 		/* Try to allocate from the buddy system. */
-		block = buf_buddy_alloc_zip(i);
+		block = buf_buddy_alloc_zip(buf_pool, i);
 
 		if (block) {
-
 			goto func_exit;
 		}
 	}
 
 	/* Try allocating from the buf_pool->free list. */
-	block = buf_LRU_get_free_only();
+	block = buf_LRU_get_free_only(buf_pool);
 
 	if (block) {
 
@@ -326,18 +326,19 @@ buf_buddy_alloc_low(
 	}
 
 	/* Try replacing an uncompressed page in the buffer pool. */
-	buf_pool_mutex_exit();
-	block = buf_LRU_get_free_block(0);
+	buf_pool_mutex_exit(buf_pool);
+	block = buf_LRU_get_free_block(buf_pool, 0);
 	*lru = TRUE;
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 alloc_big:
 	buf_buddy_block_register(block);
 
-	block = buf_buddy_alloc_from(block->frame, i, BUF_BUDDY_SIZES);
+	block = buf_buddy_alloc_from(
+		buf_pool, block->frame, i, BUF_BUDDY_SIZES);
 
 func_exit:
-	buf_buddy_stat[i].used++;
+	buf_pool->buddy_stat[i].used++;
 	return(block);
 }
 
@@ -352,8 +353,9 @@ buf_buddy_relocate_block(
 	buf_page_t*	dpage)	/*!< in: free block to relocate to */
 {
 	buf_page_t*	b;
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	switch (buf_page_get_state(bpage)) {
 	case BUF_BLOCK_ZIP_FREE:
@@ -371,10 +373,10 @@ buf_buddy_relocate_block(
 		break;
 	}
 
-	mutex_enter(&buf_pool_zip_mutex);
+	mutex_enter(&buf_pool->zip_mutex);
 
 	if (!buf_page_can_relocate(bpage)) {
-		mutex_exit(&buf_pool_zip_mutex);
+		mutex_exit(&buf_pool->zip_mutex);
 		return(FALSE);
 	}
 
@@ -393,7 +395,7 @@ buf_buddy_relocate_block(
 
 	UNIV_MEM_INVALID(bpage, sizeof *bpage);
 
-	mutex_exit(&buf_pool_zip_mutex);
+	mutex_exit(&buf_pool->zip_mutex);
 	return(TRUE);
 }
 
@@ -404,16 +406,18 @@ static
 ibool
 buf_buddy_relocate(
 /*===============*/
-	void*	src,	/*!< in: block to relocate */
-	void*	dst,	/*!< in: free block to relocate to */
-	ulint	i)	/*!< in: index of buf_pool->zip_free[] */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	void*		src,		/*!< in: block to relocate */
+	void*		dst,		/*!< in: free block to relocate to */
+	ulint		i)		/*!< in: index of
+					buf_pool->zip_free[] */
 {
 	buf_page_t*	bpage;
 	const ulint	size	= BUF_BUDDY_LOW << i;
 	ullint		usec	= ut_time_us(NULL);
 
-	ut_ad(buf_pool_mutex_own());
-	ut_ad(!mutex_own(&buf_pool_zip_mutex));
+	ut_ad(buf_pool_mutex_own(buf_pool));
+	ut_ad(!mutex_own(&buf_pool->zip_mutex));
 	ut_ad(!ut_align_offset(src, size));
 	ut_ad(!ut_align_offset(dst, size));
 	UNIV_MEM_ASSERT_W(dst, size);
@@ -443,6 +447,7 @@ buf_buddy_relocate(
 		mach_read_from_4() calls here will only trigger bogus
 		Valgrind memcheck warnings in UNIV_DEBUG_VALGRIND builds. */
 		bpage = buf_page_hash_get(
+			buf_pool,
 			mach_read_from_4((const byte*) src
 					 + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID),
 			mach_read_from_4((const byte*) src
@@ -457,7 +462,7 @@ buf_buddy_relocate(
 			return(FALSE);
 		}
 
-		ut_ad(!buf_pool_watch_is(bpage));
+		ut_ad(!buf_pool_watch_is_sentinel(buf_pool, bpage));
 
 		if (page_zip_get_size(&bpage->zip) != size) {
 			/* The block is of different size.  We would
@@ -486,7 +491,7 @@ success:
 			UNIV_MEM_INVALID(src, size);
 			{
 				buf_buddy_stat_t*	buddy_stat
-					= &buf_buddy_stat[i];
+					= &buf_pool->buddy_stat[i];
 				buddy_stat->relocated++;
 				buddy_stat->relocated_usec
 					+= ut_time_us(NULL) - usec;
@@ -513,32 +518,33 @@ UNIV_INTERN
 void
 buf_buddy_free_low(
 /*===============*/
-	void*	buf,	/*!< in: block to be freed, must not be
-			pointed to by the buffer pool */
-	ulint	i)	/*!< in: index of buf_pool->zip_free[],
-			or BUF_BUDDY_SIZES */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	void*		buf,		/*!< in: block to be freed, must not be
+					pointed to by the buffer pool */
+	ulint		i)		/*!< in: index of buf_pool->zip_free[],
+					or BUF_BUDDY_SIZES */
 {
 	buf_page_t*	bpage;
 	buf_page_t*	buddy;
 
-	ut_ad(buf_pool_mutex_own());
-	ut_ad(!mutex_own(&buf_pool_zip_mutex));
+	ut_ad(buf_pool_mutex_own(buf_pool));
+	ut_ad(!mutex_own(&buf_pool->zip_mutex));
 	ut_ad(i <= BUF_BUDDY_SIZES);
-	ut_ad(buf_buddy_stat[i].used > 0);
+	ut_ad(buf_pool->buddy_stat[i].used > 0);
 
-	buf_buddy_stat[i].used--;
+	buf_pool->buddy_stat[i].used--;
 recombine:
 	UNIV_MEM_ASSERT_AND_ALLOC(buf, BUF_BUDDY_LOW << i);
 	ut_d(((buf_page_t*) buf)->state = BUF_BLOCK_ZIP_FREE);
 
 	if (i == BUF_BUDDY_SIZES) {
-		buf_buddy_block_free(buf);
+		buf_buddy_block_free(buf_pool, buf);
 		return;
 	}
 
 	ut_ad(i < BUF_BUDDY_SIZES);
 	ut_ad(buf == ut_align_down(buf, BUF_BUDDY_LOW << i));
-	ut_ad(!buf_pool_contains_zip(buf));
+	ut_ad(!buf_pool_contains_zip(buf_pool, buf));
 
 	/* Try to combine adjacent blocks. */
 
@@ -564,10 +570,10 @@ recombine:
 		if (bpage == buddy) {
 buddy_free:
 			/* The buddy is free: recombine */
-			buf_buddy_remove_from_free(bpage, i);
+			buf_buddy_remove_from_free(buf_pool, bpage, i);
 buddy_free2:
 			ut_ad(buf_page_get_state(buddy) == BUF_BLOCK_ZIP_FREE);
-			ut_ad(!buf_pool_contains_zip(buddy));
+			ut_ad(!buf_pool_contains_zip(buf_pool, buddy));
 			i++;
 			buf = ut_align_down(buf, BUF_BUDDY_LOW << i);
 
@@ -599,16 +605,16 @@ buddy_nonfree:
 		buf_buddy_relocate() will overwrite bpage->list. */
 
 		UNIV_MEM_VALID(bpage, BUF_BUDDY_LOW << i);
-		buf_buddy_remove_from_free(bpage, i);
+		buf_buddy_remove_from_free(buf_pool, bpage, i);
 
 		/* Try to relocate the buddy of buf to the free block. */
-		if (buf_buddy_relocate(buddy, bpage, i)) {
+		if (buf_buddy_relocate(buf_pool, buddy, bpage, i)) {
 
 			ut_d(buddy->state = BUF_BLOCK_ZIP_FREE);
 			goto buddy_free2;
 		}
 
-		buf_buddy_add_to_free(bpage, i);
+		buf_buddy_add_to_free(buf_pool, bpage, i);
 
 		/* Try to relocate the buddy of the free block to buf. */
 		buddy = (buf_page_t*) buf_buddy_get(((byte*) bpage),
@@ -629,7 +635,7 @@ buddy_nonfree:
 					    && ut_list_node_313 != buddy)));
 #endif /* !UNIV_DEBUG_VALGRIND */
 
-		if (buf_buddy_relocate(buddy, buf, i)) {
+		if (buf_buddy_relocate(buf_pool, buddy, buf, i)) {
 
 			buf = bpage;
 			UNIV_MEM_VALID(bpage, BUF_BUDDY_LOW << i);
@@ -692,5 +698,5 @@ buddy_nonfree:
 	}
 #endif /* UNIV_DEBUG */
 	bpage->state = BUF_BLOCK_ZIP_FREE;
-	buf_buddy_add_to_free(bpage, i);
+	buf_buddy_add_to_free(buf_pool, bpage, i);
 }
diff --git a/storage/innobase/buf/buf0buf.c b/storage/innobase/buf/buf0buf.c
index c4b693e3ed2..7a86d12fa69 100644
--- a/storage/innobase/buf/buf0buf.c
+++ b/storage/innobase/buf/buf0buf.c
@@ -84,21 +84,21 @@ in the file along with the file page, resides in the control block.
 The buffer buf_pool contains a single mutex which protects all the
 control data structures of the buf_pool. The content of a buffer frame is
 protected by a separate read-write lock in its control block, though.
-These locks can be locked and unlocked without owning the buf_pool mutex.
+These locks can be locked and unlocked without owning the buf_pool->mutex.
 The OS events in the buf_pool struct can be waited for without owning the
-buf_pool mutex.
+buf_pool->mutex.
 
-The buf_pool mutex is a hot-spot in main memory, causing a lot of
+The buf_pool->mutex is a hot-spot in main memory, causing a lot of
 memory bus traffic on multiprocessor systems when processors
 alternately access the mutex. On our Pentium, the mutex is accessed
 maybe every 10 microseconds. We gave up the solution to have mutexes
 for each control block, for instance, because it seemed to be
 complicated.
 
-A solution to reduce mutex contention of the buf_pool mutex is to
+A solution to reduce mutex contention of the buf_pool->mutex is to
 create a separate mutex for the page hash table. On Pentium,
 accessing the hash table takes 2 microseconds, about half
-of the total buf_pool mutex hold time.
+of the total buf_pool->mutex hold time.
 
 		Control blocks
 		--------------
@@ -247,22 +247,12 @@ static const int WAIT_FOR_READ	= 5000;
 static const ulint BUF_PAGE_READ_MAX_RETRIES = 100;
 
 /** The buffer buf_pool of the database */
-UNIV_INTERN buf_pool_t*	buf_pool = NULL;
-
-/** mutex protecting the buffer pool struct and control blocks, except the
-read-write lock in them */
-UNIV_INTERN mutex_t		buf_pool_mutex;
-/** mutex protecting the control blocks of compressed-only pages
-(of type buf_page_t, not buf_block_t) */
-UNIV_INTERN mutex_t		buf_pool_zip_mutex;
+UNIV_INTERN buf_pool_t*	buf_pool_ptr[MAX_BUFFER_POOLS];
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 static ulint	buf_dbg_counter	= 0; /*!< This is used to insert validation
-					operations in excution in the
+					operations in execution in the
 					debug version */
-/** Flag to forbid the release of the buffer pool mutex.
-Protected by buf_pool_mutex. */
-UNIV_INTERN ulint		buf_pool_mutex_exit_forbidden = 0;
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 #ifdef UNIV_DEBUG
 /** If this is set TRUE, the program prints info whenever
@@ -284,7 +274,6 @@ UNIV_INTERN mysql_pfs_key_t	buffer_block_mutex_key;
 UNIV_INTERN mysql_pfs_key_t	buf_pool_mutex_key;
 UNIV_INTERN mysql_pfs_key_t	buf_pool_zip_mutex_key;
 UNIV_INTERN mysql_pfs_key_t	flush_list_mutex_key;
-UNIV_INTERN mysql_pfs_key_t	flush_order_mutex_key;
 #endif /* UNIV_PFS_MUTEX */
 
 #if defined UNIV_PFS_MUTEX || defined UNIV_PFS_RWLOCK
@@ -316,6 +305,140 @@ struct buf_chunk_struct{
 #endif /* !UNIV_HOTBACKUP */
 
 /********************************************************************//**
+Gets the smallest oldest_modification lsn for any page in the pool. Returns
+zero if all modified pages have been flushed to disk.
+@return oldest modification in pool, zero if none */
+UNIV_INTERN
+ib_uint64_t
+buf_pool_get_oldest_modification(void)
+/*==================================*/
+{
+	ulint		i;
+	buf_page_t*	bpage;
+	ib_uint64_t	lsn = 0;
+	ib_uint64_t	oldest_lsn = 0;
+
+	/* When we traverse all the flush lists we don't want another
+	thread to add a dirty page to any flush list. */
+	log_flush_order_mutex_enter();
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+
+		buf_flush_list_mutex_enter(buf_pool);
+
+		bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
+
+		if (bpage != NULL) {
+			ut_ad(bpage->in_flush_list);
+			lsn = bpage->oldest_modification;
+		}
+
+		buf_flush_list_mutex_exit(buf_pool);
+
+		if (!oldest_lsn || oldest_lsn > lsn) {
+			oldest_lsn = lsn;
+		}
+	}
+
+	log_flush_order_mutex_exit();
+
+	/* The returned answer may be out of date: the flush_list can
+	change after the mutex has been released. */
+
+	return(oldest_lsn);
+}
+
+/********************************************************************//**
+Get total buffer pool statistics. */
+UNIV_INTERN
+void
+buf_get_total_list_len(
+/*===================*/
+	ulint*		LRU_len,	/*!< out: length of all LRU lists */
+	ulint*		free_len,	/*!< out: length of all free lists */
+	ulint*		flush_list_len)	/*!< out: length of all flush lists */
+{
+	ulint		i;
+
+	*LRU_len = 0;
+	*free_len = 0;
+	*flush_list_len = 0;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+		*LRU_len += UT_LIST_GET_LEN(buf_pool->LRU);
+		*free_len += UT_LIST_GET_LEN(buf_pool->free);
+		*flush_list_len += UT_LIST_GET_LEN(buf_pool->flush_list);
+	}
+}
+
+/********************************************************************//**
+Get total buffer pool statistics. */
+UNIV_INTERN
+void
+buf_get_total_stat(
+/*===============*/
+	buf_pool_stat_t*	tot_stat)	/*!< out: buffer pool stats */
+{
+	ulint			i;
+
+	memset(tot_stat, 0, sizeof(*tot_stat));
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_stat_t*buf_stat;
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+
+		buf_stat = &buf_pool->stat;
+		tot_stat->n_page_gets += buf_stat->n_page_gets;
+		tot_stat->n_pages_read += buf_stat->n_pages_read;
+		tot_stat->n_pages_written += buf_stat->n_pages_written;
+		tot_stat->n_pages_created += buf_stat->n_pages_created;
+		tot_stat->n_ra_pages_read += buf_stat->n_ra_pages_read;
+		tot_stat->n_ra_pages_evicted += buf_stat->n_ra_pages_evicted;
+		tot_stat->n_pages_made_young += buf_stat->n_pages_made_young;
+
+		tot_stat->n_pages_not_made_young +=
+			buf_stat->n_pages_not_made_young;
+	}
+}
+
+/********************************************************************//**
+Allocates a buffer block.
+@return own: the allocated block, in state BUF_BLOCK_MEMORY */
+UNIV_INTERN
+buf_block_t*
+buf_block_alloc(
+/*============*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		zip_size)	/*!< in: compressed page size in bytes,
+					or 0 if uncompressed tablespace */
+{
+	buf_block_t*	block;
+	ulint		index;
+	static ulint	buf_pool_index;
+
+	if (buf_pool == NULL) {
+		/* We are allocating memory from any buffer pool, ensure
+		we spread the grace on all buffer pool instances. */
+		index = buf_pool_index++ % srv_buf_pool_instances;
+		buf_pool = buf_pool_from_array(index);
+	}
+
+	block = buf_LRU_get_free_block(buf_pool, zip_size);
+
+	buf_block_set_state(block, BUF_BLOCK_MEMORY);
+
+	return(block);
+}
+
+/********************************************************************//**
 Calculates a page checksum which is stored to the page when it is written
 to a file. Note that we must be careful to calculate the same value on
 32-bit and 64-bit architectures.
@@ -727,13 +850,15 @@ static
 void
 buf_block_init(
 /*===========*/
-	buf_block_t*	block,	/*!< in: pointer to control block */
-	byte*		frame)	/*!< in: pointer to buffer frame */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	buf_block_t*	block,		/*!< in: pointer to control block */
+	byte*		frame)		/*!< in: pointer to buffer frame */
 {
 	UNIV_MEM_DESC(frame, UNIV_PAGE_SIZE, block);
 
 	block->frame = frame;
 
+	block->page.buf_pool = buf_pool;
 	block->page.state = BUF_BLOCK_NOT_USED;
 	block->page.buf_fix_count = 0;
 	block->page.io_fix = BUF_IO_NONE;
@@ -789,6 +914,7 @@ static
 buf_chunk_t*
 buf_chunk_init(
 /*===========*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
 	buf_chunk_t*	chunk,		/*!< out: chunk of buffers */
 	ulint		mem_size)	/*!< in: requested size in bytes */
 {
@@ -844,7 +970,7 @@ buf_chunk_init(
 
 	for (i = chunk->size; i--; ) {
 
-		buf_block_init(block, frame);
+		buf_block_init(buf_pool, block, frame);
 
 #ifdef HAVE_purify
 		/* Wipe contents of frame to eliminate a Purify warning */
@@ -852,7 +978,9 @@ buf_chunk_init(
 #endif
 		/* Add the block to the free list */
 		UT_LIST_ADD_LAST(list, buf_pool->free, (&block->page));
+
 		ut_d(block->page.in_free_list = TRUE);
+		ut_ad(buf_pool_from_block(block) == buf_pool);
 
 		block++;
 		frame += UNIV_PAGE_SIZE;
@@ -879,9 +1007,6 @@ buf_chunk_contains_zip(
 	buf_block_t*	block;
 	ulint		i;
 
-	ut_ad(buf_pool);
-	ut_ad(buf_pool_mutex_own());
-
 	block = chunk->blocks;
 
 	for (i = chunk->size; i--; block++) {
@@ -902,12 +1027,16 @@ UNIV_INTERN
 buf_block_t*
 buf_pool_contains_zip(
 /*==================*/
-	const void*	data)	/*!< in: pointer to compressed page */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	const void*	data)		/*!< in: pointer to compressed page */
 {
 	ulint		n;
 	buf_chunk_t*	chunk = buf_pool->chunks;
 
+	ut_ad(buf_pool);
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	for (n = buf_pool->n_chunks; n--; chunk++) {
+
 		buf_block_t* block = buf_chunk_contains_zip(chunk, data);
 
 		if (block) {
@@ -931,9 +1060,6 @@ buf_chunk_not_freed(
 	buf_block_t*	block;
 	ulint		i;
 
-	ut_ad(buf_pool);
-	ut_ad(buf_pool_mutex_own());
-
 	block = chunk->blocks;
 
 	for (i = chunk->size; i--; block++) {
@@ -983,9 +1109,6 @@ buf_chunk_all_free(
 	const buf_block_t*	block;
 	ulint			i;
 
-	ut_ad(buf_pool);
-	ut_ad(buf_pool_mutex_own());
-
 	block = chunk->blocks;
 
 	for (i = chunk->size; i--; block++) {
@@ -1005,12 +1128,13 @@ static
 void
 buf_chunk_free(
 /*===========*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
 	buf_chunk_t*	chunk)		/*!< out: chunk of buffers */
 {
 	buf_block_t*		block;
 	const buf_block_t*	block_end;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	block_end = chunk->blocks + chunk->size;
 
@@ -1038,55 +1162,83 @@ buf_chunk_free(
 }
 
 /********************************************************************//**
-Creates the buffer pool.
-@return	own: buf_pool object, NULL if not enough memory or error */
+Set buffer pool size variables after resizing it */
+static
+void
+buf_pool_set_sizes(void)
+/*====================*/
+{
+	ulint	i;
+	ulint	curr_size = 0;
+
+	buf_pool_mutex_enter_all();
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+		curr_size += buf_pool->curr_pool_size;
+	}
+
+	srv_buf_pool_curr_size = curr_size;
+	srv_buf_pool_old_size = srv_buf_pool_size;
+
+	buf_pool_mutex_exit_all();
+}
+
+/********************************************************************//**
+Initialize a buffer pool instance.
+@return DB_SUCCESS if all goes well. */
 UNIV_INTERN
-buf_pool_t*
-buf_pool_init(void)
-/*===============*/
+ulint
+buf_pool_init_instance(
+/*===================*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		buf_pool_size,	/*!< in: size in bytes */
+	ulint		instance_no)	/*!< in: id of the instance */
 {
-	buf_chunk_t*	chunk;
 	ulint		i;
-
-	buf_pool = mem_zalloc(sizeof(buf_pool_t));
+	buf_chunk_t*	chunk;
 
 	/* 1. Initialize general fields
 	------------------------------- */
 	mutex_create(buf_pool_mutex_key,
-		     &buf_pool_mutex, SYNC_BUF_POOL);
+		     &buf_pool->mutex, SYNC_BUF_POOL);
 	mutex_create(buf_pool_zip_mutex_key,
-		     &buf_pool_zip_mutex, SYNC_BUF_BLOCK);
+		     &buf_pool->zip_mutex, SYNC_BUF_BLOCK);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	buf_pool->n_chunks = 1;
-	buf_pool->chunks = chunk = mem_alloc(sizeof *chunk);
+	if (buf_pool_size > 0) {
+		buf_pool->n_chunks = 1;
+		buf_pool->chunks = chunk = mem_zalloc(sizeof *chunk);
 
-	UT_LIST_INIT(buf_pool->free);
+		UT_LIST_INIT(buf_pool->free);
 
-	if (!buf_chunk_init(chunk, srv_buf_pool_size)) {
-		mem_free(chunk);
-		mem_free(buf_pool);
-		buf_pool = NULL;
-		return(NULL);
-	}
+		if (!buf_chunk_init(buf_pool, chunk, buf_pool_size)) {
+			mem_free(chunk);
+			mem_free(buf_pool);
 
-	srv_buf_pool_old_size = srv_buf_pool_size;
-	buf_pool->curr_size = chunk->size;
-	srv_buf_pool_curr_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
+			buf_pool_mutex_exit(buf_pool);
 
-	buf_pool->page_hash = hash_create(2 * buf_pool->curr_size);
-	buf_pool->zip_hash = hash_create(2 * buf_pool->curr_size);
+			return(DB_ERROR);
+		}
 
-	buf_pool->last_printout_time = time(NULL);
+		buf_pool->instance_no = instance_no;
+		buf_pool->old_pool_size = buf_pool_size;
+		buf_pool->curr_size = chunk->size;
+		buf_pool->curr_pool_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
 
+		buf_pool->page_hash = hash_create(2 * buf_pool->curr_size);
+		buf_pool->zip_hash = hash_create(2 * buf_pool->curr_size);
+		
+		buf_pool->last_printout_time = ut_time();
+	}
 	/* 2. Initialize flushing fields
 	-------------------------------- */
 
 	mutex_create(flush_list_mutex_key, &buf_pool->flush_list_mutex,
 		     SYNC_BUF_FLUSH_LIST);
-	mutex_create(flush_order_mutex_key, &buf_pool->flush_order_mutex,
-		     SYNC_BUF_FLUSH_ORDER);
 
 	for (i = BUF_FLUSH_LRU; i < BUF_FLUSH_N_TYPES; i++) {
 		buf_pool->no_flush[i] = os_event_create(NULL);
@@ -1094,26 +1246,22 @@ buf_pool_init(void)
 
 	/* 3. Initialize LRU fields
 	--------------------------- */
-	/* All fields are initialized by mem_zalloc(). */
-
-	buf_pool_mutex_exit();
-
-	btr_search_sys_create(buf_pool->curr_size
-			      * UNIV_PAGE_SIZE / sizeof(void*) / 64);
 
-	/* 4. Initialize the buddy allocator fields */
 	/* All fields are initialized by mem_zalloc(). */
 
-	return(buf_pool);
+	buf_pool_mutex_exit(buf_pool);
+
+	return(DB_SUCCESS);
 }
 
 /********************************************************************//**
-Frees the buffer pool at shutdown.  This must not be invoked before
-freeing all mutexes. */
-UNIV_INTERN
+free one buffer pool instance */
+static
 void
-buf_pool_free(void)
-/*===============*/
+buf_pool_free_instance(
+/*===================*/
+	buf_pool_t*	buf_pool)	/* in,own: buffer pool instance
+					to free */
 {
 	buf_chunk_t*	chunk;
 	buf_chunk_t*	chunks;
@@ -1135,6 +1283,139 @@ buf_pool_free(void)
 }
 
 /********************************************************************//**
+Creates the buffer pool.
+@return	DB_SUCCESS if success, DB_ERROR if not enough memory or error */
+UNIV_INTERN
+ulint
+buf_pool_init(
+/*==========*/
+	ulint	total_size,	/*!< in: size of the total pool in bytes */
+	ulint	n_instances)	/*!< in: number of instances */
+{
+	ulint	i;
+
+	/* We create an extra buffer pool instance, this instance is used
+	for flushing the flush lists, to keep track of n_flush for all
+	the buffer pools and also used as a waiting object during flushing. */
+	for (i = 0; i < n_instances; i++) {
+		buf_pool_t*	ptr;
+		ulint		size;
+
+		ptr = mem_zalloc(sizeof(*ptr));
+
+		size = total_size / n_instances;
+
+		buf_pool_ptr[i] = ptr;
+
+		if (buf_pool_init_instance(ptr, size, i) != DB_SUCCESS) {
+
+			mem_free(buf_pool_ptr[i]);
+
+			/* Free all the instances created so far. */
+			buf_pool_free(i);
+
+			return(DB_ERROR);
+		}
+	}
+
+	buf_pool_set_sizes();
+	buf_LRU_old_ratio_update(100 * 3/ 8, FALSE);
+
+	btr_search_sys_create(buf_pool_get_curr_size() / sizeof(void*) / 64);
+
+	return(DB_SUCCESS);
+}
+
+/********************************************************************//**
+Frees the buffer pool at shutdown.  This must not be invoked before
+freeing all mutexes. */
+UNIV_INTERN
+void
+buf_pool_free(
+/*==========*/
+	ulint	n_instances)	/*!< in: numbere of instances to free */
+{
+	ulint	i;
+
+	for (i = 0; i < n_instances; i++) {
+		buf_pool_free_instance(buf_pool_from_array(i));
+		buf_pool_ptr[i] = NULL;
+	}
+}
+
+/********************************************************************//**
+Drops adaptive hash index for a buffer pool instance. */
+static
+void
+buf_pool_drop_hash_index_instance(
+/*==============================*/
+	buf_pool_t*	buf_pool,		/*!< in: buffer pool instance */
+	ibool*		released_search_latch)	/*!< out: flag for signalling
+						whether the search latch was
+						released */
+{
+	buf_chunk_t*	chunks	= buf_pool->chunks;
+	buf_chunk_t*	chunk	= chunks + buf_pool->n_chunks;
+
+	while (--chunk >= chunks) {
+		ulint		i;
+		buf_block_t*	block	= chunk->blocks;
+
+		for (i = chunk->size; i--; block++) {
+			/* block->is_hashed cannot be modified
+			when we have an x-latch on btr_search_latch;
+			see the comment in buf0buf.h */
+			
+			if (!block->is_hashed) {
+				continue;
+			}
+			
+			/* To follow the latching order, we
+			have to release btr_search_latch
+			before acquiring block->latch. */
+			rw_lock_x_unlock(&btr_search_latch);
+			/* When we release the search latch,
+			we must rescan all blocks, because
+			some may become hashed again. */
+			*released_search_latch = TRUE;
+			
+			rw_lock_x_lock(&block->lock);
+			
+			/* This should be guaranteed by the
+			callers, which will be holding
+			btr_search_enabled_mutex. */
+			ut_ad(!btr_search_enabled);
+			
+			/* Because we did not buffer-fix the
+			block by calling buf_block_get_gen(),
+			it is possible that the block has been
+			allocated for some other use after
+			btr_search_latch was released above.
+			We do not care which file page the
+			block is mapped to.  All we want to do
+			is to drop any hash entries referring
+			to the page. */
+			
+			/* It is possible that
+			block->page.state != BUF_FILE_PAGE.
+			Even that does not matter, because
+			btr_search_drop_page_hash_index() will
+			check block->is_hashed before doing
+			anything.  block->is_hashed can only
+			be set on uncompressed file pages. */
+			
+			btr_search_drop_page_hash_index(block);
+			
+			rw_lock_x_unlock(&block->lock);
+			
+			rw_lock_x_lock(&btr_search_latch);
+			
+			ut_ad(!btr_search_enabled);
+		}
+	}
+}
+ 
+/********************************************************************//**
 Drops the adaptive hash index.  To prevent a livelock, this function
 is only to be called while holding btr_search_latch and while
 btr_search_enabled == FALSE. */
@@ -1151,69 +1432,19 @@ buf_pool_drop_hash_index(void)
 	ut_ad(!btr_search_enabled);
 
 	do {
-		buf_chunk_t*	chunks	= buf_pool->chunks;
-		buf_chunk_t*	chunk	= chunks + buf_pool->n_chunks;
+ 		ulint	i;
 
 		released_search_latch = FALSE;
 
-		while (--chunk >= chunks) {
-			buf_block_t*	block	= chunk->blocks;
-			ulint		i	= chunk->size;
-
-			for (; i--; block++) {
-				/* block->is_hashed cannot be modified
-				when we have an x-latch on btr_search_latch;
-				see the comment in buf0buf.h */
+		for (i = 0; i < srv_buf_pool_instances; i++) {
+ 			buf_pool_t*	buf_pool;
 
-				if (buf_block_get_state(block)
-				    != BUF_BLOCK_FILE_PAGE
-				    || !block->is_hashed) {
-					continue;
-				}
+			buf_pool = buf_pool_from_array(i);
 
-				/* To follow the latching order, we
-				have to release btr_search_latch
-				before acquiring block->latch. */
-				rw_lock_x_unlock(&btr_search_latch);
-				/* When we release the search latch,
-				we must rescan all blocks, because
-				some may become hashed again. */
-				released_search_latch = TRUE;
-
-				rw_lock_x_lock(&block->lock);
-
-				/* This should be guaranteed by the
-				callers, which will be holding
-				btr_search_enabled_mutex. */
-				ut_ad(!btr_search_enabled);
-
-				/* Because we did not buffer-fix the
-				block by calling buf_block_get_gen(),
-				it is possible that the block has been
-				allocated for some other use after
-				btr_search_latch was released above.
-				We do not care which file page the
-				block is mapped to.  All we want to do
-				is to drop any hash entries referring
-				to the page. */
-
-				/* It is possible that
-				block->page.state != BUF_FILE_PAGE.
-				Even that does not matter, because
-				btr_search_drop_page_hash_index() will
-				check block->is_hashed before doing
-				anything.  block->is_hashed can only
-				be set on uncompressed file pages. */
-
-				btr_search_drop_page_hash_index(block);
-
-				rw_lock_x_unlock(&block->lock);
-
-				rw_lock_x_lock(&btr_search_latch);
-
-				ut_ad(!btr_search_enabled);
-			}
+			buf_pool_drop_hash_index_instance(
+				buf_pool, &released_search_latch);
 		}
+
 	} while (released_search_latch);
 }
 
@@ -1232,16 +1463,18 @@ buf_relocate(
 {
 	buf_page_t*	b;
 	ulint		fold;
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 	ut_a(buf_page_get_io_fix(bpage) == BUF_IO_NONE);
 	ut_a(bpage->buf_fix_count == 0);
 	ut_ad(bpage->in_LRU_list);
 	ut_ad(!bpage->in_zip_hash);
 	ut_ad(bpage->in_page_hash);
-	ut_ad(bpage == buf_page_hash_get(bpage->space, bpage->offset));
-	ut_ad(!buf_pool_watch_is(bpage));
+	ut_ad(bpage == buf_page_hash_get(buf_pool,
+			       		 bpage->space, bpage->offset));
+	ut_ad(!buf_pool_watch_is_sentinel(buf_pool, bpage));
 #ifdef UNIV_DEBUG
 	switch (buf_page_get_state(bpage)) {
 	case BUF_BLOCK_ZIP_FREE:
@@ -1300,12 +1533,13 @@ buf_relocate(
 }
 
 /********************************************************************//**
-Shrinks the buffer pool. */
+Shrinks a buffer pool instance. */
 static
 void
-buf_pool_shrink(
-/*============*/
-	ulint	chunk_size)	/*!< in: number of pages to remove */
+buf_pool_shrink_instance(
+/*=====================*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		chunk_size)	/*!< in: number of pages to remove */
 {
 	buf_chunk_t*	chunks;
 	buf_chunk_t*	chunk;
@@ -1314,11 +1548,11 @@ buf_pool_shrink(
 	buf_chunk_t*	max_chunk;
 	buf_chunk_t*	max_free_chunk;
 
-	ut_ad(!buf_pool_mutex_own());
+	ut_ad(!buf_pool_mutex_own(buf_pool));
 
 try_again:
 	btr_search_disable(); /* Empty the adaptive hash index again */
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 shrink_again:
 	if (buf_pool->n_chunks <= 1) {
@@ -1381,7 +1615,7 @@ shrink_again:
 
 			mutex_enter(&block->mutex);
 			/* The following calls will temporarily
-			release block->mutex and buf_pool_mutex.
+			release block->mutex and buf_pool->mutex.
 			Therefore, we have to always retry,
 			even if !dirty && !nonfree. */
 
@@ -1397,7 +1631,7 @@ shrink_again:
 			mutex_exit(&block->mutex);
 		}
 
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		/* Request for a flush of the chunk if it helps.
 		Do not flush if there are non-free blocks, since
@@ -1406,10 +1640,10 @@ shrink_again:
 			/* Avoid busy-waiting. */
 			os_thread_sleep(100000);
 		} else if (dirty
-			   && buf_flush_batch(BUF_FLUSH_LRU, dirty, 0)
-			   == ULINT_UNDEFINED) {
+			   && buf_flush_LRU(buf_pool, dirty)
+			      == ULINT_UNDEFINED) {
 
-			buf_flush_wait_batch_end(BUF_FLUSH_LRU);
+			buf_flush_wait_batch_end(buf_pool, BUF_FLUSH_LRU);
 		}
 
 		goto try_again;
@@ -1418,7 +1652,7 @@ shrink_again:
 	max_size = max_free_size;
 	max_chunk = max_free_chunk;
 
-	srv_buf_pool_old_size = srv_buf_pool_size;
+	buf_pool->old_pool_size = buf_pool->curr_pool_size;
 
 	/* Rewrite buf_pool->chunks.  Copy everything but max_chunk. */
 	chunks = mem_alloc((buf_pool->n_chunks - 1) * sizeof *chunks);
@@ -1430,9 +1664,9 @@ shrink_again:
 	       - (max_chunk + 1));
 	ut_a(buf_pool->curr_size > max_chunk->size);
 	buf_pool->curr_size -= max_chunk->size;
-	srv_buf_pool_curr_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
+	buf_pool->curr_pool_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
 	chunk_size -= max_chunk->size;
-	buf_chunk_free(max_chunk);
+	buf_chunk_free(buf_pool, max_chunk);
 	mem_free(buf_pool->chunks);
 	buf_pool->chunks = chunks;
 	buf_pool->n_chunks--;
@@ -1442,29 +1676,53 @@ shrink_again:
 
 		goto shrink_again;
 	}
+	goto func_exit;
 
 func_done:
-	srv_buf_pool_old_size = srv_buf_pool_size;
+	buf_pool->old_pool_size = buf_pool->curr_pool_size;
 func_exit:
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 	btr_search_enable();
 }
 
 /********************************************************************//**
-Rebuild buf_pool->page_hash. */
+Shrinks the buffer pool. */
 static
 void
-buf_pool_page_hash_rebuild(void)
-/*============================*/
+buf_pool_shrink(
+/*============*/
+	ulint	chunk_size)	/*!< in: number of pages to remove */
+{
+	ulint	i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+		ulint		instance_chunk_size;
+
+		instance_chunk_size = chunk_size / srv_buf_pool_instances;
+		buf_pool = buf_pool_from_array(i);
+		buf_pool_shrink_instance(buf_pool, instance_chunk_size);
+	}
+
+	buf_pool_set_sizes();
+}
+
+/********************************************************************//**
+Rebuild buf_pool->page_hash for a buffer pool instance. */
+static
+void
+buf_pool_page_hash_rebuild_instance(
+/*================================*/
+	buf_pool_t*	buf_pool)		/*!< in: buffer pool instance */
 {
 	ulint		i;
-	ulint		n_chunks;
+	buf_page_t*	b;
 	buf_chunk_t*	chunk;
-	hash_table_t*	page_hash;
+	ulint		n_chunks;
 	hash_table_t*	zip_hash;
-	buf_page_t*	b;
+	hash_table_t*	page_hash;
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	/* Free, create, and populate the hash table. */
 	hash_table_free(buf_pool->page_hash);
@@ -1517,7 +1775,7 @@ buf_pool_page_hash_rebuild(void)
 			    buf_page_address_fold(b->space, b->offset), b);
 	}
 
-	buf_flush_list_mutex_enter();
+	buf_flush_list_mutex_enter(buf_pool);
 	for (b = UT_LIST_GET_FIRST(buf_pool->flush_list); b;
 	     b = UT_LIST_GET_NEXT(list, b)) {
 		ut_ad(b->in_flush_list);
@@ -1545,85 +1803,24 @@ buf_pool_page_hash_rebuild(void)
 		}
 	}
 
-	buf_flush_list_mutex_exit();
-	buf_pool_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
+	buf_pool_mutex_exit(buf_pool);
 }
 
-/********************************************************************//**
-Resizes the buffer pool. */
-UNIV_INTERN
-void
-buf_pool_resize(void)
-/*=================*/
-{
-	buf_pool_mutex_enter();
-
-	if (srv_buf_pool_old_size == srv_buf_pool_size) {
-
-		buf_pool_mutex_exit();
-		return;
-	}
-
-	if (srv_buf_pool_curr_size + 1048576 > srv_buf_pool_size) {
-
-		buf_pool_mutex_exit();
-
-		/* Disable adaptive hash indexes and empty the index
-		in order to free up memory in the buffer pool chunks. */
-		buf_pool_shrink((srv_buf_pool_curr_size - srv_buf_pool_size)
-				/ UNIV_PAGE_SIZE);
-	} else if (srv_buf_pool_curr_size + 1048576 < srv_buf_pool_size) {
-
-		/* Enlarge the buffer pool by at least one megabyte */
-
-		ulint		mem_size
-			= srv_buf_pool_size - srv_buf_pool_curr_size;
-		buf_chunk_t*	chunks;
-		buf_chunk_t*	chunk;
-
-		chunks = mem_alloc((buf_pool->n_chunks + 1) * sizeof *chunks);
-
-		memcpy(chunks, buf_pool->chunks, buf_pool->n_chunks
-		       * sizeof *chunks);
-
-		chunk = &chunks[buf_pool->n_chunks];
-
-		if (!buf_chunk_init(chunk, mem_size)) {
-			mem_free(chunks);
-		} else {
-			buf_pool->curr_size += chunk->size;
-			srv_buf_pool_curr_size = buf_pool->curr_size
-				* UNIV_PAGE_SIZE;
-			mem_free(buf_pool->chunks);
-			buf_pool->chunks = chunks;
-			buf_pool->n_chunks++;
-		}
-
-		srv_buf_pool_old_size = srv_buf_pool_size;
-		buf_pool_mutex_exit();
-	}
-
-	buf_pool_page_hash_rebuild();
-}
-
-/** Maximum number of concurrent buffer pool watches */
-#define BUF_POOL_WATCH_SIZE 1
-/** Sentinel records for buffer pool watches. Protected by buf_pool_mutex. */
-static buf_page_t buf_pool_watch[BUF_POOL_WATCH_SIZE];
-
 /********************************************************************
 Determine if a block is a sentinel for a buffer pool watch.
 @return	TRUE if a sentinel for a buffer pool watch, FALSE if not */
 UNIV_INTERN
 ibool
-buf_pool_watch_is(
-/*==============*/
-	const buf_page_t*	bpage)	/*!< in: block */
+buf_pool_watch_is_sentinel(
+/*=======================*/
+	buf_pool_t*		buf_pool,	/*!< buffer pool instance */
+	const buf_page_t*	bpage)		/*!< in: block */
 {
 	ut_ad(buf_page_in_file(bpage));
 
-	if (UNIV_LIKELY(bpage < &buf_pool_watch[0]
-			|| bpage >= &buf_pool_watch[BUF_POOL_WATCH_SIZE])) {
+	if (bpage < &buf_pool->watch[0]
+	    || bpage >= &buf_pool->watch[BUF_POOL_WATCH_SIZE]) {
 
 		ut_ad(buf_page_get_state(bpage) != BUF_BLOCK_ZIP_PAGE
 		      || bpage->zip.data != NULL);
@@ -1653,13 +1850,14 @@ buf_pool_watch_set(
 {
 	buf_page_t*	bpage;
 	ulint		i;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
-	bpage = buf_page_hash_get_low(space, offset, fold);
+	bpage = buf_page_hash_get_low(buf_pool, space, offset, fold);
 
 	if (UNIV_LIKELY_NULL(bpage)) {
-		if (!buf_pool_watch_is(bpage)) {
+		if (!buf_pool_watch_is_sentinel(buf_pool, bpage)) {
 			/* The page was loaded meanwhile. */
 			return(bpage);
 		}
@@ -1669,7 +1867,7 @@ buf_pool_watch_set(
 	}
 
 	for (i = 0; i < BUF_POOL_WATCH_SIZE; i++) {
-		bpage = &buf_pool_watch[i];
+		bpage = &buf_pool->watch[i];
 
 		ut_ad(bpage->access_time == 0);
 		ut_ad(bpage->newest_modification == 0);
@@ -1685,7 +1883,7 @@ buf_pool_watch_set(
 			/* bpage is pointing to buf_pool_watch[],
 			which is protected by buf_pool_mutex.
 			Normally, buf_page_t objects are protected by
-			buf_block_t::mutex or buf_pool_zip_mutex or both. */
+			buf_block_t::mutex or buf_pool->zip_mutex or both. */
 
 			bpage->state = BUF_BLOCK_ZIP_PAGE;
 			bpage->space = space;
@@ -1715,6 +1913,123 @@ buf_pool_watch_set(
 	return(NULL);
 }
 
+/********************************************************************//**
+Rebuild buf_pool->page_hash. */
+static
+void
+buf_pool_page_hash_rebuild(void)
+/*============================*/
+{
+	ulint   i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_page_hash_rebuild_instance(buf_pool_from_array(i));
+	}
+}
+
+/********************************************************************//**
+Increase the buffer pool size of one buffer pool instance. */
+static
+void
+buf_pool_increase_instance(
+/*=======================*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instane */
+	ulint		change_size)	/*!< in: new size of the pool */
+{
+	buf_chunk_t*	chunks;
+	buf_chunk_t*	chunk;
+
+	buf_pool_mutex_enter(buf_pool);
+	chunks = mem_alloc((buf_pool->n_chunks + 1) * sizeof *chunks);
+
+	memcpy(chunks, buf_pool->chunks, buf_pool->n_chunks * sizeof *chunks);
+
+	chunk = &chunks[buf_pool->n_chunks];
+
+	if (!buf_chunk_init(buf_pool, chunk, change_size)) {
+		mem_free(chunks);
+	} else {
+		buf_pool->old_pool_size = buf_pool->curr_pool_size;
+		buf_pool->curr_size += chunk->size;
+		buf_pool->curr_pool_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
+		mem_free(buf_pool->chunks);
+		buf_pool->chunks = chunks;
+		buf_pool->n_chunks++;
+	}
+
+	buf_pool_mutex_exit(buf_pool);
+}
+
+/********************************************************************//**
+Increase the buffer pool size. */
+static
+void
+buf_pool_increase(
+/*==============*/
+	ulint   change_size)
+{
+	ulint   i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_increase_instance(
+			buf_pool_from_array(i),
+			change_size / srv_buf_pool_instances);
+	}
+
+	buf_pool_set_sizes();
+}
+
+/********************************************************************//**
+Resizes the buffer pool. */
+UNIV_INTERN
+void
+buf_pool_resize(void)
+/*=================*/
+{
+	ulint	change_size;
+	ulint	min_change_size = 1048576 * srv_buf_pool_instances;
+
+	buf_pool_mutex_enter_all();
+  
+  	if (srv_buf_pool_old_size == srv_buf_pool_size) {
+  
+		buf_pool_mutex_exit_all();
+
+  		return;
+
+  	} else if (srv_buf_pool_curr_size + min_change_size
+		   > srv_buf_pool_size) {
+  
+		change_size = (srv_buf_pool_curr_size - srv_buf_pool_size)
+			    / UNIV_PAGE_SIZE;
+
+		buf_pool_mutex_exit_all();
+  
+  		/* Disable adaptive hash indexes and empty the index
+  		in order to free up memory in the buffer pool chunks. */
+		buf_pool_shrink(change_size);
+
+	} else if (srv_buf_pool_curr_size + min_change_size
+		   < srv_buf_pool_size) {
+ 
+  		/* Enlarge the buffer pool by at least one megabyte */
+  
+		change_size = srv_buf_pool_size - srv_buf_pool_curr_size;
+
+		buf_pool_mutex_exit_all();
+
+		buf_pool_increase(change_size);
+	} else {
+		srv_buf_pool_size = srv_buf_pool_old_size;
+
+		buf_pool_mutex_exit_all();
+
+		return;
+	}
+  
+  	buf_pool_page_hash_rebuild();
+}
+ 
 /****************************************************************//**
 Remove the sentinel block for the watch before replacing it with a real block.
 buf_page_watch_clear() or buf_page_watch_occurred() will notice that
@@ -1724,10 +2039,12 @@ static
 void
 buf_pool_watch_remove(
 /*==================*/
-	ulint		fold,	/*!< in: buf_page_address_fold(space, offset) */
-	buf_page_t*	watch)	/*!< in/out: sentinel for watch */
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	ulint		fold,		/*!< in: buf_page_address_fold(
+					space, offset) */
+	buf_page_t*	watch)		/*!< in/out: sentinel for watch */
 {
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	HASH_DELETE(buf_page_t, hash, buf_pool->page_hash, fold, watch);
 	ut_d(watch->in_page_hash = FALSE);
@@ -1746,16 +2063,18 @@ buf_pool_watch_unset(
 	ulint	offset)	/*!< in: page number */
 {
 	buf_page_t*	bpage;
-	ulint		fold	= buf_page_address_fold(space, offset);
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
+	ulint		fold = buf_page_address_fold(space, offset);
 
-	buf_pool_mutex_enter();
-	bpage = buf_page_hash_get_low(space, offset, fold);
+	buf_pool_mutex_enter(buf_pool);
+	bpage = buf_page_hash_get_low(buf_pool, space, offset, fold);
 	/* The page must exist because buf_pool_watch_set()
 	increments buf_fix_count. */
 	ut_a(bpage);
 
-	if (UNIV_UNLIKELY(!buf_pool_watch_is(bpage))) {
+	if (UNIV_UNLIKELY(!buf_pool_watch_is_sentinel(buf_pool, bpage))) {
 		mutex_t* mutex = buf_page_get_mutex(bpage);
+
 		mutex_enter(mutex);
 		ut_a(bpage->buf_fix_count > 0);
 		bpage->buf_fix_count--;
@@ -1764,11 +2083,11 @@ buf_pool_watch_unset(
 		ut_a(bpage->buf_fix_count > 0);
 
 		if (UNIV_LIKELY(!--bpage->buf_fix_count)) {
-			buf_pool_watch_remove(fold, bpage);
+			buf_pool_watch_remove(buf_pool, fold, bpage);
 		}
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 }
 
 /****************************************************************//**
@@ -1783,18 +2102,19 @@ buf_pool_watch_occurred(
 	ulint	space,	/*!< in: space id */
 	ulint	offset)	/*!< in: page number */
 {
+	ibool		ret;
 	buf_page_t*	bpage;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 	ulint		fold	= buf_page_address_fold(space, offset);
-	ibool		ret;
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	bpage = buf_page_hash_get_low(space, offset, fold);
+	bpage = buf_page_hash_get_low(buf_pool, space, offset, fold);
 	/* The page must exist because buf_pool_watch_set()
 	increments buf_fix_count. */
 	ut_a(bpage);
-	ret = !buf_pool_watch_is(bpage);
-	buf_pool_mutex_exit();
+	ret = !buf_pool_watch_is_sentinel(buf_pool, bpage);
+	buf_pool_mutex_exit(buf_pool);
 
 	return(ret);
 }
@@ -1809,13 +2129,15 @@ buf_page_make_young(
 /*================*/
 	buf_page_t*	bpage)	/*!< in: buffer block of a file page */
 {
-	buf_pool_mutex_enter();
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+
+	buf_pool_mutex_enter(buf_pool);
 
 	ut_a(buf_page_in_file(bpage));
 
 	buf_LRU_make_block_young(bpage);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 }
 
 /********************************************************************//**
@@ -1833,18 +2155,20 @@ buf_page_set_accessed_make_young(
 					read under mutex protection,
 					or 0 if unknown */
 {
-	ut_ad(!buf_pool_mutex_own());
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+
+	ut_ad(!buf_pool_mutex_own(buf_pool));
 	ut_a(buf_page_in_file(bpage));
 
 	if (buf_page_peek_if_too_old(bpage)) {
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 		buf_LRU_make_block_young(bpage);
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 	} else if (!access_time) {
 		ulint	time_ms = ut_time_ms();
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 		buf_page_set_accessed(bpage, time_ms);
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 	}
 }
 
@@ -1859,17 +2183,18 @@ buf_reset_check_index_page_at_flush(
 	ulint	offset)	/*!< in: page number */
 {
 	buf_block_t*	block;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	block = (buf_block_t*) buf_page_hash_get(space, offset);
+	block = (buf_block_t*) buf_page_hash_get(buf_pool, space, offset);
 
 	if (block && buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE) {
-		ut_ad(!buf_pool_watch_is(&block->page));
+		ut_ad(!buf_pool_watch_is_sentinel(buf_pool, &block->page));
 		block->check_index_page_at_flush = FALSE;
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 }
 
 /********************************************************************//**
@@ -1886,19 +2211,20 @@ buf_page_peek_if_search_hashed(
 {
 	buf_block_t*	block;
 	ibool		is_hashed;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	block = (buf_block_t*) buf_page_hash_get(space, offset);
+	block = (buf_block_t*) buf_page_hash_get(buf_pool, space, offset);
 
 	if (!block || buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE) {
 		is_hashed = FALSE;
 	} else {
-		ut_ad(!buf_pool_watch_is(&block->page));
+		ut_ad(!buf_pool_watch_is_sentinel(buf_pool, &block->page));
 		is_hashed = block->is_hashed;
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	return(is_hashed);
 }
@@ -1918,17 +2244,18 @@ buf_page_set_file_page_was_freed(
 	ulint	offset)	/*!< in: page number */
 {
 	buf_page_t*	bpage;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	bpage = buf_page_hash_get(space, offset);
+	bpage = buf_page_hash_get(buf_pool, space, offset);
 
 	if (bpage) {
-		ut_ad(!buf_pool_watch_is(bpage));
+		ut_ad(!buf_pool_watch_is_sentinel(buf_pool, bpage));
 		bpage->file_page_was_freed = TRUE;
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	return(bpage);
 }
@@ -1947,17 +2274,18 @@ buf_page_reset_file_page_was_freed(
 	ulint	offset)	/*!< in: page number */
 {
 	buf_page_t*	bpage;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	bpage = buf_page_hash_get(space, offset);
+	bpage = buf_page_hash_get(buf_pool, space, offset);
 
 	if (bpage) {
-		ut_ad(!buf_pool_watch_is(bpage));
+		ut_ad(!buf_pool_watch_is_sentinel(buf_pool, bpage));
 		bpage->file_page_was_freed = FALSE;
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	return(bpage);
 }
@@ -1984,6 +2312,7 @@ buf_page_get_zip(
 	mutex_t*	block_mutex;
 	ibool		must_read;
 	unsigned	access_time;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
 #ifndef UNIV_LOG_DEBUG
 	ut_ad(!ibuf_inside());
@@ -1991,17 +2320,17 @@ buf_page_get_zip(
 	buf_pool->stat.n_page_gets++;
 
 	for (;;) {
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 lookup:
-		bpage = buf_page_hash_get(space, offset);
+		bpage = buf_page_hash_get(buf_pool, space, offset);
 		if (bpage) {
-			ut_ad(!buf_pool_watch_is(bpage));
+			ut_ad(!buf_pool_watch_is_sentinel(buf_pool, bpage));
 			break;
 		}
 
 		/* Page not in buf_pool: needs to be read from file */
 
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		buf_read_page(space, zip_size, offset);
 
@@ -2013,11 +2342,11 @@ lookup:
 	if (UNIV_UNLIKELY(!bpage->zip.data)) {
 		/* There is no compressed page. */
 err_exit:
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 		return(NULL);
 	}
 
-	ut_ad(!buf_pool_watch_is(bpage));
+	ut_ad(!buf_pool_watch_is_sentinel(buf_pool, bpage));
 
 	switch (buf_page_get_state(bpage)) {
 	case BUF_BLOCK_NOT_USED:
@@ -2028,7 +2357,7 @@ err_exit:
 		break;
 	case BUF_BLOCK_ZIP_PAGE:
 	case BUF_BLOCK_ZIP_DIRTY:
-		block_mutex = &buf_pool_zip_mutex;
+		block_mutex = &buf_pool->zip_mutex;
 		mutex_enter(block_mutex);
 		bpage->buf_fix_count++;
 		goto got_block;
@@ -2056,7 +2385,7 @@ got_block:
 	must_read = buf_page_get_io_fix(bpage) == BUF_IO_READ;
 	access_time = buf_page_is_accessed(bpage);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	mutex_exit(block_mutex);
 
@@ -2186,13 +2515,16 @@ buf_zip_decompress(
 
 #ifndef UNIV_HOTBACKUP
 /*******************************************************************//**
-Gets the block to whose frame the pointer is pointing to.
-@return	pointer to block, never NULL */
+Gets the block to whose frame the pointer is pointing to if found
+in this buffer pool instance.
+@return	pointer to block */
 UNIV_INTERN
 buf_block_t*
-buf_block_align(
-/*============*/
-	const byte*	ptr)	/*!< in: pointer to a frame */
+buf_block_align_instance(
+/*=====================*/
+ 	buf_pool_t*	buf_pool,	/*!< in: buffer in which the block
+					resides */
+	const byte*	ptr)		/*!< in: pointer to a frame */
 {
 	buf_chunk_t*	chunk;
 	ulint		i;
@@ -2218,7 +2550,7 @@ buf_block_align(
 			ut_ad(block->frame == page_align(ptr));
 #ifdef UNIV_DEBUG
 			/* A thread that updates these fields must
-			hold buf_pool_mutex and block->mutex.  Acquire
+			hold buf_pool->mutex and block->mutex.  Acquire
 			only the latter. */
 			mutex_enter(&block->mutex);
 
@@ -2267,6 +2599,30 @@ buf_block_align(
 		}
 	}
 
+	return(NULL);
+}
+
+/*******************************************************************//**
+Gets the block to whose frame the pointer is pointing to.
+@return	pointer to block, never NULL */
+UNIV_INTERN
+buf_block_t*
+buf_block_align(
+/*============*/
+	const byte*	ptr)	/*!< in: pointer to a frame */
+{
+	ulint		i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_block_t*	block;
+
+		block = buf_block_align_instance(
+			buf_pool_from_array(i), ptr);
+		if (block) {
+			return(block);
+		}
+	}
+
 	/* The block should always be found. */
 	ut_error;
 	return(NULL);
@@ -2274,14 +2630,15 @@ buf_block_align(
 
 /********************************************************************//**
 Find out if a pointer belongs to a buf_block_t. It can be a pointer to
-the buf_block_t itself or a member of it
+the buf_block_t itself or a member of it. This functions checks one of
+the buffer pool instances.
 @return	TRUE if ptr belongs to a buf_block_t struct */
-UNIV_INTERN
+static
 ibool
-buf_pointer_is_block_field(
-/*=======================*/
-	const void*		ptr)	/*!< in: pointer not
-					dereferenced */
+buf_pointer_is_block_field_instance(
+/*================================*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	const void*	ptr)		/*!< in: pointer not dereferenced */
 {
 	const buf_chunk_t*		chunk	= buf_pool->chunks;
 	const buf_chunk_t* const	echunk	= chunk + buf_pool->n_chunks;
@@ -2302,23 +2659,49 @@ buf_pointer_is_block_field(
 }
 
 /********************************************************************//**
+Find out if a pointer belongs to a buf_block_t. It can be a pointer to
+the buf_block_t itself or a member of it
+@return	TRUE if ptr belongs to a buf_block_t struct */
+UNIV_INTERN
+ibool
+buf_pointer_is_block_field(
+/*=======================*/
+	const void*	ptr)	/*!< in: pointer not dereferenced */
+{
+	ulint	i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		ibool	found;
+
+		found = buf_pointer_is_block_field_instance(
+			buf_pool_from_array(i), ptr);
+		if (found) {
+			return(TRUE);
+		}
+	}
+
+	return(FALSE);
+}
+
+/********************************************************************//**
 Find out if a buffer block was created by buf_chunk_init().
 @return	TRUE if "block" has been added to buf_pool->free by buf_chunk_init() */
 static
 ibool
 buf_block_is_uncompressed(
 /*======================*/
-	const buf_block_t*	block)	/*!< in: pointer to block,
-					not dereferenced */
+	buf_pool_t*		buf_pool,	/*!< in: buffer pool instance */
+	const buf_block_t*	block)		/*!< in: pointer to block,
+						not dereferenced */
 {
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	if (UNIV_UNLIKELY((((ulint) block) % sizeof *block) != 0)) {
 		/* The pointer should be aligned. */
 		return(FALSE);
 	}
 
-	return(buf_pointer_is_block_field((void *)block));
+	return(buf_pointer_is_block_field_instance(buf_pool, (void *)block));
 }
 
 /********************************************************************//**
@@ -2347,6 +2730,7 @@ buf_page_get_gen(
 	ulint		fix_type;
 	ibool		must_read;
 	ulint		retries = 0;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
 	ut_ad(mtr);
 	ut_ad(mtr->state == MTR_ACTIVE);
@@ -2367,7 +2751,7 @@ buf_page_get_gen(
 	fold = buf_page_address_fold(space, offset);
 loop:
 	block = guess;
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	if (block) {
 		/* If the guess is a compressed page descriptor that
@@ -2378,7 +2762,7 @@ loop:
 		the guess may be pointing to a buffer pool chunk that
 		has been released when resizing the buffer pool. */
 
-		if (!buf_block_is_uncompressed(block)
+		if (!buf_block_is_uncompressed(buf_pool, block)
 		    || offset != block->page.offset
 		    || space != block->page.space
 		    || buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE) {
@@ -2391,12 +2775,12 @@ loop:
 	}
 
 	if (block == NULL) {
-		block = (buf_block_t*) buf_page_hash_get_low(space, offset,
-							     fold);
+		block = (buf_block_t*) buf_page_hash_get_low(
+			buf_pool, space, offset, fold);
 	}
 
 loop2:
-	if (block && buf_pool_watch_is(&block->page)) {
+	if (block && buf_pool_watch_is_sentinel(buf_pool, &block->page)) {
 		block = NULL;
 	}
 
@@ -2413,7 +2797,7 @@ loop2:
 			}
 		}
 
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		if (mode == BUF_GET_IF_IN_POOL
 		    || mode == BUF_GET_IF_IN_POOL_OR_WATCH) {
@@ -2461,7 +2845,7 @@ got_block:
 		/* The page is being read to buffer pool,
 		but we cannot wait around for the read to
 		complete. */
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		return(NULL);
 	}
@@ -2477,40 +2861,42 @@ got_block:
 	case BUF_BLOCK_ZIP_DIRTY:
 		bpage = &block->page;
 		/* Protect bpage->buf_fix_count. */
-		mutex_enter(&buf_pool_zip_mutex);
+		mutex_enter(&buf_pool->zip_mutex);
 
 		if (bpage->buf_fix_count
 		    || buf_page_get_io_fix(bpage) != BUF_IO_NONE) {
 			/* This condition often occurs when the buffer
 			is not buffer-fixed, but I/O-fixed by
 			buf_page_init_for_read(). */
-			mutex_exit(&buf_pool_zip_mutex);
+			mutex_exit(&buf_pool->zip_mutex);
 wait_until_unfixed:
 			/* The block is buffer-fixed or I/O-fixed.
 			Try again later. */
-			buf_pool_mutex_exit();
+			buf_pool_mutex_exit(buf_pool);
 			os_thread_sleep(WAIT_FOR_READ);
-
+  
 			goto loop;
 		}
 
 		/* Allocate an uncompressed page. */
-		buf_pool_mutex_exit();
-		mutex_exit(&buf_pool_zip_mutex);
+		buf_pool_mutex_exit(buf_pool);
+		mutex_exit(&buf_pool->zip_mutex);
 
-		block = buf_LRU_get_free_block(0);
+		block = buf_LRU_get_free_block(buf_pool, 0);
 		ut_a(block);
 
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 		mutex_enter(&block->mutex);
 
 		{
-			buf_page_t*	hash_bpage
-				= buf_page_hash_get_low(space, offset, fold);
+			buf_page_t*	hash_bpage;
+
+			hash_bpage = buf_page_hash_get_low(
+				buf_pool, space, offset, fold);
 
 			if (UNIV_UNLIKELY(bpage != hash_bpage)) {
 				/* The buf_pool->page_hash was modified
-				while buf_pool_mutex was released.
+				while buf_pool->mutex was released.
 				Free the block that was allocated. */
 
 				buf_LRU_block_free_non_file_page(block);
@@ -2526,7 +2912,7 @@ wait_until_unfixed:
 		     || buf_page_get_io_fix(bpage) != BUF_IO_NONE)) {
 
 			/* The block was buffer-fixed or I/O-fixed
-			while buf_pool_mutex was not held by this thread.
+			while buf_pool->mutex was not held by this thread.
 			Free the block that was allocated and try again.
 			This should be extremely unlikely. */
 
@@ -2539,7 +2925,7 @@ wait_until_unfixed:
 		/* Move the compressed page from bpage to block,
 		and uncompress it. */
 
-		mutex_enter(&buf_pool_zip_mutex);
+		mutex_enter(&buf_pool->zip_mutex);
 
 		buf_relocate(bpage, &block->page);
 		buf_block_init_low(block);
@@ -2574,15 +2960,15 @@ wait_until_unfixed:
 		UNIV_MEM_INVALID(bpage, sizeof *bpage);
 
 		mutex_exit(&block->mutex);
-		mutex_exit(&buf_pool_zip_mutex);
+		mutex_exit(&buf_pool->zip_mutex);
 		buf_pool->n_pend_unzip++;
 
-		buf_buddy_free(bpage, sizeof *bpage);
+		buf_buddy_free(buf_pool, bpage, sizeof *bpage);
 
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		/* Decompress the page and apply buffered operations
-		while not holding buf_pool_mutex or block->mutex. */
+		while not holding buf_pool->mutex or block->mutex. */
 		success = buf_zip_decompress(block, srv_use_checksums);
 
 		if (UNIV_LIKELY(success && !recv_no_ibuf_operations)) {
@@ -2591,7 +2977,7 @@ wait_until_unfixed:
 		}
 
 		/* Unfix and unlatch the block. */
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 		mutex_enter(&block->mutex);
 		block->page.buf_fix_count--;
 		buf_block_set_io_fix(block, BUF_IO_NONE);
@@ -2601,7 +2987,7 @@ wait_until_unfixed:
 
 		if (UNIV_UNLIKELY(!success)) {
 
-			buf_pool_mutex_exit();
+			buf_pool_mutex_exit(buf_pool);
 			return(NULL);
 		}
 
@@ -2629,7 +3015,7 @@ wait_until_unfixed:
 
 	access_time = buf_page_is_accessed(&block->page);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	buf_page_set_accessed_make_young(&block->page, access_time);
 
@@ -2714,6 +3100,7 @@ buf_page_optimistic_get(
 	ulint		line,	/*!< in: line where called */
 	mtr_t*		mtr)	/*!< in: mini-transaction */
 {
+	buf_pool_t*	buf_pool;
 	unsigned	access_time;
 	ibool		success;
 	ulint		fix_type;
@@ -2807,6 +3194,7 @@ buf_page_optimistic_get(
 	ut_a(ibuf_count_get(buf_block_get_space(block),
 			    buf_block_get_page_no(block)) == 0);
 #endif
+	buf_pool = buf_pool_from_block(block);
 	buf_pool->stat.n_page_gets++;
 
 	return(TRUE);
@@ -2828,6 +3216,7 @@ buf_page_get_known_nowait(
 	ulint		line,	/*!< in: line where called */
 	mtr_t*		mtr)	/*!< in: mini-transaction */
 {
+	buf_pool_t*	buf_pool;
 	ibool		success;
 	ulint		fix_type;
 
@@ -2856,10 +3245,12 @@ buf_page_get_known_nowait(
 
 	mutex_exit(&block->mutex);
 
+	buf_pool = buf_pool_from_block(block);
+
 	if (mode == BUF_MAKE_YOUNG && buf_page_peek_if_too_old(&block->page)) {
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 		buf_LRU_make_block_young(&block->page);
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 	} else if (!buf_page_is_accessed(&block->page)) {
 		/* Above, we do a dirty read on purpose, to avoid
 		mutex contention.  The field buf_page_t::access_time
@@ -2867,9 +3258,9 @@ buf_page_get_known_nowait(
 		field must be protected by mutex, however. */
 		ulint	time_ms = ut_time_ms();
 
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 		buf_page_set_accessed(&block->page, time_ms);
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 	}
 
 	ut_ad(!ibuf_inside() || (mode == BUF_KEEP_OLD));
@@ -2931,22 +3322,23 @@ buf_page_try_get_func(
 	buf_block_t*	block;
 	ibool		success;
 	ulint		fix_type;
+	buf_pool_t*	buf_pool = buf_pool_get(space_id, page_no);
 
 	ut_ad(mtr);
 	ut_ad(mtr->state == MTR_ACTIVE);
 
-	buf_pool_mutex_enter();
-	block = buf_block_hash_get(space_id, page_no);
+	buf_pool_mutex_enter(buf_pool);
+	block = buf_block_hash_get(buf_pool, space_id, page_no);
 
 	if (!block || buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE) {
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 		return(NULL);
 	}
 
-	ut_ad(!buf_pool_watch_is(&block->page));
+	ut_ad(!buf_pool_watch_is_sentinel(buf_pool, &block->page));
 
 	mutex_enter(&block->mutex);
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 	ut_a(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
@@ -3033,8 +3425,9 @@ buf_page_init(
 	buf_block_t*	block)	/*!< in: block to init */
 {
 	buf_page_t*	hash_page;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(mutex_own(&(block->mutex)));
 	ut_a(buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE);
 
@@ -3052,21 +3445,22 @@ buf_page_init(
 
 	buf_block_init_low(block);
 
-	block->lock_hash_val	= lock_rec_hash(space, offset);
+	block->lock_hash_val = lock_rec_hash(space, offset);
 
 	buf_page_init_low(&block->page);
 
 	/* Insert into the hash table of file pages */
 
-	hash_page = buf_page_hash_get_low(space, offset, fold);
+	hash_page = buf_page_hash_get_low(buf_pool, space, offset, fold);
 
 	if (UNIV_LIKELY(!hash_page)) {
-	} else if (UNIV_LIKELY(buf_pool_watch_is(hash_page))) {
+	} else if (buf_pool_watch_is_sentinel(buf_pool, hash_page)) {
 		/* Preserve the reference count. */
 		ulint	buf_fix_count = hash_page->buf_fix_count;
+
 		ut_a(buf_fix_count > 0);
 		block->page.buf_fix_count += buf_fix_count;
-		buf_pool_watch_remove(fold, hash_page);
+		buf_pool_watch_remove(buf_pool, fold, hash_page);
 	} else {
 		fprintf(stderr,
 			"InnoDB: Error: page %lu %lu already found"
@@ -3076,7 +3470,7 @@ buf_page_init(
 			(const void*) hash_page, (const void*) block);
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 		mutex_exit(&block->mutex);
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 		buf_print();
 		buf_LRU_print();
 		buf_validate();
@@ -3111,7 +3505,8 @@ buf_page_init_for_read(
 	ulint		space,	/*!< in: space id */
 	ulint		zip_size,/*!< in: compressed page size, or 0 */
 	ibool		unzip,	/*!< in: TRUE=request uncompressed page */
-	ib_int64_t	tablespace_version,/*!< in: prevents reading from a wrong
+	ib_int64_t	tablespace_version,
+				/*!< in: prevents reading from a wrong
 				version of the tablespace in case we have done
 				DISCARD + IMPORT */
 	ulint		offset)	/*!< in: page number */
@@ -3123,6 +3518,7 @@ buf_page_init_for_read(
 	ulint		fold;
 	ibool		lru	= FALSE;
 	void*		data;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
 	ut_ad(buf_pool);
 
@@ -3151,16 +3547,17 @@ buf_page_init_for_read(
 	    && UNIV_LIKELY(!recv_recovery_is_on())) {
 		block = NULL;
 	} else {
-		block = buf_LRU_get_free_block(0);
+		block = buf_LRU_get_free_block(buf_pool, 0);
 		ut_ad(block);
+		ut_ad(buf_pool_from_block(block) == buf_pool);
 	}
 
 	fold = buf_page_address_fold(space, offset);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	watch_page = buf_page_hash_get_low(space, offset, fold);
-	if (watch_page && !buf_pool_watch_is(watch_page)) {
+	watch_page = buf_page_hash_get_low(buf_pool, space, offset, fold);
+	if (watch_page && !buf_pool_watch_is_sentinel(buf_pool, watch_page)) {
 		/* The page is already in the buffer pool. */
 		watch_page = NULL;
 err_exit:
@@ -3187,6 +3584,8 @@ err_exit:
 		bpage = &block->page;
 		mutex_enter(&block->mutex);
 
+		ut_ad(buf_pool_from_bpage(bpage) == buf_pool);
+
 		buf_page_init(space, offset, fold, block);
 
 		/* The block must be put to the LRU list, to the old blocks */
@@ -3207,16 +3606,16 @@ err_exit:
 		if (UNIV_UNLIKELY(zip_size)) {
 			page_zip_set_size(&block->page.zip, zip_size);
 
-			/* buf_pool_mutex may be released and
+			/* buf_pool->mutex may be released and
 			reacquired by buf_buddy_alloc().  Thus, we
 			must release block->mutex in order not to
 			break the latching order in the reacquisition
-			of buf_pool_mutex.  We also must defer this
+			of buf_pool->mutex.  We also must defer this
 			operation until after the block descriptor has
 			been added to buf_pool->LRU and
 			buf_pool->page_hash. */
 			mutex_exit(&block->mutex);
-			data = buf_buddy_alloc(zip_size, &lru);
+			data = buf_buddy_alloc(buf_pool, zip_size, &lru);
 			mutex_enter(&block->mutex);
 			block->page.zip.data = data;
 
@@ -3240,21 +3639,28 @@ err_exit:
 		control block (bpage), in order to avoid the
 		invocation of buf_buddy_relocate_block() on
 		uninitialized data. */
-		data = buf_buddy_alloc(zip_size, &lru);
-		bpage = buf_buddy_alloc(sizeof *bpage, &lru);
+		data = buf_buddy_alloc(buf_pool, zip_size, &lru);
+		bpage = buf_buddy_alloc(buf_pool, sizeof *bpage, &lru);
+
+		/* Initialize the buf_pool pointer. */
+		bpage->buf_pool = buf_pool;
 
 		/* If buf_buddy_alloc() allocated storage from the LRU list,
-		it released and reacquired buf_pool_mutex.  Thus, we must
+		it released and reacquired buf_pool->mutex.  Thus, we must
 		check the page_hash again, as it may have been modified. */
 		if (UNIV_UNLIKELY(lru)) {
-			watch_page = buf_page_hash_get_low(space, offset, fold);
-			if (UNIV_UNLIKELY
-			    (watch_page && !buf_pool_watch_is(watch_page))) {
+
+			watch_page = buf_page_hash_get_low(
+				buf_pool, space, offset, fold);
+
+			if (watch_page
+			    && !buf_pool_watch_is_sentinel(buf_pool,
+				   			   watch_page)) {
 
 				/* The block was added by some other thread. */
 				watch_page = NULL;
-				buf_buddy_free(bpage, sizeof *bpage);
-				buf_buddy_free(data, zip_size);
+				buf_buddy_free(buf_pool, bpage, sizeof *bpage);
+				buf_buddy_free(buf_pool, data, zip_size);
 
 				bpage = NULL;
 				goto func_exit;
@@ -3265,7 +3671,7 @@ err_exit:
 		page_zip_set_size(&bpage->zip, zip_size);
 		bpage->zip.data = data;
 
-		mutex_enter(&buf_pool_zip_mutex);
+		mutex_enter(&buf_pool->zip_mutex);
 		UNIV_MEM_DESC(bpage->zip.data,
 			      page_zip_get_size(&bpage->zip), bpage);
 
@@ -3291,8 +3697,8 @@ err_exit:
 			ulint	buf_fix_count = watch_page->buf_fix_count;
 			ut_a(buf_fix_count > 0);
 			bpage->buf_fix_count += buf_fix_count;
-			ut_ad(buf_pool_watch_is(watch_page));
-			buf_pool_watch_remove(fold, watch_page);
+			ut_ad(buf_pool_watch_is_sentinel(buf_pool, watch_page));
+			buf_pool_watch_remove(buf_pool, fold, watch_page);
 		}
 
 		HASH_INSERT(buf_page_t, hash, buf_pool->page_hash, fold,
@@ -3304,12 +3710,12 @@ err_exit:
 
 		buf_page_set_io_fix(bpage, BUF_IO_READ);
 
-		mutex_exit(&buf_pool_zip_mutex);
+		mutex_exit(&buf_pool->zip_mutex);
 	}
 
 	buf_pool->n_pend_reads++;
 func_exit:
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	if (mode == BUF_READ_IBUF_PAGES_ONLY) {
 
@@ -3338,24 +3744,27 @@ buf_page_create(
 {
 	buf_frame_t*	frame;
 	buf_block_t*	block;
+	ulint		fold;
 	buf_block_t*	free_block	= NULL;
 	ulint		time_ms		= ut_time_ms();
-	ulint		fold;
+	buf_pool_t*	buf_pool 	= buf_pool_get(space, offset);
 
 	ut_ad(mtr);
 	ut_ad(mtr->state == MTR_ACTIVE);
 	ut_ad(space || !zip_size);
 
-	free_block = buf_LRU_get_free_block(0);
+	free_block = buf_LRU_get_free_block(buf_pool, 0);
 
 	fold = buf_page_address_fold(space, offset);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	block = (buf_block_t*) buf_page_hash_get_low(space, offset, fold);
+	block = (buf_block_t*) buf_page_hash_get_low(
+		buf_pool, space, offset, fold);
 
-	if (block && buf_page_in_file(&block->page)
-	    && !buf_pool_watch_is(&block->page)) {
+	if (block
+	    && buf_page_in_file(&block->page)
+	    && !buf_pool_watch_is_sentinel(buf_pool, &block->page)) {
 #ifdef UNIV_IBUF_COUNT_DEBUG
 		ut_a(ibuf_count_get(space, offset) == 0);
 #endif
@@ -3364,7 +3773,7 @@ buf_page_create(
 #endif /* UNIV_DEBUG_FILE_ACCESSES */
 
 		/* Page can be found in buf_pool */
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		buf_block_free(free_block);
 
@@ -3398,7 +3807,7 @@ buf_page_create(
 		ibool	lru;
 
 		/* Prevent race conditions during buf_buddy_alloc(),
-		which may release and reacquire buf_pool_mutex,
+		which may release and reacquire buf_pool->mutex,
 		by IO-fixing and X-latching the block. */
 
 		buf_page_set_io_fix(&block->page, BUF_IO_READ);
@@ -3406,13 +3815,13 @@ buf_page_create(
 
 		page_zip_set_size(&block->page.zip, zip_size);
 		mutex_exit(&block->mutex);
-		/* buf_pool_mutex may be released and reacquired by
+		/* buf_pool->mutex may be released and reacquired by
 		buf_buddy_alloc().  Thus, we must release block->mutex
 		in order not to break the latching order in
-		the reacquisition of buf_pool_mutex.  We also must
+		the reacquisition of buf_pool->mutex.  We also must
 		defer this operation until after the block descriptor
 		has been added to buf_pool->LRU and buf_pool->page_hash. */
-		data = buf_buddy_alloc(zip_size, &lru);
+		data = buf_buddy_alloc(buf_pool, zip_size, &lru);
 		mutex_enter(&block->mutex);
 		block->page.zip.data = data;
 
@@ -3430,7 +3839,7 @@ buf_page_create(
 
 	buf_page_set_accessed(&block->page, time_ms);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	mtr_memo_push(mtr, block, MTR_MEMO_BUF_FIX);
 
@@ -3442,7 +3851,7 @@ buf_page_create(
 	ibuf_merge_or_delete_for_page(NULL, space, offset, zip_size, TRUE);
 
 	/* Flush pages from the end of the LRU list if necessary */
-	buf_flush_free_margin();
+	buf_flush_free_margin(buf_pool);
 
 	frame = block->frame;
 
@@ -3478,6 +3887,7 @@ buf_page_io_complete(
 	buf_page_t*	bpage)	/*!< in: pointer to the block in question */
 {
 	enum buf_io_fix	io_type;
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
 	const ibool	uncompressed = (buf_page_get_state(bpage)
 					== BUF_BLOCK_FILE_PAGE);
 
@@ -3613,7 +4023,7 @@ corrupt:
 		}
 	}
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 	mutex_enter(buf_page_get_mutex(bpage));
 
 #ifdef UNIV_IBUF_COUNT_DEBUG
@@ -3677,22 +4087,57 @@ corrupt:
 #endif /* UNIV_DEBUG */
 
 	mutex_exit(buf_page_get_mutex(bpage));
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 }
 
 /*********************************************************************//**
-Invalidates the file pages in the buffer pool when an archive recovery is
-completed. All the file pages buffered must be in a replaceable state when
-this function is called: not latched and not modified. */
-UNIV_INTERN
+Asserts that all file pages in the buffer are in a replaceable state.
+@return	TRUE */
+static
+ibool
+buf_all_freed_instance(
+/*===================*/
+	buf_pool_t*	buf_pool)	/*!< in: buffer pool instancce */
+{
+	ulint		i;
+	buf_chunk_t*	chunk;
+
+	ut_ad(buf_pool);
+
+	buf_pool_mutex_enter(buf_pool);
+
+	chunk = buf_pool->chunks;
+
+	for (i = buf_pool->n_chunks; i--; chunk++) {
+
+		const buf_block_t* block = buf_chunk_not_freed(chunk);
+
+		if (UNIV_LIKELY_NULL(block)) {
+			fprintf(stderr,
+				"Page %lu %lu still fixed or dirty\n",
+				(ulong) block->page.space,
+				(ulong) block->page.offset);
+			ut_error;
+		}
+	}
+
+	buf_pool_mutex_exit(buf_pool);
+
+	return(TRUE);
+}
+
+/*********************************************************************//**
+Invalidates file pages in one buffer pool instance */
+static
 void
-buf_pool_invalidate(void)
-/*=====================*/
+buf_pool_invalidate_instance(
+/*=========================*/
+	buf_pool_t*	buf_pool)	/*!< in: buffer pool instance */
 {
 	ibool		freed;
 	enum buf_flush	i;
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	for (i = BUF_FLUSH_LRU; i < BUF_FLUSH_N_TYPES; i++) {
 
@@ -3708,23 +4153,23 @@ buf_pool_invalidate(void)
 		pool invalidation to proceed we must ensure there is NO
 		write activity happening. */
 		if (buf_pool->n_flush[i] > 0) {
-			buf_pool_mutex_exit();
-			buf_flush_wait_batch_end(i);
-			buf_pool_mutex_enter();
+			buf_pool_mutex_exit(buf_pool);
+			buf_flush_wait_batch_end(buf_pool, i);
+			buf_pool_mutex_enter(buf_pool);
 		}
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
-	ut_ad(buf_all_freed());
+	ut_ad(buf_all_freed_instance(buf_pool));
 
 	freed = TRUE;
 
 	while (freed) {
-		freed = buf_LRU_search_and_free_block(100);
+		freed = buf_LRU_search_and_free_block(buf_pool, 100);
 	}
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	ut_ad(UT_LIST_GET_LEN(buf_pool->LRU) == 0);
 	ut_ad(UT_LIST_GET_LEN(buf_pool->unzip_LRU) == 0);
@@ -3735,19 +4180,36 @@ buf_pool_invalidate(void)
 	buf_pool->LRU_flush_ended = 0;
 
 	memset(&buf_pool->stat, 0x00, sizeof(buf_pool->stat));
-	buf_refresh_io_stats();
+	buf_refresh_io_stats(buf_pool);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
+}
+
+/*********************************************************************//**
+Invalidates the file pages in the buffer pool when an archive recovery is
+completed. All the file pages buffered must be in a replaceable state when
+this function is called: not latched and not modified. */
+UNIV_INTERN
+void
+buf_pool_invalidate(void)
+/*=====================*/
+{
+	ulint   i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_invalidate_instance(buf_pool_from_array(i));
+	}
 }
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 /*********************************************************************//**
-Validates the buffer buf_pool data structure.
+Validates data in one buffer pool instance
 @return	TRUE */
-UNIV_INTERN
+static
 ibool
-buf_validate(void)
-/*==============*/
+buf_pool_validate_instance(
+/*=======================*/
+	buf_pool_t*	buf_pool)	/*!< in: buffer pool instance */
 {
 	buf_page_t*	b;
 	buf_chunk_t*	chunk;
@@ -3762,7 +4224,7 @@ buf_validate(void)
 
 	ut_ad(buf_pool);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	chunk = buf_pool->chunks;
 
@@ -3787,7 +4249,8 @@ buf_validate(void)
 				break;
 
 			case BUF_BLOCK_FILE_PAGE:
-				ut_a(buf_page_hash_get(buf_block_get_space(
+				ut_a(buf_page_hash_get(buf_pool,
+						       buf_block_get_space(
 							       block),
 						       buf_block_get_page_no(
 							       block))
@@ -3851,7 +4314,7 @@ buf_validate(void)
 		}
 	}
 
-	mutex_enter(&buf_pool_zip_mutex);
+	mutex_enter(&buf_pool->zip_mutex);
 
 	/* Check clean compressed-only blocks. */
 
@@ -3874,10 +4337,10 @@ buf_validate(void)
 		}
 
 		/* It is OK to read oldest_modification here because
-		we have acquired buf_pool_zip_mutex above which acts
+		we have acquired buf_pool->zip_mutex above which acts
 		as the 'block->mutex' for these bpages. */
 		ut_a(!b->oldest_modification);
-		ut_a(buf_page_hash_get(b->space, b->offset) == b);
+		ut_a(buf_page_hash_get(buf_pool, b->space, b->offset) == b);
 
 		n_lru++;
 		n_zip++;
@@ -3885,7 +4348,7 @@ buf_validate(void)
 
 	/* Check dirty blocks. */
 
-	buf_flush_list_mutex_enter();
+	buf_flush_list_mutex_enter(buf_pool);
 	for (b = UT_LIST_GET_FIRST(buf_pool->flush_list); b;
 	     b = UT_LIST_GET_NEXT(list, b)) {
 		ut_ad(b->in_flush_list);
@@ -3929,14 +4392,14 @@ buf_validate(void)
 			ut_error;
 			break;
 		}
-		ut_a(buf_page_hash_get(b->space, b->offset) == b);
+		ut_a(buf_page_hash_get(buf_pool, b->space, b->offset) == b);
 	}
 
 	ut_a(UT_LIST_GET_LEN(buf_pool->flush_list) == n_flush);
 
-	buf_flush_list_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
 
-	mutex_exit(&buf_pool_zip_mutex);
+	mutex_exit(&buf_pool->zip_mutex);
 
 	if (n_lru + n_free > buf_pool->curr_size + n_zip) {
 		fprintf(stderr, "n LRU %lu, n free %lu, pool %lu zip %lu\n",
@@ -3957,22 +4420,44 @@ buf_validate(void)
 	ut_a(buf_pool->n_flush[BUF_FLUSH_LIST] == n_list_flush);
 	ut_a(buf_pool->n_flush[BUF_FLUSH_LRU] == n_lru_flush);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	ut_a(buf_LRU_validate());
-	ut_a(buf_flush_validate());
+	ut_a(buf_flush_validate(buf_pool));
+
+	return(TRUE);
+}
+
+/*********************************************************************//**
+Validates the buffer buf_pool data structure.
+@return	TRUE */
+UNIV_INTERN
+ibool
+buf_validate(void)
+/*==============*/
+{
+	ulint	i;
 
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+
+		buf_pool_validate_instance(buf_pool);
+	}
 	return(TRUE);
 }
+
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
 #if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 /*********************************************************************//**
-Prints info of the buffer buf_pool data structure. */
-UNIV_INTERN
+Prints info of the buffer buf_pool data structure for one instance. */
+static
 void
-buf_print(void)
-/*===========*/
+buf_print_instance(
+/*===============*/
+	buf_pool_t*	buf_pool)
 {
 	dulint*		index_ids;
 	ulint*		counts;
@@ -3991,8 +4476,8 @@ buf_print(void)
 	index_ids = mem_alloc(sizeof(dulint) * size);
 	counts = mem_alloc(sizeof(ulint) * size);
 
-	buf_pool_mutex_enter();
-	buf_flush_list_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
+	buf_flush_list_mutex_enter(buf_pool);
 
 	fprintf(stderr,
 		"buf_pool size %lu\n"
@@ -4019,7 +4504,7 @@ buf_print(void)
 		(ulong) buf_pool->stat.n_pages_created,
 		(ulong) buf_pool->stat.n_pages_written);
 
-	buf_flush_list_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
 
 	/* Count the number of blocks belonging to each index in the buffer */
 
@@ -4061,7 +4546,7 @@ buf_print(void)
 		}
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	for (i = 0; i < n_found; i++) {
 		index = dict_index_get_if_in_cache(index_ids[i]);
@@ -4082,7 +4567,24 @@ buf_print(void)
 	mem_free(index_ids);
 	mem_free(counts);
 
-	ut_a(buf_validate());
+	ut_a(buf_pool_validate_instance(buf_pool));
+}
+
+/*********************************************************************//**
+Prints info of the buffer buf_pool data structure. */
+UNIV_INTERN
+void
+buf_print(void)
+/*===========*/
+{
+	ulint   i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+		buf_print_instance(buf_pool);
+	}
 }
 #endif /* UNIV_DEBUG_PRINT || UNIV_DEBUG || UNIV_BUF_DEBUG */
 
@@ -4092,15 +4594,16 @@ Returns the number of latched pages in the buffer pool.
 @return	number of latched pages */
 UNIV_INTERN
 ulint
-buf_get_latched_pages_number(void)
-/*==============================*/
+buf_get_latched_pages_number_instance(
+/*==================================*/
+	buf_pool_t*	buf_pool)	/*!< in: buffer pool instance */
 {
-	buf_chunk_t*	chunk;
 	buf_page_t*	b;
 	ulint		i;
+	buf_chunk_t*	chunk;
 	ulint		fixed_pages_number = 0;
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	chunk = buf_pool->chunks;
 
@@ -4129,7 +4632,7 @@ buf_get_latched_pages_number(void)
 		}
 	}
 
-	mutex_enter(&buf_pool_zip_mutex);
+	mutex_enter(&buf_pool->zip_mutex);
 
 	/* Traverse the lists of clean and dirty compressed-only blocks. */
 
@@ -4144,7 +4647,7 @@ buf_get_latched_pages_number(void)
 		}
 	}
 
-	buf_flush_list_mutex_enter();
+	buf_flush_list_mutex_enter(buf_pool);
 	for (b = UT_LIST_GET_FIRST(buf_pool->flush_list); b;
 	     b = UT_LIST_GET_NEXT(list, b)) {
 		ut_ad(b->in_flush_list);
@@ -4170,12 +4673,36 @@ buf_get_latched_pages_number(void)
 		}
 	}
 
-	buf_flush_list_mutex_exit();
-	mutex_exit(&buf_pool_zip_mutex);
-	buf_pool_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
+	mutex_exit(&buf_pool->zip_mutex);
+	buf_pool_mutex_exit(buf_pool);
 
 	return(fixed_pages_number);
 }
+
+/*********************************************************************//**
+Returns the number of latched pages in all the buffer pools.
+@return	number of latched pages */
+UNIV_INTERN
+ulint
+buf_get_latched_pages_number(void)
+/*==============================*/
+{
+	ulint	i;
+	ulint	total_latched_pages = 0;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+
+		total_latched_pages += buf_get_latched_pages_number_instance(
+			buf_pool);
+	}
+
+	return(total_latched_pages);
+}
+
 #endif /* UNIV_DEBUG */
 
 /*********************************************************************//**
@@ -4186,10 +4713,22 @@ ulint
 buf_get_n_pending_ios(void)
 /*=======================*/
 {
-	return(buf_pool->n_pend_reads
-	       + buf_pool->n_flush[BUF_FLUSH_LRU]
-	       + buf_pool->n_flush[BUF_FLUSH_LIST]
-	       + buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
+	ulint	i;
+	ulint	pend_ios = 0;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+
+		pend_ios +=
+			buf_pool->n_pend_reads
+			+ buf_pool->n_flush[BUF_FLUSH_LRU]
+			+ buf_pool->n_flush[BUF_FLUSH_LIST]
+			+ buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE];
+	}
+
+	return(pend_ios);
 }
 
 /*********************************************************************//**
@@ -4201,13 +4740,15 @@ ulint
 buf_get_modified_ratio_pct(void)
 /*============================*/
 {
-	ulint	ratio;
+	ulint		ratio;
+	ulint		lru_len = 0;
+	ulint		free_len = 0;
+	ulint		flush_list_len = 0;
 
-	/* This is for heuristics. No need to grab any mutex here. */
-	ratio = (100 * UT_LIST_GET_LEN(buf_pool->flush_list))
-		/ (1 + UT_LIST_GET_LEN(buf_pool->LRU)
-		   + UT_LIST_GET_LEN(buf_pool->free));
+	buf_get_total_list_len(&lru_len, &free_len, &flush_list_len);
 
+	ratio = (100 * flush_list_len) / (1 + lru_len + free_len);
+  
 	/* 1 + is there to avoid division by zero */
 
 	return(ratio);
@@ -4217,9 +4758,10 @@ buf_get_modified_ratio_pct(void)
 Prints info of the buffer i/o. */
 UNIV_INTERN
 void
-buf_print_io(
-/*=========*/
-	FILE*	file)	/*!< in/out: buffer where to print */
+buf_print_io_instance(
+/*==================*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	FILE*		file)		/*!< in/out: buffer where to print */
 {
 	time_t	current_time;
 	double	time_elapsed;
@@ -4227,8 +4769,8 @@ buf_print_io(
 
 	ut_ad(buf_pool);
 
-	buf_pool_mutex_enter();
-	buf_flush_list_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
+	buf_flush_list_mutex_enter(buf_pool);
 
 	fprintf(file,
 		"Buffer pool size   %lu\n"
@@ -4250,7 +4792,7 @@ buf_print_io(
 		+ buf_pool->init_flush[BUF_FLUSH_LIST],
 		(ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
 
-	buf_flush_list_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
 
 	current_time = time(NULL);
 	time_elapsed = 0.001 + difftime(current_time,
@@ -4282,7 +4824,8 @@ buf_print_io(
 		 - buf_pool->old_stat.n_pages_written)
 		/ time_elapsed);
 
-	n_gets_diff = buf_pool->stat.n_page_gets - buf_pool->old_stat.n_page_gets;
+	n_gets_diff = buf_pool->stat.n_page_gets
+		    - buf_pool->old_stat.n_page_gets;
 
 	if (n_gets_diff) {
 		fprintf(file,
@@ -4326,56 +4869,81 @@ buf_print_io(
 		buf_LRU_stat_sum.io, buf_LRU_stat_cur.io,
 		buf_LRU_stat_sum.unzip, buf_LRU_stat_cur.unzip);
 
-	buf_refresh_io_stats();
-	buf_pool_mutex_exit();
+	buf_refresh_io_stats(buf_pool);
+	buf_pool_mutex_exit(buf_pool);
+}
+
+/*********************************************************************//**
+Prints info of the buffer i/o. */
+UNIV_INTERN
+void
+buf_print_io(
+/*=========*/
+	FILE*	file)	/*!< in/out: buffer where to print */
+{
+	ulint   i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+		buf_print_io_instance(buf_pool, file);
+	}
 }
 
 /**********************************************************************//**
 Refreshes the statistics used to print per-second averages. */
 UNIV_INTERN
 void
-buf_refresh_io_stats(void)
-/*======================*/
+buf_refresh_io_stats(
+/*=================*/
+	buf_pool_t*	buf_pool)	/*!< in: buffer pool instance */
 {
-	buf_pool->last_printout_time = time(NULL);
+	buf_pool->last_printout_time = ut_time();
 	buf_pool->old_stat = buf_pool->stat;
 }
 
-/*********************************************************************//**
-Asserts that all file pages in the buffer are in a replaceable state.
-@return	TRUE */
+/**********************************************************************//**
+Refreshes the statistics used to print per-second averages. */
 UNIV_INTERN
-ibool
-buf_all_freed(void)
-/*===============*/
+void
+buf_refresh_io_stats_all(void)
+/*==========================*/
 {
-	buf_chunk_t*	chunk;
 	ulint		i;
 
-	ut_ad(buf_pool);
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
 
-	buf_pool_mutex_enter();
+		buf_pool = buf_pool_from_array(i);
 
-	chunk = buf_pool->chunks;
+		buf_refresh_io_stats(buf_pool);
+	}
+}
 
-	for (i = buf_pool->n_chunks; i--; chunk++) {
+/**********************************************************************//**
+Check if all pages in all buffer pools are in a replacable state.
+@return FALSE if not */
+UNIV_INTERN
+ibool
+buf_all_freed(void)
+/*===============*/
+{
+	ulint	i;
 
-		const buf_block_t* block = buf_chunk_not_freed(chunk);
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
 
-		if (UNIV_LIKELY_NULL(block)) {
-			fprintf(stderr,
-				"Page %lu %lu still fixed or dirty\n",
-				(ulong) block->page.space,
-				(ulong) block->page.offset);
-			ut_error;
-		}
-	}
+		buf_pool = buf_pool_from_array(i);
 
-	buf_pool_mutex_exit();
+		if (!buf_all_freed_instance(buf_pool)) {
+			return(FALSE);
+		}
+ 	}
 
 	return(TRUE);
 }
-
+  
 /*********************************************************************//**
 Checks that there currently are no pending i/o-operations for the buffer
 pool.
@@ -4385,23 +4953,32 @@ ibool
 buf_pool_check_no_pending_io(void)
 /*==============================*/
 {
-	ibool	ret;
+	ulint		i;
+	ibool		ret = TRUE;
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter_all();
 
-	if (buf_pool->n_pend_reads + buf_pool->n_flush[BUF_FLUSH_LRU]
-	    + buf_pool->n_flush[BUF_FLUSH_LIST]
-	    + buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]) {
-		ret = FALSE;
-	} else {
-		ret = TRUE;
+	for (i = 0; i < srv_buf_pool_instances && ret; i++) {
+		const buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+
+		if (buf_pool->n_pend_reads
+		    + buf_pool->n_flush[BUF_FLUSH_LRU]
+		    + buf_pool->n_flush[BUF_FLUSH_LIST]
+		    + buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]) {
+
+			ret = FALSE;
+		}
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit_all();
 
 	return(ret);
 }
 
+#if 0
+Code currently not used
 /*********************************************************************//**
 Gets the current length of the free list of buffer blocks.
 @return	length of the free list */
@@ -4412,14 +4989,16 @@ buf_get_free_list_len(void)
 {
 	ulint	len;
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	len = UT_LIST_GET_LEN(buf_pool->free);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	return(len);
 }
+#endif
+
 #else /* !UNIV_HOTBACKUP */
 /********************************************************************//**
 Inits a page to the buffer buf_pool, for use in ibbackup --restore. */
diff --git a/storage/innobase/buf/buf0flu.c b/storage/innobase/buf/buf0flu.c
index 847f8dd9452..bb126a35867 100644
--- a/storage/innobase/buf/buf0flu.c
+++ b/storage/innobase/buf/buf0flu.c
@@ -83,8 +83,9 @@ Validates the flush list.
 @return	TRUE if ok */
 static
 ibool
-buf_flush_validate_low(void);
-/*========================*/
+buf_flush_validate_low(
+/*===================*/
+	buf_pool_t*	buf_pool);	/*!< in: Buffer pool instance */
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
 /******************************************************************//**
@@ -98,11 +99,12 @@ buf_flush_insert_in_flush_rbt(
 /*==========================*/
 	buf_page_t*	bpage)	/*!< in: bpage to be inserted. */
 {
-	buf_page_t*		prev = NULL;
 	const ib_rbt_node_t*	c_node;
 	const ib_rbt_node_t*	p_node;
+	buf_page_t*		prev = NULL;
+	buf_pool_t*		buf_pool = buf_pool_from_bpage(bpage);
 
-	ut_ad(buf_flush_list_mutex_own());
+	ut_ad(buf_flush_list_mutex_own(buf_pool));
 
 	/* Insert this buffer into the rbt. */
 	c_node = rbt_insert(buf_pool->flush_rbt, &bpage, &bpage);
@@ -127,10 +129,10 @@ buf_flush_delete_from_flush_rbt(
 /*============================*/
 	buf_page_t*	bpage)	/*!< in: bpage to be removed. */
 {
+	ibool		ret = FALSE;
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
 
-	ibool	ret = FALSE;
-
-	ut_ad(buf_flush_list_mutex_own());
+	ut_ad(buf_flush_list_mutex_own(buf_pool));
 
 	ret = rbt_delete(buf_pool->flush_rbt, &bpage);
 	ut_ad(ret);
@@ -156,22 +158,21 @@ buf_flush_block_cmp(
 	int			ret;
 	const buf_page_t*	b1 = *(const buf_page_t**) p1;
 	const buf_page_t*	b2 = *(const buf_page_t**) p2;
+#ifdef UNIV_DEBUG
+	buf_pool_t*		buf_pool = buf_pool_from_bpage(b1);
+#endif /* UNIV_DEBUG */
 
 	ut_ad(b1 != NULL);
 	ut_ad(b2 != NULL);
 
-	ut_ad(buf_flush_list_mutex_own());
+	ut_ad(buf_flush_list_mutex_own(buf_pool));
 
 	ut_ad(b1->in_flush_list);
 	ut_ad(b2->in_flush_list);
 
-	if (b2->oldest_modification
-	    > b1->oldest_modification) {
+	if (b2->oldest_modification > b1->oldest_modification) {
 		return(1);
-	}
-
-	if (b2->oldest_modification
-	    < b1->oldest_modification) {
+	} else if (b2->oldest_modification < b1->oldest_modification) {
 		return(-1);
 	}
 
@@ -191,12 +192,21 @@ void
 buf_flush_init_flush_rbt(void)
 /*==========================*/
 {
-	buf_flush_list_mutex_enter();
+	ulint	i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
 
-	/* Create red black tree for speedy insertions in flush list. */
-	buf_pool->flush_rbt = rbt_create(sizeof(buf_page_t*),
-					 buf_flush_block_cmp);
-	buf_flush_list_mutex_exit();
+		buf_flush_list_mutex_enter(buf_pool);
+
+		/* Create red black tree for speedy insertions in flush list. */
+		buf_pool->flush_rbt = rbt_create(
+			sizeof(buf_page_t*), buf_flush_block_cmp);
+
+		buf_flush_list_mutex_exit(buf_pool);
+	}
 }
 
 /********************************************************************//**
@@ -206,16 +216,24 @@ void
 buf_flush_free_flush_rbt(void)
 /*==========================*/
 {
-	buf_flush_list_mutex_enter();
+	ulint	i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+
+		buf_flush_list_mutex_enter(buf_pool);
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
-	ut_a(buf_flush_validate_low());
+		ut_a(buf_flush_validate_low(buf_pool));
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
-	rbt_free(buf_pool->flush_rbt);
-	buf_pool->flush_rbt = NULL;
+		rbt_free(buf_pool->flush_rbt);
+		buf_pool->flush_rbt = NULL;
 
-	buf_flush_list_mutex_exit();
+		buf_flush_list_mutex_exit(buf_pool);
+	}
 }
 
 /********************************************************************//**
@@ -224,14 +242,15 @@ UNIV_INTERN
 void
 buf_flush_insert_into_flush_list(
 /*=============================*/
-	buf_block_t*	block,	/*!< in/out: block which is modified */
-	ib_uint64_t	lsn)	/*!< in: oldest modification */
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	buf_block_t*	block,		/*!< in/out: block which is modified */
+	ib_uint64_t	lsn)		/*!< in: oldest modification */
 {
-	ut_ad(!buf_pool_mutex_own());
-	ut_ad(buf_flush_order_mutex_own());
+	ut_ad(!buf_pool_mutex_own(buf_pool));
+	ut_ad(log_flush_order_mutex_own());
 	ut_ad(mutex_own(&block->mutex));
 
-	buf_flush_list_mutex_enter();
+	buf_flush_list_mutex_enter(buf_pool);
 
 	ut_ad((UT_LIST_GET_FIRST(buf_pool->flush_list) == NULL)
 	      || (UT_LIST_GET_FIRST(buf_pool->flush_list)->oldest_modification
@@ -240,8 +259,8 @@ buf_flush_insert_into_flush_list(
 	/* If we are in the recovery then we need to update the flush
 	red-black tree as well. */
 	if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
-		buf_flush_list_mutex_exit();
-		buf_flush_insert_sorted_into_flush_list(block, lsn);
+		buf_flush_list_mutex_exit(buf_pool);
+		buf_flush_insert_sorted_into_flush_list(buf_pool, block, lsn);
 		return;
 	}
 
@@ -253,10 +272,10 @@ buf_flush_insert_into_flush_list(
 	UT_LIST_ADD_FIRST(list, buf_pool->flush_list, &block->page);
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
-	ut_a(buf_flush_validate_low());
+	ut_a(buf_flush_validate_low(buf_pool));
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
-	buf_flush_list_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
 }
 
 /********************************************************************//**
@@ -267,18 +286,19 @@ UNIV_INTERN
 void
 buf_flush_insert_sorted_into_flush_list(
 /*====================================*/
-	buf_block_t*	block,	/*!< in/out: block which is modified */
-	ib_uint64_t	lsn)	/*!< in: oldest modification */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	buf_block_t*	block,		/*!< in/out: block which is modified */
+	ib_uint64_t	lsn)		/*!< in: oldest modification */
 {
 	buf_page_t*	prev_b;
 	buf_page_t*	b;
 
-	ut_ad(!buf_pool_mutex_own());
-	ut_ad(buf_flush_order_mutex_own());
+	ut_ad(!buf_pool_mutex_own(buf_pool));
+	ut_ad(log_flush_order_mutex_own());
 	ut_ad(mutex_own(&block->mutex));
 	ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 
-	buf_flush_list_mutex_enter();
+	buf_flush_list_mutex_enter(buf_pool);
 
 	/* The field in_LRU_list is protected by buf_pool_mutex, which
 	we are not holding.  However, while a block is in the flush
@@ -332,10 +352,10 @@ buf_flush_insert_sorted_into_flush_list(
 	}
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
-	ut_a(buf_flush_validate_low());
+	ut_a(buf_flush_validate_low(buf_pool));
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
-	buf_flush_list_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
 }
 
 /********************************************************************//**
@@ -349,7 +369,10 @@ buf_flush_ready_for_replace(
 	buf_page_t*	bpage)	/*!< in: buffer control block, must be
 				buf_page_in_file(bpage) and in the LRU list */
 {
-	ut_ad(buf_pool_mutex_own());
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+	ut_ad(buf_pool_mutex_own(buf_pool));
+#endif
 	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 	ut_ad(bpage->in_LRU_list);
 
@@ -382,8 +405,11 @@ buf_flush_ready_for_flush(
 				buf_page_in_file(bpage) */
 	enum buf_flush	flush_type)/*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
 {
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+	ut_ad(buf_pool_mutex_own(buf_pool));
+#endif
 	ut_a(buf_page_in_file(bpage));
-	ut_ad(buf_pool_mutex_own());
 	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 	ut_ad(flush_type == BUF_FLUSH_LRU || BUF_FLUSH_LIST);
 
@@ -416,15 +442,17 @@ buf_flush_remove(
 /*=============*/
 	buf_page_t*	bpage)	/*!< in: pointer to the block in question */
 {
-	ut_ad(buf_pool_mutex_own());
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 	ut_ad(bpage->in_flush_list);
 
-	buf_flush_list_mutex_enter();
+	buf_flush_list_mutex_enter(buf_pool);
 
 	switch (buf_page_get_state(bpage)) {
 	case BUF_BLOCK_ZIP_PAGE:
-		/* clean compressed pages should not be on the flush list */
+		/* Clean compressed pages should not be on the flush list */
 	case BUF_BLOCK_ZIP_FREE:
 	case BUF_BLOCK_NOT_USED:
 	case BUF_BLOCK_READY_FOR_USE:
@@ -442,7 +470,7 @@ buf_flush_remove(
 		break;
 	}
 
-	/* If the flush_rbt is active then delete from it as well. */
+	/* If the flush_rbt is active then delete from there as well. */
 	if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
 		buf_flush_delete_from_flush_rbt(bpage);
 	}
@@ -454,18 +482,18 @@ buf_flush_remove(
 	bpage->oldest_modification = 0;
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
-	ut_a(buf_flush_validate_low());
+	ut_a(buf_flush_validate_low(buf_pool));
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
-	buf_flush_list_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
 }
 
 /*******************************************************************//**
 Relocates a buffer control block on the flush_list.
-Note that it is assumed that the contents of bpage has already been
+Note that it is assumed that the contents of bpage have already been
 copied to dpage.
 IMPORTANT: When this function is called bpage and dpage are not
-exact copy of each other. For example, they both will have different
+exact copies of each other. For example, they both will have different
 ::state. Also the ::list pointers in dpage may be stale. We need to
 use the current list node (bpage) to do the list manipulation because
 the list pointers could have changed between the time that we copied
@@ -478,17 +506,20 @@ buf_flush_relocate_on_flush_list(
 	buf_page_t*	bpage,	/*!< in/out: control block being moved */
 	buf_page_t*	dpage)	/*!< in/out: destination block */
 {
-	buf_page_t* prev;
-	buf_page_t* prev_b = NULL;
+	buf_page_t*	prev;
+	buf_page_t* 	prev_b = NULL;
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
+	/* Must reside in the same buffer pool. */
+	ut_ad(buf_pool == buf_pool_from_bpage(dpage));
 
 	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 
-	buf_flush_list_mutex_enter();
+	buf_flush_list_mutex_enter(buf_pool);
 
 	/* FIXME: At this point we have both buf_pool and flush_list
-	mutexes. Theoratically removal of a block from flush list is
+	mutexes. Theoretically removal of a block from flush list is
 	only covered by flush_list mutex but currently we do
 	have buf_pool mutex in buf_flush_remove() therefore this block
 	is guaranteed to be in the flush list. We need to check if
@@ -529,10 +560,10 @@ buf_flush_relocate_on_flush_list(
 	ut_a(!buf_pool->flush_rbt || prev_b == prev);
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
-	ut_a(buf_flush_validate_low());
+	ut_a(buf_flush_validate_low(buf_pool));
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
-	buf_flush_list_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
 }
 
 /********************************************************************//**
@@ -544,6 +575,7 @@ buf_flush_write_complete(
 	buf_page_t*	bpage)	/*!< in: pointer to the block in question */
 {
 	enum buf_flush	flush_type;
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
 
 	ut_ad(bpage);
 
@@ -564,8 +596,8 @@ buf_flush_write_complete(
 	/* fprintf(stderr, "n pending flush %lu\n",
 	buf_pool->n_flush[flush_type]); */
 
-	if ((buf_pool->n_flush[flush_type] == 0)
-	    && (buf_pool->init_flush[flush_type] == FALSE)) {
+	if (buf_pool->n_flush[flush_type] == 0
+	    && buf_pool->init_flush[flush_type] == FALSE) {
 
 		/* The running flush batch has ended */
 
@@ -979,6 +1011,10 @@ buf_flush_write_block_low(
 /*======================*/
 	buf_page_t*	bpage)	/*!< in: buffer block to write */
 {
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+	ut_ad(!buf_pool_mutex_own(buf_pool));
+#endif
 	ulint	zip_size	= buf_page_get_zip_size(bpage);
 	page_t*	frame		= NULL;
 #ifdef UNIV_LOG_DEBUG
@@ -992,8 +1028,8 @@ buf_flush_write_block_low(
 	io_fixed and oldest_modification != 0.  Thus, it cannot be
 	relocated in the buffer pool or removed from flush_list or
 	LRU_list. */
-	ut_ad(!buf_pool_mutex_own());
-	ut_ad(!buf_flush_list_mutex_own());
+	ut_ad(!buf_pool_mutex_own(buf_pool));
+	ut_ad(!buf_flush_list_mutex_own(buf_pool));
 	ut_ad(!mutex_own(buf_page_get_mutex(bpage)));
 	ut_ad(buf_page_get_io_fix(bpage) == BUF_IO_WRITE);
 	ut_ad(bpage->oldest_modification != 0);
@@ -1062,13 +1098,14 @@ buf_flush_write_block_low(
 Writes a flushable page asynchronously from the buffer pool to a file.
 NOTE: in simulated aio we must call
 os_aio_simulated_wake_handler_threads after we have posted a batch of
-writes! NOTE: buf_pool_mutex and buf_page_get_mutex(bpage) must be
+writes! NOTE: buf_pool->mutex and buf_page_get_mutex(bpage) must be
 held upon entering this function, and they will be released by this
 function. */
 static
 void
 buf_flush_page(
 /*===========*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
 	buf_page_t*	bpage,		/*!< in: buffer control block */
 	enum buf_flush	flush_type)	/*!< in: BUF_FLUSH_LRU
 					or BUF_FLUSH_LIST */
@@ -1077,7 +1114,7 @@ buf_flush_page(
 	ibool		is_uncompressed;
 
 	ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(buf_page_in_file(bpage));
 
 	block_mutex = buf_page_get_mutex(bpage);
@@ -1097,7 +1134,7 @@ buf_flush_page(
 	buf_pool->n_flush[flush_type]++;
 
 	is_uncompressed = (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE);
-	ut_ad(is_uncompressed == (block_mutex != &buf_pool_zip_mutex));
+	ut_ad(is_uncompressed == (block_mutex != &buf_pool->zip_mutex));
 
 	switch (flush_type) {
 		ibool	is_s_latched;
@@ -1113,7 +1150,7 @@ buf_flush_page(
 		}
 
 		mutex_exit(block_mutex);
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		/* Even though bpage is not protected by any mutex at
 		this point, it is safe to access bpage, because it is
@@ -1150,7 +1187,7 @@ buf_flush_page(
 		immediately. */
 
 		mutex_exit(block_mutex);
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 		break;
 
 	default:
@@ -1184,13 +1221,13 @@ buf_flush_try_neighbors(
 	enum buf_flush	flush_type)	/*!< in: BUF_FLUSH_LRU or
 					BUF_FLUSH_LIST */
 {
-	buf_page_t*	bpage;
-	ulint		low, high;
-	ulint		count		= 0;
 	ulint		i;
+	ulint		low;
+	ulint		high;
+	ulint		count = 0;
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 
-	ut_ad(flush_type == BUF_FLUSH_LRU
-	      || flush_type == BUF_FLUSH_LIST);
+	ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
 
 	if (UT_LIST_GET_LEN(buf_pool->LRU) < BUF_LRU_OLD_MIN_LEN) {
 		/* If there is little space, it is better not to flush
@@ -1203,8 +1240,11 @@ buf_flush_try_neighbors(
 		neighborhoods of this size, and flushed along with the
 		original page. */
 
-		ulint	buf_flush_area	= ut_min(BUF_READ_AHEAD_AREA,
-						 buf_pool->curr_size / 16);
+		ulint	buf_flush_area;
+	
+		buf_flush_area	= ut_min(
+			BUF_READ_AHEAD_AREA(buf_pool),
+			buf_pool->curr_size / 16);
 
 		low = (offset / buf_flush_area) * buf_flush_area;
 		high = (offset / buf_flush_area + 1) * buf_flush_area;
@@ -1216,14 +1256,20 @@ buf_flush_try_neighbors(
 		high = fil_space_get_size(space);
 	}
 
-	buf_pool_mutex_enter();
-
 	for (i = low; i < high; i++) {
 
-		bpage = buf_page_hash_get(space, i);
+		buf_page_t*	bpage;
+
+		buf_pool = buf_pool_get(space, i);
+
+		buf_pool_mutex_enter(buf_pool);
+
+		/* We only want to flush pages from this buffer pool. */
+		bpage = buf_page_hash_get(buf_pool, space, i);
 
 		if (!bpage) {
 
+			buf_pool_mutex_exit(buf_pool);
 			continue;
 		}
 
@@ -1250,19 +1296,18 @@ buf_flush_try_neighbors(
 				doublewrite buffer before we start
 				waiting. */
 
-				buf_flush_page(bpage, flush_type);
+				buf_flush_page(buf_pool, bpage, flush_type);
 				ut_ad(!mutex_own(block_mutex));
+				ut_ad(!buf_pool_mutex_own(buf_pool));
 				count++;
-
-				buf_pool_mutex_enter();
+				continue;
 			} else {
 				mutex_exit(block_mutex);
 			}
 		}
+		buf_pool_mutex_exit(buf_pool);
 	}
 
-	buf_pool_mutex_exit();
-
 	return(count);
 }
 
@@ -1285,10 +1330,13 @@ buf_flush_page_and_try_neighbors(
 	ulint*		count)		/*!< in/out: number of pages
 					flushed */
 {
-	ibool		flushed = FALSE;
 	mutex_t*	block_mutex;
+	ibool		flushed = FALSE;
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+#endif /* UNIV_DEBUG */
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	block_mutex = buf_page_get_mutex(bpage);
 	mutex_enter(block_mutex);
@@ -1296,10 +1344,13 @@ buf_flush_page_and_try_neighbors(
 	ut_a(buf_page_in_file(bpage));
 
 	if (buf_flush_ready_for_flush(bpage, flush_type)) {
-		ulint	space;
-		ulint	offset;
+		ulint		space;
+		ulint		offset;
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_bpage(bpage);
 
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		/* These fields are protected by both the
 		buffer pool mutex and block mutex. */
@@ -1309,16 +1360,15 @@ buf_flush_page_and_try_neighbors(
 		mutex_exit(block_mutex);
 
 		/* Try to flush also all the neighbors */
-		*count += buf_flush_try_neighbors(space, offset,
-						  flush_type);
+		*count += buf_flush_try_neighbors(space, offset, flush_type);
 
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 		flushed = TRUE;
 	} else {
 		mutex_exit(block_mutex);
 	}
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	return(flushed);
 }
@@ -1333,12 +1383,13 @@ static
 ulint
 buf_flush_LRU_list_batch(
 /*=====================*/
-	ulint		max)	/*!< in: max of blocks to flush */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		max)		/*!< in: max of blocks to flush */
 {
 	buf_page_t*	bpage;
 	ulint		count = 0;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	do {
 		/* Start from the end of the list looking for a
@@ -1360,7 +1411,7 @@ buf_flush_LRU_list_batch(
 	should be flushed, we factor in this value. */
 	buf_lru_flush_page_count += count;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	return(count);
 }
@@ -1375,6 +1426,7 @@ static
 ulint
 buf_flush_flush_list_batch(
 /*=======================*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
 	ulint		min_n,		/*!< in: wished minimum mumber
 					of blocks flushed (it is not
 					guaranteed that the actual
@@ -1389,16 +1441,16 @@ buf_flush_flush_list_batch(
 	buf_page_t*	bpage;
 	ulint		count = 0;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	/* If we have flushed enough, leave the loop */
 	do {
 		/* Start from the end of the list looking for a suitable
 		block to be flushed. */
 
-		buf_flush_list_mutex_enter();
+		buf_flush_list_mutex_enter(buf_pool);
 
-		/* We use len here because theoratically insertions can
+		/* We use len here because theoretically insertions can
 		happen in the flush_list below while we are traversing
 		it for a suitable candidate for flushing. We'd like to
 		set a limit on how farther we are willing to traverse
@@ -1410,11 +1462,10 @@ buf_flush_flush_list_batch(
 			ut_a(bpage->oldest_modification > 0);
 		}
 
-
 		if (!bpage || bpage->oldest_modification >= lsn_limit) {
 
 			/* We have flushed enough */
-			buf_flush_list_mutex_exit();
+			buf_flush_list_mutex_exit(buf_pool);
 			break;
 		}
 
@@ -1422,7 +1473,7 @@ buf_flush_flush_list_batch(
 
 		ut_ad(bpage->in_flush_list);
 
-		buf_flush_list_mutex_exit();
+		buf_flush_list_mutex_exit(buf_pool);
 
 		/* The list may change during the flushing and we cannot
 		safely preserve within this function a pointer to a
@@ -1432,12 +1483,11 @@ buf_flush_flush_list_batch(
 		       && !buf_flush_page_and_try_neighbors(
 				bpage, BUF_FLUSH_LIST, &count)) {
 
-			buf_flush_list_mutex_enter();
+			buf_flush_list_mutex_enter(buf_pool);
 
-			/* If we are here that means that buf_pool
-			mutex was not released in
-			buf_flush_page_and_try_neighbors() above and
-			this guarantees that bpage didn't get
+			/* If we are here that means that buf_pool->mutex
+			 was not released in buf_flush_page_and_try_neighbors()
+			above and this guarantees that bpage didn't get
 			relocated since we released the flush_list
 			mutex above. There is a chance, however, that
 			the bpage got removed from flush_list (not
@@ -1447,21 +1497,22 @@ buf_flush_flush_list_batch(
 			the oldest_modification and if it is zero
 			we start all over again. */
 			if (bpage->oldest_modification == 0) {
-				buf_flush_list_mutex_exit();
+				buf_flush_list_mutex_exit(buf_pool);
 				break;
 			}
+
 			bpage = UT_LIST_GET_PREV(list, bpage);
 
 			ut_ad(!bpage || bpage->in_flush_list);
 
-			buf_flush_list_mutex_exit();
+			buf_flush_list_mutex_exit(buf_pool);
 
 			--len;
 		}
 
 	} while (count < min_n && bpage != NULL && len > 0);
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	return(count);
 }
@@ -1474,10 +1525,11 @@ end up waiting for these latches! NOTE 2: in the case of a flush list flush,
 the calling thread is not allowed to own any latches on pages!
 @return number of blocks for which the write request was queued;
 ULINT_UNDEFINED if there was a flush of the same type already running */
-UNIV_INTERN
+static
 ulint
 buf_flush_batch(
 /*============*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
 	enum buf_flush	flush_type,	/*!< in: BUF_FLUSH_LRU or
 					BUF_FLUSH_LIST; if BUF_FLUSH_LIST,
 					then the caller must not own any
@@ -1485,59 +1537,36 @@ buf_flush_batch(
 	ulint		min_n,		/*!< in: wished minimum mumber of blocks
 					flushed (it is not guaranteed that the
 					actual number is that big, though) */
-	ib_uint64_t	lsn_limit)	/*!< in the case BUF_FLUSH_LIST all
-					blocks whose oldest_modification is
+	ib_uint64_t	lsn_limit)	/*!< in: in the case of BUF_FLUSH_LIST
+					all blocks whose oldest_modification is
 					smaller than this should be flushed
 					(if their number does not exceed
 					min_n), otherwise ignored */
 {
 	ulint		count	= 0;
 
-	ut_ad(flush_type == BUF_FLUSH_LRU
-	      || flush_type == BUF_FLUSH_LIST);
+	ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
 #ifdef UNIV_SYNC_DEBUG
 	ut_ad((flush_type != BUF_FLUSH_LIST)
 	      || sync_thread_levels_empty_gen(TRUE));
 #endif /* UNIV_SYNC_DEBUG */
-	buf_pool_mutex_enter();
 
-	if (buf_pool->n_flush[flush_type] > 0
-	    || buf_pool->init_flush[flush_type] == TRUE) {
-
-		/* There is already a flush batch of the same type running */
-
-		buf_pool_mutex_exit();
-
-		return(ULINT_UNDEFINED);
-	}
-
-	buf_pool->init_flush[flush_type] = TRUE;
+	buf_pool_mutex_enter(buf_pool);
 
 	/* Note: The buffer pool mutex is released and reacquired within
 	the flush functions. */
 	switch(flush_type) {
 	case BUF_FLUSH_LRU:
-		count = buf_flush_LRU_list_batch(min_n);
+		count = buf_flush_LRU_list_batch(buf_pool, min_n);
 		break;
 	case BUF_FLUSH_LIST:
-		count = buf_flush_flush_list_batch(min_n, lsn_limit);
+		count = buf_flush_flush_list_batch(buf_pool, min_n, lsn_limit);
 		break;
 	default:
 		ut_error;
 	}
 
-	ut_ad(buf_pool_mutex_own());
-
-	buf_pool->init_flush[flush_type] = FALSE;
-
-	if (buf_pool->n_flush[flush_type] == 0) {
-
-		/* The running flush batch has ended */
-
-		os_event_set(buf_pool->no_flush[flush_type]);
-	}
-
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	buf_flush_buffered_writes();
 
@@ -1556,18 +1585,207 @@ buf_flush_batch(
 }
 
 /******************************************************************//**
+Gather the aggregated stats for both flush list and LRU list flushing */
+static
+void
+buf_flush_common(
+/*=============*/
+	enum buf_flush	flush_type,	/*!< in: type of flush */
+	ulint		page_count)	/*!< in: number of pages flushed */
+{
+	buf_flush_buffered_writes();
+
+	ut_a(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
+
+#ifdef UNIV_DEBUG
+	if (buf_debug_prints && page_count > 0) {
+		fprintf(stderr, flush_type == BUF_FLUSH_LRU
+			? "Flushed %lu pages in LRU flush\n"
+			: "Flushed %lu pages in flush list flush\n",
+			(ulong) page_count);
+	}
+#endif /* UNIV_DEBUG */
+
+	srv_buf_pool_flushed += page_count;
+
+	if (flush_type == BUF_FLUSH_LRU) {
+		/* We keep track of all flushes happening as part of LRU
+		flush. When estimating the desired rate at which flush_list
+		should be flushed we factor in this value. */
+		buf_lru_flush_page_count += page_count;
+	}
+}
+
+/******************************************************************//**
+Start a buffer flush batch for LRU or flush list */
+static
+ibool
+buf_flush_start(
+/*============*/
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	enum buf_flush	flush_type)	/*!< in: BUF_FLUSH_LRU
+					or BUF_FLUSH_LIST */
+{
+	buf_pool_mutex_enter(buf_pool);
+
+	if (buf_pool->n_flush[flush_type] > 0
+	   || buf_pool->init_flush[flush_type] == TRUE) {
+
+		/* There is already a flush batch of the same type running */
+
+		buf_pool_mutex_exit(buf_pool);
+
+		return(FALSE);
+	}
+
+	buf_pool->init_flush[flush_type] = TRUE;
+
+	buf_pool_mutex_exit(buf_pool);
+
+	return(TRUE);
+}
+
+/******************************************************************//**
+End a buffer flush batch for LRU or flush list */
+static
+void
+buf_flush_end(
+/*==========*/
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	enum buf_flush	flush_type)	/*!< in: BUF_FLUSH_LRU
+					or BUF_FLUSH_LIST */
+{
+	buf_pool_mutex_enter(buf_pool);
+
+	buf_pool->init_flush[flush_type] = FALSE;
+
+	if (buf_pool->n_flush[flush_type] == 0) {
+
+		/* The running flush batch has ended */
+
+		os_event_set(buf_pool->no_flush[flush_type]);
+	}
+
+	buf_pool_mutex_exit(buf_pool);
+}
+
+/******************************************************************//**
 Waits until a flush batch of the given type ends */
 UNIV_INTERN
 void
 buf_flush_wait_batch_end(
 /*=====================*/
-	enum buf_flush	type)	/*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	enum buf_flush	type)		/*!< in: BUF_FLUSH_LRU
+					or BUF_FLUSH_LIST */
 {
-	ut_ad((type == BUF_FLUSH_LRU) || (type == BUF_FLUSH_LIST));
+	ut_ad(type == BUF_FLUSH_LRU || type == BUF_FLUSH_LIST);
+
+	if (buf_pool == NULL) {
+		ulint	i;
+
+		for (i = 0; i < srv_buf_pool_instances; ++i) {
+			buf_pool_t*	buf_pool;
+
+			buf_pool = buf_pool_from_array(i);
 
-	os_event_wait(buf_pool->no_flush[type]);
+			os_event_wait(buf_pool->no_flush[type]);
+		}
+	} else {
+		os_event_wait(buf_pool->no_flush[type]);
+	}
 }
 
+/*******************************************************************//**
+This utility flushes dirty blocks from the end of the LRU list.
+NOTE: The calling thread may own latches to pages: to avoid deadlocks,
+this function must be written so that it cannot end up waiting for these
+latches!
+@return number of blocks for which the write request was queued;
+ULINT_UNDEFINED if there was a flush of the same type already running */
+UNIV_INTERN
+ulint
+buf_flush_LRU(
+/*==========*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		min_n)		/*!< in: wished minimum mumber of blocks
+					flushed (it is not guaranteed that the
+					actual number is that big, though) */
+{
+	ulint		page_count;
+
+	if (!buf_flush_start(buf_pool, BUF_FLUSH_LRU)) {
+		return(ULINT_UNDEFINED);
+	}
+
+	page_count = buf_flush_batch(buf_pool, BUF_FLUSH_LRU, min_n, 0);
+
+	buf_flush_end(buf_pool, BUF_FLUSH_LRU);
+
+	buf_flush_common(BUF_FLUSH_LRU, page_count);
+
+	return(page_count);
+}
+
+/*******************************************************************//**
+This utility flushes dirty blocks from the end of the flush list of
+all buffer pool instances.
+NOTE: The calling thread is not allowed to own any latches on pages!
+@return number of blocks for which the write request was queued;
+ULINT_UNDEFINED if there was a flush of the same type already running */
+UNIV_INTERN
+ulint
+buf_flush_list(
+/*===========*/
+	ulint		min_n,		/*!< in: wished minimum mumber of blocks
+					flushed (it is not guaranteed that the
+					actual number is that big, though) */
+	ib_uint64_t	lsn_limit)	/*!< in the case BUF_FLUSH_LIST all
+					blocks whose oldest_modification is
+					smaller than this should be flushed
+					(if their number does not exceed
+					min_n), otherwise ignored */
+{
+	ulint		i;
+	ulint		total_page_count = 0;
+
+	if (min_n != ULINT_MAX) {
+		/* Ensure that flushing is spread evenly amongst the
+		buffer pool instances. When min_n is ULINT_MAX
+		we need to flush everything up to the lsn limit
+		so no limit here. */
+		min_n = (min_n + srv_buf_pool_instances - 1)
+			 / srv_buf_pool_instances;
+	}
+
+	/* We use buffer pool instance 0 to control start and end of
+	flushing of the flush list since we always flush all instances
+	at once in this case. */
+
+	/* Flush to lsn_limit in all buffer pool instances */
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+		ulint		page_count = 0;
+
+		buf_pool = buf_pool_from_array(i);
+
+		if (!buf_flush_start(buf_pool, BUF_FLUSH_LIST)) {
+			continue;
+		}
+
+		page_count = buf_flush_batch(
+			buf_pool, BUF_FLUSH_LIST, min_n, lsn_limit);
+
+		buf_flush_end(buf_pool, BUF_FLUSH_LIST);
+
+		buf_flush_common(BUF_FLUSH_LIST, page_count);
+
+		total_page_count += page_count;
+	}
+
+	return(total_page_count);
+}
+ 
 /******************************************************************//**
 Gives a recommendation of how many blocks should be flushed to establish
 a big enough margin of replaceable blocks near the end of the LRU list
@@ -1576,23 +1794,24 @@ and in the free list.
 LRU list */
 static
 ulint
-buf_flush_LRU_recommendation(void)
-/*==============================*/
+buf_flush_LRU_recommendation(
+/*=========================*/
+	buf_pool_t*	buf_pool)		/*!< in: Buffer pool instance */
 {
 	buf_page_t*	bpage;
 	ulint		n_replaceable;
 	ulint		distance	= 0;
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	n_replaceable = UT_LIST_GET_LEN(buf_pool->free);
 
 	bpage = UT_LIST_GET_LAST(buf_pool->LRU);
 
 	while ((bpage != NULL)
-	       && (n_replaceable < BUF_FLUSH_FREE_BLOCK_MARGIN
-		   + BUF_FLUSH_EXTRA_MARGIN)
-	       && (distance < BUF_LRU_FREE_SEARCH_LEN)) {
+	       && (n_replaceable < BUF_FLUSH_FREE_BLOCK_MARGIN(buf_pool)
+		   + BUF_FLUSH_EXTRA_MARGIN(buf_pool))
+	       && (distance < BUF_LRU_FREE_SEARCH_LEN(buf_pool))) {
 
 		mutex_t* block_mutex = buf_page_get_mutex(bpage);
 
@@ -1609,14 +1828,15 @@ buf_flush_LRU_recommendation(void)
 		bpage = UT_LIST_GET_PREV(LRU, bpage);
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
-	if (n_replaceable >= BUF_FLUSH_FREE_BLOCK_MARGIN) {
+	if (n_replaceable >= BUF_FLUSH_FREE_BLOCK_MARGIN(buf_pool)) {
 
 		return(0);
 	}
 
-	return(BUF_FLUSH_FREE_BLOCK_MARGIN + BUF_FLUSH_EXTRA_MARGIN
+	return(BUF_FLUSH_FREE_BLOCK_MARGIN(buf_pool)
+	       + BUF_FLUSH_EXTRA_MARGIN(buf_pool)
 	       - n_replaceable);
 }
 
@@ -1628,25 +1848,46 @@ flush only pages such that the s-lock required for flushing can be acquired
 immediately, without waiting. */
 UNIV_INTERN
 void
-buf_flush_free_margin(void)
-/*=======================*/
+buf_flush_free_margin(
+/*==================*/
+	buf_pool_t*	buf_pool)		/*!< in: Buffer pool instance */
 {
 	ulint	n_to_flush;
-	ulint	n_flushed;
 
-	n_to_flush = buf_flush_LRU_recommendation();
+	n_to_flush = buf_flush_LRU_recommendation(buf_pool);
 
 	if (n_to_flush > 0) {
-		n_flushed = buf_flush_batch(BUF_FLUSH_LRU, n_to_flush, 0);
+		ulint	n_flushed;
+
+		n_flushed = buf_flush_LRU(buf_pool, n_to_flush);
+
 		if (n_flushed == ULINT_UNDEFINED) {
 			/* There was an LRU type flush batch already running;
 			let us wait for it to end */
 
-			buf_flush_wait_batch_end(BUF_FLUSH_LRU);
+			buf_flush_wait_batch_end(buf_pool, BUF_FLUSH_LRU);
 		}
 	}
 }
 
+/*********************************************************************//**
+Flushes pages from the end of all the LRU lists. */
+UNIV_INTERN
+void
+buf_flush_free_margins(void)
+/*========================*/
+{
+	ulint	i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+
+		buf_flush_free_margin(buf_pool);
+	}
+}
+
 /*********************************************************************
 Update the historical stats that we are collecting for flush rate
 heuristics at the end of each interval.
@@ -1707,22 +1948,28 @@ ulint
 buf_flush_get_desired_flush_rate(void)
 /*==================================*/
 {
-	ulint			redo_avg;
-	ulint			lru_flush_avg;
-	ulint			n_dirty;
-	ulint			n_flush_req;
-	lint			rate;
-	ib_uint64_t		lsn = log_get_lsn();
-	ulint			log_capacity = log_get_capacity();
+	ulint		i;
+	lint		rate;
+	ulint		redo_avg;
+	ulint		n_dirty = 0;
+	ulint		n_flush_req;
+	ulint		lru_flush_avg;
+	ib_uint64_t	lsn = log_get_lsn();
+	ulint		log_capacity = log_get_capacity();
 
 	/* log_capacity should never be zero after the initialization
 	of log subsystem. */
 	ut_ad(log_capacity != 0);
 
 	/* Get total number of dirty pages. It is OK to access
-	flush_list without holding any mtex as we are using this
+	flush_list without holding any mutex as we are using this
 	only for heuristics. */
-	n_dirty = UT_LIST_GET_LEN(buf_pool->flush_list);
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+		n_dirty += UT_LIST_GET_LEN(buf_pool->flush_list);
+	}
 
 	/* An overflow can happen if we generate more than 2^32 bytes
 	of redo in this interval i.e.: 4G of redo in 1 second. We can
@@ -1764,13 +2011,14 @@ Validates the flush list.
 @return	TRUE if ok */
 static
 ibool
-buf_flush_validate_low(void)
-/*========================*/
+buf_flush_validate_low(
+/*===================*/
+	buf_pool_t*	buf_pool)		/*!< in: Buffer pool instance */
 {
 	buf_page_t*		bpage;
 	const ib_rbt_node_t*	rnode = NULL;
 
-	ut_ad(buf_flush_list_mutex_own());
+	ut_ad(buf_flush_list_mutex_own(buf_pool));
 
 	UT_LIST_VALIDATE(list, buf_page_t, buf_pool->flush_list,
 			 ut_ad(ut_list_node_313->in_flush_list));
@@ -1786,6 +2034,9 @@ buf_flush_validate_low(void)
 
 	while (bpage != NULL) {
 		const ib_uint64_t om = bpage->oldest_modification;
+
+		ut_ad(buf_pool_from_bpage(bpage) == buf_pool);
+
 		ut_ad(bpage->in_flush_list);
 
 		/* A page in flush_list can be in BUF_BLOCK_REMOVE_HASH
@@ -1795,14 +2046,15 @@ buf_flush_validate_low(void)
 		waiting to acquire the flush_list_mutex to complete
 		the relocation. */
 		ut_a(buf_page_in_file(bpage)
-		     || buf_page_get_state(bpage)
-			== BUF_BLOCK_REMOVE_HASH);
+		     || buf_page_get_state(bpage) == BUF_BLOCK_REMOVE_HASH);
 		ut_a(om > 0);
 
 		if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
+			buf_page_t* rpage;
+
 			ut_a(rnode);
-			buf_page_t* rpage = *rbt_value(buf_page_t*,
-						       rnode);
+			rpage = *rbt_value(buf_page_t*, rnode);
+
 			ut_a(rpage);
 			ut_a(rpage == bpage);
 			rnode = rbt_next(buf_pool->flush_rbt, rnode);
@@ -1825,16 +2077,17 @@ Validates the flush list.
 @return	TRUE if ok */
 UNIV_INTERN
 ibool
-buf_flush_validate(void)
-/*====================*/
+buf_flush_validate(
+/*===============*/
+	buf_pool_t*	buf_pool)	/*!< buffer pool instance */
 {
 	ibool	ret;
 
-	buf_flush_list_mutex_enter();
+	buf_flush_list_mutex_enter(buf_pool);
 
-	ret = buf_flush_validate_low();
+	ret = buf_flush_validate_low(buf_pool);
 
-	buf_flush_list_mutex_exit();
+	buf_flush_list_mutex_exit(buf_pool);
 
 	return(ret);
 }
diff --git a/storage/innobase/buf/buf0lru.c b/storage/innobase/buf/buf0lru.c
index c7feb3ae79b..6a4c18aa86e 100644
--- a/storage/innobase/buf/buf0lru.c
+++ b/storage/innobase/buf/buf0lru.c
@@ -50,7 +50,7 @@ Created 11/5/1995 Heikki Tuuri
 #include "srv0srv.h"
 
 /** The number of blocks from the LRU_old pointer onward, including
-the block pointed to, must be buf_LRU_old_ratio/BUF_LRU_OLD_RATIO_DIV
+the block pointed to, must be buf_pool->LRU_old_ratio/BUF_LRU_OLD_RATIO_DIV
 of the whole LRU list length, except that the tolerance defined below
 is allowed. Note that the tolerance must be small enough such that for
 even the BUF_LRU_OLD_MIN_LEN long LRU list, the LRU_old pointer is not
@@ -96,8 +96,9 @@ with page_zip_decompress() operations. */
 #define BUF_LRU_IO_TO_UNZIP_FACTOR 50
 
 /** Sampled values buf_LRU_stat_cur.
-Protected by buf_pool_mutex.  Updated by buf_LRU_stat_update(). */
+Not protected by any mutex.  Updated by buf_LRU_stat_update(). */
 static buf_LRU_stat_t		buf_LRU_stat_arr[BUF_LRU_STAT_N_INTERVAL];
+
 /** Cursor to buf_LRU_stat_arr[] that is updated in a round-robin fashion. */
 static ulint			buf_LRU_stat_arr_ind;
 
@@ -106,15 +107,12 @@ by buf_LRU_stat_update(). */
 UNIV_INTERN buf_LRU_stat_t	buf_LRU_stat_cur;
 
 /** Running sum of past values of buf_LRU_stat_cur.
-Updated by buf_LRU_stat_update().  Protected by buf_pool_mutex. */
+Updated by buf_LRU_stat_update().  Not Protected by any mutex. */
 UNIV_INTERN buf_LRU_stat_t	buf_LRU_stat_sum;
 
 /* @} */
 
 /** @name Heuristics for detecting index scan @{ */
-/** Reserve this much/BUF_LRU_OLD_RATIO_DIV of the buffer pool for
-"old" blocks.  Protected by buf_pool_mutex. */
-UNIV_INTERN uint	buf_LRU_old_ratio;
 /** Move blocks to "new" LRU list only if the first access was at
 least this many milliseconds ago.  Not protected by any mutex or latch. */
 UNIV_INTERN uint	buf_LRU_old_threshold_ms;
@@ -123,7 +121,7 @@ UNIV_INTERN uint	buf_LRU_old_threshold_ms;
 /******************************************************************//**
 Takes a block out of the LRU list and page hash table.
 If the block is compressed-only (BUF_BLOCK_ZIP_PAGE),
-the object will be freed and buf_pool_zip_mutex will be released.
+the object will be freed and buf_pool->zip_mutex will be released.
 
 If a compressed page or a compressed-only block descriptor is freed,
 other compressed pages or compressed-only block descriptors may be
@@ -154,13 +152,14 @@ instead of the general LRU list.
 @return	TRUE if should use unzip_LRU */
 UNIV_INLINE
 ibool
-buf_LRU_evict_from_unzip_LRU(void)
-/*==============================*/
+buf_LRU_evict_from_unzip_LRU(
+/*=========================*/
+	buf_pool_t*	buf_pool)
 {
 	ulint	io_avg;
 	ulint	unzip_avg;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	/* If the unzip_LRU list is empty, we can only use the LRU. */
 	if (UT_LIST_GET_LEN(buf_pool->unzip_LRU) == 0) {
@@ -228,7 +227,8 @@ static
 void
 buf_LRU_drop_page_hash_for_tablespace(
 /*==================================*/
-	ulint	id)	/*!< in: space id */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		id)		/*!< in: space id */
 {
 	buf_page_t*	bpage;
 	ulint*		page_arr;
@@ -243,9 +243,10 @@ buf_LRU_drop_page_hash_for_tablespace(
 		return;
 	}
 
-	page_arr = ut_malloc(sizeof(ulint)
-			     * BUF_LRU_DROP_SEARCH_HASH_SIZE);
-	buf_pool_mutex_enter();
+	page_arr = ut_malloc(
+		sizeof(ulint) * BUF_LRU_DROP_SEARCH_HASH_SIZE);
+
+	buf_pool_mutex_enter(buf_pool);
 
 scan_again:
 	num_entries = 0;
@@ -283,14 +284,17 @@ scan_again:
 			if (num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE) {
 				goto next_page;
 			}
-			/* Array full. We release the buf_pool_mutex to
+
+			/* Array full. We release the buf_pool->mutex to
 			obey the latching order. */
-			buf_pool_mutex_exit();
+			buf_pool_mutex_exit(buf_pool);
+
+			buf_LRU_drop_page_hash_batch(
+				id, zip_size, page_arr, num_entries);
 
-			buf_LRU_drop_page_hash_batch(id, zip_size, page_arr,
-						     num_entries);
 			num_entries = 0;
-			buf_pool_mutex_enter();
+
+			buf_pool_mutex_enter(buf_pool);
 		} else {
 			mutex_exit(block_mutex);
 		}
@@ -315,7 +319,7 @@ next_page:
 		}
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	/* Drop any remaining batch of search hashed pages. */
 	buf_LRU_drop_page_hash_batch(id, zip_size, page_arr, num_entries);
@@ -323,27 +327,21 @@ next_page:
 }
 
 /******************************************************************//**
-Invalidates all pages belonging to a given tablespace when we are deleting
-the data file(s) of that tablespace. */
-UNIV_INTERN
+Invalidates all pages belonging to a given tablespace inside a specific
+buffer pool instance when we are deleting the data file(s) of that
+tablespace. */
+static
 void
-buf_LRU_invalidate_tablespace(
-/*==========================*/
-	ulint	id)	/*!< in: space id */
+buf_LRU_invalidate_tablespace_buf_pool_instance(
+/*============================================*/
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	ulint		id)		/*!< in: space id */
 {
 	buf_page_t*	bpage;
 	ibool		all_freed;
 
-	/* Before we attempt to drop pages one by one we first
-	attempt to drop page hash index entries in batches to make
-	it more efficient. The batching attempt is a best effort
-	attempt and does not guarantee that all pages hash entries
-	will be dropped. We get rid of remaining page hash entries
-	one by one below. */
-	buf_LRU_drop_page_hash_for_tablespace(id);
-
 scan_again:
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	all_freed = TRUE;
 
@@ -417,7 +415,7 @@ scan_again:
 						buf_pool_zip_mutex, it is
 						not necessary to acquire
 						further mutexes. */
-						ut_ad(&buf_pool_zip_mutex
+						ut_ad(&buf_pool->zip_mutex
 						      == block_mutex);
 						ut_ad(mutex_own(block_mutex));
 						prev_bpage_buf_fix = TRUE;
@@ -431,7 +429,7 @@ scan_again:
 				ulint	page_no;
 				ulint	zip_size;
 
-				buf_pool_mutex_exit();
+				buf_pool_mutex_exit(buf_pool);
 
 				zip_size = buf_page_get_zip_size(bpage);
 				page_no = buf_page_get_page_no(bpage);
@@ -461,7 +459,7 @@ scan_again:
 				/* The block_mutex should have been
 				released by buf_LRU_block_remove_hashed_page()
 				when it returns BUF_BLOCK_ZIP_FREE. */
-				ut_ad(block_mutex == &buf_pool_zip_mutex);
+				ut_ad(block_mutex == &buf_pool->zip_mutex);
 				ut_ad(!mutex_own(block_mutex));
 
 				if (prev_bpage_buf_fix) {
@@ -488,7 +486,7 @@ next_page_no_mutex:
 		bpage = prev_bpage;
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	if (!all_freed) {
 		os_thread_sleep(20000);
@@ -497,6 +495,32 @@ next_page_no_mutex:
 	}
 }
 
+/******************************************************************//**
+Invalidates all pages belonging to a given tablespace when we are deleting
+the data file(s) of that tablespace. */
+UNIV_INTERN
+void
+buf_LRU_invalidate_tablespace(
+/*==========================*/
+	ulint	id)	/*!< in: space id */
+{
+	ulint	i;
+
+	/* Before we attempt to drop pages one by one we first
+	attempt to drop page hash index entries in batches to make
+	it more efficient. The batching attempt is a best effort
+	attempt and does not guarantee that all pages hash entries
+	will be dropped. We get rid of remaining page hash entries
+	one by one below. */
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+		buf_LRU_drop_page_hash_for_tablespace(buf_pool, id);
+		buf_LRU_invalidate_tablespace_buf_pool_instance(buf_pool, id);
+	}
+}
+
 /********************************************************************//**
 Insert a compressed block into buf_pool->zip_clean in the LRU order. */
 UNIV_INTERN
@@ -506,8 +530,9 @@ buf_LRU_insert_zip_clean(
 	buf_page_t*	bpage)	/*!< in: pointer to the block in question */
 {
 	buf_page_t*	b;
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(buf_page_get_state(bpage) == BUF_BLOCK_ZIP_PAGE);
 
 	/* Find the first successor of bpage in the LRU list
@@ -537,16 +562,19 @@ UNIV_INLINE
 ibool
 buf_LRU_free_from_unzip_LRU_list(
 /*=============================*/
-	ulint	n_iterations)	/*!< in: how many times this has been called
-				repeatedly without result: a high value means
-				that we should search farther; we will search
-				n_iterations / 5 of the unzip_LRU list,
-				or nothing if n_iterations >= 5 */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		n_iterations)	/*!< in: how many times this has
+					been called repeatedly without
+					result: a high value means that
+					we should search farther; we will
+					search n_iterations / 5 of the
+					unzip_LRU list, or nothing if
+					n_iterations >= 5 */
 {
 	buf_block_t*	block;
 	ulint		distance;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	/* Theoratically it should be much easier to find a victim
 	from unzip_LRU as we can choose even a dirty block (as we'll
@@ -556,7 +584,7 @@ buf_LRU_free_from_unzip_LRU_list(
 	if we have done five iterations so far. */
 
 	if (UNIV_UNLIKELY(n_iterations >= 5)
-	    || !buf_LRU_evict_from_unzip_LRU()) {
+	    || !buf_LRU_evict_from_unzip_LRU(buf_pool)) {
 
 		return(FALSE);
 	}
@@ -608,7 +636,9 @@ UNIV_INLINE
 ibool
 buf_LRU_free_from_common_LRU_list(
 /*==============================*/
-	ulint	n_iterations)	/*!< in: how many times this has been called
+	buf_pool_t*	buf_pool,
+	ulint		n_iterations)
+				/*!< in: how many times this has been called
 				repeatedly without result: a high value means
 				that we should search farther; if
 				n_iterations < 10, then we search
@@ -618,7 +648,7 @@ buf_LRU_free_from_common_LRU_list(
 	buf_page_t*	bpage;
 	ulint		distance;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	distance = 100 + (n_iterations * buf_pool->curr_size) / 10;
 
@@ -675,7 +705,10 @@ UNIV_INTERN
 ibool
 buf_LRU_search_and_free_block(
 /*==========================*/
-	ulint	n_iterations)	/*!< in: how many times this has been called
+	buf_pool_t*	buf_pool,
+				/*!< in: buffer pool instance */
+	ulint		n_iterations)
+				/*!< in: how many times this has been called
 				repeatedly without result: a high value means
 				that we should search farther; if
 				n_iterations < 10, then we search
@@ -686,12 +719,13 @@ buf_LRU_search_and_free_block(
 {
 	ibool	freed = FALSE;
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	freed = buf_LRU_free_from_unzip_LRU_list(n_iterations);
+	freed = buf_LRU_free_from_unzip_LRU_list(buf_pool, n_iterations);
 
 	if (!freed) {
-		freed = buf_LRU_free_from_common_LRU_list(n_iterations);
+		freed = buf_LRU_free_from_common_LRU_list(
+			buf_pool, n_iterations);
 	}
 
 	if (!freed) {
@@ -700,7 +734,7 @@ buf_LRU_search_and_free_block(
 		buf_pool->LRU_flush_ended--;
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	return(freed);
 }
@@ -715,44 +749,64 @@ operations need new buffer blocks, and the i/o work done in flushing would be
 wasted. */
 UNIV_INTERN
 void
-buf_LRU_try_free_flushed_blocks(void)
-/*=================================*/
+buf_LRU_try_free_flushed_blocks(
+/*============================*/
+	buf_pool_t*	buf_pool)		/*!< in: buffer pool instance */
 {
-	buf_pool_mutex_enter();
 
-	while (buf_pool->LRU_flush_ended > 0) {
+	if (buf_pool == NULL) {
+		ulint	i;
+
+		for (i = 0; i < srv_buf_pool_instances; i++) {
+			buf_pool = buf_pool_from_array(i);
+			buf_LRU_try_free_flushed_blocks(buf_pool);
+		}
+	} else {
+		buf_pool_mutex_enter(buf_pool);
 
-		buf_pool_mutex_exit();
+		while (buf_pool->LRU_flush_ended > 0) {
 
-		buf_LRU_search_and_free_block(1);
+			buf_pool_mutex_exit(buf_pool);
 
-		buf_pool_mutex_enter();
-	}
+			buf_LRU_search_and_free_block(buf_pool, 1);
+
+			buf_pool_mutex_enter(buf_pool);
+		}
 
-	buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
+	}
 }
 
 /******************************************************************//**
-Returns TRUE if less than 25 % of the buffer pool is available. This can be
-used in heuristics to prevent huge transactions eating up the whole buffer
-pool for their locks.
+Returns TRUE if less than 25 % of the buffer pool in any instance is
+available. This can be used in heuristics to prevent huge transactions
+eating up the whole buffer pool for their locks.
 @return	TRUE if less than 25 % of buffer pool left */
 UNIV_INTERN
 ibool
 buf_LRU_buf_pool_running_out(void)
 /*==============================*/
 {
-	ibool	ret	= FALSE;
+	ulint	i;
+	ibool	ret = FALSE;
 
-	buf_pool_mutex_enter();
+	for (i = 0; i < srv_buf_pool_instances && !ret; i++) {
+		buf_pool_t*	buf_pool;
 
-	if (!recv_recovery_on && UT_LIST_GET_LEN(buf_pool->free)
-	    + UT_LIST_GET_LEN(buf_pool->LRU) < buf_pool->curr_size / 4) {
+		buf_pool = buf_pool_from_array(i);
 
-		ret = TRUE;
-	}
+		buf_pool_mutex_enter(buf_pool);
+
+		if (!recv_recovery_on
+		    && UT_LIST_GET_LEN(buf_pool->free)
+		       + UT_LIST_GET_LEN(buf_pool->LRU)
+		       < buf_pool->curr_size / 4) {
 
-	buf_pool_mutex_exit();
+			ret = TRUE;
+		}
+
+		buf_pool_mutex_exit(buf_pool);
+	}
 
 	return(ret);
 }
@@ -763,16 +817,18 @@ free list.  If it is empty, returns NULL.
 @return	a free control block, or NULL if the buf_block->free list is empty */
 UNIV_INTERN
 buf_block_t*
-buf_LRU_get_free_only(void)
-/*=======================*/
+buf_LRU_get_free_only(
+/*==================*/
+	buf_pool_t*	buf_pool)
 {
 	buf_block_t*	block;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	block = (buf_block_t*) UT_LIST_GET_FIRST(buf_pool->free);
 
 	if (block) {
+
 		ut_ad(block->page.in_free_list);
 		ut_d(block->page.in_free_list = FALSE);
 		ut_ad(!block->page.in_flush_list);
@@ -785,6 +841,8 @@ buf_LRU_get_free_only(void)
 		buf_block_set_state(block, BUF_BLOCK_READY_FOR_USE);
 		UNIV_MEM_ALLOC(block->frame, UNIV_PAGE_SIZE);
 
+		ut_ad(buf_pool_from_block(block) == buf_pool);
+
 		mutex_exit(&block->mutex);
 	}
 
@@ -800,8 +858,9 @@ UNIV_INTERN
 buf_block_t*
 buf_LRU_get_free_block(
 /*===================*/
-	ulint	zip_size)	/*!< in: compressed page size in bytes,
-				or 0 if uncompressed tablespace */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		zip_size)	/*!< in: compressed page size in bytes,
+					or 0 if uncompressed tablespace */
 {
 	buf_block_t*	block		= NULL;
 	ibool		freed;
@@ -809,7 +868,7 @@ buf_LRU_get_free_block(
 	ibool		mon_value_was	= FALSE;
 	ibool		started_monitor	= FALSE;
 loop:
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	if (!recv_recovery_on && UT_LIST_GET_LEN(buf_pool->free)
 	    + UT_LIST_GET_LEN(buf_pool->LRU) < buf_pool->curr_size / 20) {
@@ -876,9 +935,11 @@ loop:
 	}
 
 	/* If there is a block in the free list, take it */
-	block = buf_LRU_get_free_only();
+	block = buf_LRU_get_free_only(buf_pool);
 	if (block) {
 
+		ut_ad(buf_pool_from_block(block) == buf_pool);
+
 #ifdef UNIV_DEBUG
 		block->page.zip.m_start =
 #endif /* UNIV_DEBUG */
@@ -889,14 +950,17 @@ loop:
 		if (UNIV_UNLIKELY(zip_size)) {
 			ibool	lru;
 			page_zip_set_size(&block->page.zip, zip_size);
-			block->page.zip.data = buf_buddy_alloc(zip_size, &lru);
+
+			block->page.zip.data = buf_buddy_alloc(
+				buf_pool, zip_size, &lru);
+
 			UNIV_MEM_DESC(block->page.zip.data, zip_size, block);
 		} else {
 			page_zip_set_size(&block->page.zip, 0);
 			block->page.zip.data = NULL;
 		}
 
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		if (started_monitor) {
 			srv_print_innodb_monitor = mon_value_was;
@@ -908,9 +972,9 @@ loop:
 	/* If no block was in the free list, search from the end of the LRU
 	list and try to free a block there */
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
-	freed = buf_LRU_search_and_free_block(n_iterations);
+	freed = buf_LRU_search_and_free_block(buf_pool, n_iterations);
 
 	if (freed > 0) {
 		goto loop;
@@ -952,23 +1016,23 @@ loop:
 
 	/* No free block was found: try to flush the LRU list */
 
-	buf_flush_free_margin();
+	buf_flush_free_margin(buf_pool);
 	++srv_buf_pool_wait_free;
 
 	os_aio_simulated_wake_handler_threads();
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	if (buf_pool->LRU_flush_ended > 0) {
 		/* We have written pages in an LRU flush. To make the insert
 		buffer more efficient, we try to move these pages to the free
 		list. */
 
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
-		buf_LRU_try_free_flushed_blocks();
+		buf_LRU_try_free_flushed_blocks(buf_pool);
 	} else {
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 	}
 
 	if (n_iterations > 10) {
@@ -986,16 +1050,17 @@ Moves the LRU_old pointer so that the length of the old blocks list
 is inside the allowed limits. */
 UNIV_INLINE
 void
-buf_LRU_old_adjust_len(void)
-/*========================*/
+buf_LRU_old_adjust_len(
+/*===================*/
+	buf_pool_t*	buf_pool)	/*!< in: buffer pool instance */
 {
 	ulint	old_len;
 	ulint	new_len;
 
 	ut_a(buf_pool->LRU_old);
-	ut_ad(buf_pool_mutex_own());
-	ut_ad(buf_LRU_old_ratio >= BUF_LRU_OLD_RATIO_MIN);
-	ut_ad(buf_LRU_old_ratio <= BUF_LRU_OLD_RATIO_MAX);
+	ut_ad(buf_pool_mutex_own(buf_pool));
+	ut_ad(buf_pool->LRU_old_ratio >= BUF_LRU_OLD_RATIO_MIN);
+	ut_ad(buf_pool->LRU_old_ratio <= BUF_LRU_OLD_RATIO_MAX);
 #if BUF_LRU_OLD_RATIO_MIN * BUF_LRU_OLD_MIN_LEN <= BUF_LRU_OLD_RATIO_DIV * (BUF_LRU_OLD_TOLERANCE + 5)
 # error "BUF_LRU_OLD_RATIO_MIN * BUF_LRU_OLD_MIN_LEN <= BUF_LRU_OLD_RATIO_DIV * (BUF_LRU_OLD_TOLERANCE + 5)"
 #endif
@@ -1011,7 +1076,7 @@ buf_LRU_old_adjust_len(void)
 
 	old_len = buf_pool->LRU_old_len;
 	new_len = ut_min(UT_LIST_GET_LEN(buf_pool->LRU)
-			 * buf_LRU_old_ratio / BUF_LRU_OLD_RATIO_DIV,
+			 * buf_pool->LRU_old_ratio / BUF_LRU_OLD_RATIO_DIV,
 			 UT_LIST_GET_LEN(buf_pool->LRU)
 			 - (BUF_LRU_OLD_TOLERANCE
 			    + BUF_LRU_NON_OLD_MIN_LEN));
@@ -1053,12 +1118,13 @@ Initializes the old blocks pointer in the LRU list. This function should be
 called when the LRU list grows to BUF_LRU_OLD_MIN_LEN length. */
 static
 void
-buf_LRU_old_init(void)
-/*==================*/
+buf_LRU_old_init(
+/*=============*/
+	buf_pool_t*	buf_pool)
 {
 	buf_page_t*	bpage;
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_a(UT_LIST_GET_LEN(buf_pool->LRU) == BUF_LRU_OLD_MIN_LEN);
 
 	/* We first initialize all blocks in the LRU list as old and then use
@@ -1077,7 +1143,7 @@ buf_LRU_old_init(void)
 	buf_pool->LRU_old = UT_LIST_GET_FIRST(buf_pool->LRU);
 	buf_pool->LRU_old_len = UT_LIST_GET_LEN(buf_pool->LRU);
 
-	buf_LRU_old_adjust_len();
+	buf_LRU_old_adjust_len(buf_pool);
 }
 
 /******************************************************************//**
@@ -1088,10 +1154,12 @@ buf_unzip_LRU_remove_block_if_needed(
 /*=================================*/
 	buf_page_t*	bpage)	/*!< in/out: control block */
 {
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+
 	ut_ad(buf_pool);
 	ut_ad(bpage);
 	ut_ad(buf_page_in_file(bpage));
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	if (buf_page_belongs_to_unzip_LRU(bpage)) {
 		buf_block_t*	block = (buf_block_t*) bpage;
@@ -1111,9 +1179,11 @@ buf_LRU_remove_block(
 /*=================*/
 	buf_page_t*	bpage)	/*!< in: control block */
 {
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+
 	ut_ad(buf_pool);
 	ut_ad(bpage);
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	ut_a(buf_page_in_file(bpage));
 
@@ -1127,7 +1197,7 @@ buf_LRU_remove_block(
 		/* Below: the previous block is guaranteed to exist,
 		because the LRU_old pointer is only allowed to differ
 		by BUF_LRU_OLD_TOLERANCE from strict
-		buf_LRU_old_ratio/BUF_LRU_OLD_RATIO_DIV of the LRU
+		buf_pool->LRU_old_ratio/BUF_LRU_OLD_RATIO_DIV of the LRU
 		list length. */
 		buf_page_t*	prev_bpage = UT_LIST_GET_PREV(LRU, bpage);
 
@@ -1173,7 +1243,7 @@ buf_LRU_remove_block(
 	}
 
 	/* Adjust the length of the old block list if necessary */
-	buf_LRU_old_adjust_len();
+	buf_LRU_old_adjust_len(buf_pool);
 }
 
 /******************************************************************//**
@@ -1186,9 +1256,11 @@ buf_unzip_LRU_add_block(
 	ibool		old)	/*!< in: TRUE if should be put to the end
 				of the list, else put to the start */
 {
+	buf_pool_t*	buf_pool = buf_pool_from_block(block);
+
 	ut_ad(buf_pool);
 	ut_ad(block);
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	ut_a(buf_page_belongs_to_unzip_LRU(&block->page));
 
@@ -1210,9 +1282,11 @@ buf_LRU_add_block_to_end_low(
 /*=========================*/
 	buf_page_t*	bpage)	/*!< in: control block */
 {
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+
 	ut_ad(buf_pool);
 	ut_ad(bpage);
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	ut_a(buf_page_in_file(bpage));
 
@@ -1228,14 +1302,14 @@ buf_LRU_add_block_to_end_low(
 
 		buf_page_set_old(bpage, TRUE);
 		buf_pool->LRU_old_len++;
-		buf_LRU_old_adjust_len();
+		buf_LRU_old_adjust_len(buf_pool);
 
 	} else if (UT_LIST_GET_LEN(buf_pool->LRU) == BUF_LRU_OLD_MIN_LEN) {
 
 		/* The LRU list is now long enough for LRU_old to become
 		defined: init it */
 
-		buf_LRU_old_init();
+		buf_LRU_old_init(buf_pool);
 	} else {
 		buf_page_set_old(bpage, buf_pool->LRU_old != NULL);
 	}
@@ -1259,9 +1333,11 @@ buf_LRU_add_block_low(
 				LRU list is very short, the block is added to
 				the start, regardless of this parameter */
 {
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+
 	ut_ad(buf_pool);
 	ut_ad(bpage);
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	ut_a(buf_page_in_file(bpage));
 	ut_ad(!bpage->in_LRU_list);
@@ -1295,14 +1371,14 @@ buf_LRU_add_block_low(
 		/* Adjust the length of the old block list if necessary */
 
 		buf_page_set_old(bpage, old);
-		buf_LRU_old_adjust_len();
+		buf_LRU_old_adjust_len(buf_pool);
 
 	} else if (UT_LIST_GET_LEN(buf_pool->LRU) == BUF_LRU_OLD_MIN_LEN) {
 
 		/* The LRU list is now long enough for LRU_old to become
 		defined: init it */
 
-		buf_LRU_old_init();
+		buf_LRU_old_init(buf_pool);
 	} else {
 		buf_page_set_old(bpage, buf_pool->LRU_old != NULL);
 	}
@@ -1338,7 +1414,9 @@ buf_LRU_make_block_young(
 /*=====================*/
 	buf_page_t*	bpage)	/*!< in: control block */
 {
-	ut_ad(buf_pool_mutex_own());
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
 	if (bpage->old) {
 		buf_pool->stat.n_pages_made_young++;
@@ -1365,10 +1443,10 @@ Try to free a block.  If bpage is a descriptor of a compressed-only
 page, the descriptor object will be freed as well.
 
 NOTE: If this function returns BUF_LRU_FREED, it will not temporarily
-release buf_pool_mutex.  Furthermore, the page frame will no longer be
+release buf_pool->mutex.  Furthermore, the page frame will no longer be
 accessible via bpage.
 
-The caller must hold buf_pool_mutex and buf_page_get_mutex(bpage) and
+The caller must hold buf_pool->mutex and buf_page_get_mutex(bpage) and
 release these two mutexes after the call.  No other
 buf_page_get_mutex() may be held when calling this function.
 @return BUF_LRU_FREED if freed, BUF_LRU_CANNOT_RELOCATE or
@@ -1382,13 +1460,14 @@ buf_LRU_free_block(
 				compressed page of an uncompressed page */
 	ibool*		buf_pool_mutex_released)
 				/*!< in: pointer to a variable that will
-				be assigned TRUE if buf_pool_mutex
+				be assigned TRUE if buf_pool->mutex
 				was temporarily released, or NULL */
 {
 	buf_page_t*	b = NULL;
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
 	mutex_t*	block_mutex = buf_page_get_mutex(bpage);
 
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(mutex_own(block_mutex));
 	ut_ad(buf_page_in_file(bpage));
 	ut_ad(bpage->in_LRU_list);
@@ -1427,9 +1506,9 @@ buf_LRU_free_block(
 		If it cannot be allocated (without freeing a block
 		from the LRU list), refuse to free bpage. */
 alloc:
-		buf_pool_mutex_exit_forbid();
-		b = buf_buddy_alloc(sizeof *b, NULL);
-		buf_pool_mutex_exit_allow();
+		buf_pool_mutex_exit_forbid(buf_pool);
+		b = buf_buddy_alloc(buf_pool, sizeof *b, NULL);
+		buf_pool_mutex_exit_allow(buf_pool);
 
 		if (UNIV_UNLIKELY(!b)) {
 			return(BUF_LRU_CANNOT_RELOCATE);
@@ -1451,11 +1530,14 @@ alloc:
 		ut_a(bpage->buf_fix_count == 0);
 
 		if (b) {
+			buf_page_t*	hash_b;
 			buf_page_t*	prev_b	= UT_LIST_GET_PREV(LRU, b);
-			const ulint	fold	= buf_page_address_fold(
+
+			const ulint	fold = buf_page_address_fold(
 				bpage->space, bpage->offset);
-			buf_page_t*	hash_b	= buf_page_hash_get_low(
-				bpage->space, bpage->offset, fold);
+
+			hash_b	= buf_page_hash_get_low(
+				buf_pool, bpage->space, bpage->offset, fold);
 
 			ut_a(!hash_b);
 
@@ -1512,12 +1594,12 @@ alloc:
 					ut_ad(buf_pool->LRU_old);
 					/* Adjust the length of the
 					old block list if necessary */
-					buf_LRU_old_adjust_len();
+					buf_LRU_old_adjust_len(buf_pool);
 				} else if (lru_len == BUF_LRU_OLD_MIN_LEN) {
 					/* The LRU list is now long
 					enough for LRU_old to become
 					defined: init it */
-					buf_LRU_old_init();
+					buf_LRU_old_init(buf_pool);
 				}
 #ifdef UNIV_LRU_DEBUG
 				/* Check that the "old" flag is consistent
@@ -1541,7 +1623,7 @@ alloc:
 
 			/* Prevent buf_page_get_gen() from
 			decompressing the block while we release
-			buf_pool_mutex and block_mutex. */
+			buf_pool->mutex and block_mutex. */
 			b->buf_fix_count++;
 			b->io_fix = BUF_IO_READ;
 		}
@@ -1550,7 +1632,7 @@ alloc:
 			*buf_pool_mutex_released = TRUE;
 		}
 
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 		mutex_exit(block_mutex);
 
 		/* Remove possible adaptive hash index on the page.
@@ -1582,14 +1664,14 @@ alloc:
 				: BUF_NO_CHECKSUM_MAGIC);
 		}
 
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 		mutex_enter(block_mutex);
 
 		if (b) {
-			mutex_enter(&buf_pool_zip_mutex);
+			mutex_enter(&buf_pool->zip_mutex);
 			b->buf_fix_count--;
 			buf_page_set_io_fix(b, BUF_IO_NONE);
-			mutex_exit(&buf_pool_zip_mutex);
+			mutex_exit(&buf_pool->zip_mutex);
 		}
 
 		buf_LRU_block_free_hashed_page((buf_block_t*) bpage);
@@ -1597,7 +1679,7 @@ alloc:
 		/* The block_mutex should have been released by
 		buf_LRU_block_remove_hashed_page() when it returns
 		BUF_BLOCK_ZIP_FREE. */
-		ut_ad(block_mutex == &buf_pool_zip_mutex);
+		ut_ad(block_mutex == &buf_pool->zip_mutex);
 		mutex_enter(block_mutex);
 	}
 
@@ -1612,10 +1694,11 @@ buf_LRU_block_free_non_file_page(
 /*=============================*/
 	buf_block_t*	block)	/*!< in: block, must not contain a file page */
 {
-	void*	data;
+	void*		data;
+	buf_pool_t*	buf_pool = buf_pool_from_block(block);
 
 	ut_ad(block);
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(mutex_own(&block->mutex));
 
 	switch (buf_block_get_state(block)) {
@@ -1649,9 +1732,12 @@ buf_LRU_block_free_non_file_page(
 	if (data) {
 		block->page.zip.data = NULL;
 		mutex_exit(&block->mutex);
-		buf_pool_mutex_exit_forbid();
-		buf_buddy_free(data, page_zip_get_size(&block->page.zip));
-		buf_pool_mutex_exit_allow();
+		buf_pool_mutex_exit_forbid(buf_pool);
+
+		buf_buddy_free(
+			buf_pool, data, page_zip_get_size(&block->page.zip));
+
+		buf_pool_mutex_exit_allow(buf_pool);
 		mutex_enter(&block->mutex);
 		page_zip_set_size(&block->page.zip, 0);
 	}
@@ -1665,7 +1751,7 @@ buf_LRU_block_free_non_file_page(
 /******************************************************************//**
 Takes a block out of the LRU list and page hash table.
 If the block is compressed-only (BUF_BLOCK_ZIP_PAGE),
-the object will be freed and buf_pool_zip_mutex will be released.
+the object will be freed and buf_pool->zip_mutex will be released.
 
 If a compressed page or a compressed-only block descriptor is freed,
 other compressed pages or compressed-only block descriptors may be
@@ -1684,8 +1770,10 @@ buf_LRU_block_remove_hashed_page(
 {
 	ulint			fold;
 	const buf_page_t*	hashed_bpage;
+	buf_pool_t*		buf_pool = buf_pool_from_bpage(bpage);
+
 	ut_ad(bpage);
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 
 	ut_a(buf_page_get_io_fix(bpage) == BUF_IO_NONE);
@@ -1767,8 +1855,8 @@ buf_LRU_block_remove_hashed_page(
 	}
 
 	fold = buf_page_address_fold(bpage->space, bpage->offset);
-	hashed_bpage = buf_page_hash_get_low(bpage->space, bpage->offset,
-					     fold);
+	hashed_bpage = buf_page_hash_get_low(
+		buf_pool, bpage->space, bpage->offset, fold);
 
 	if (UNIV_UNLIKELY(bpage != hashed_bpage)) {
 		fprintf(stderr,
@@ -1788,7 +1876,7 @@ buf_LRU_block_remove_hashed_page(
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 		mutex_exit(buf_page_get_mutex(bpage));
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 		buf_print();
 		buf_LRU_print();
 		buf_validate();
@@ -1811,12 +1899,16 @@ buf_LRU_block_remove_hashed_page(
 
 		UT_LIST_REMOVE(list, buf_pool->zip_clean, bpage);
 
-		mutex_exit(&buf_pool_zip_mutex);
-		buf_pool_mutex_exit_forbid();
-		buf_buddy_free(bpage->zip.data,
-			       page_zip_get_size(&bpage->zip));
-		buf_buddy_free(bpage, sizeof(*bpage));
-		buf_pool_mutex_exit_allow();
+		mutex_exit(&buf_pool->zip_mutex);
+		buf_pool_mutex_exit_forbid(buf_pool);
+
+		buf_buddy_free(
+			buf_pool, bpage->zip.data,
+			page_zip_get_size(&bpage->zip));
+
+		buf_buddy_free(buf_pool, bpage, sizeof(*bpage));
+		buf_pool_mutex_exit_allow(buf_pool);
+
 		UNIV_MEM_UNDESC(bpage);
 		return(BUF_BLOCK_ZIP_FREE);
 
@@ -1838,9 +1930,13 @@ buf_LRU_block_remove_hashed_page(
 			ut_ad(!bpage->in_flush_list);
 			ut_ad(!bpage->in_LRU_list);
 			mutex_exit(&((buf_block_t*) bpage)->mutex);
-			buf_pool_mutex_exit_forbid();
-			buf_buddy_free(data, page_zip_get_size(&bpage->zip));
-			buf_pool_mutex_exit_allow();
+			buf_pool_mutex_exit_forbid(buf_pool);
+
+			buf_buddy_free(
+				buf_pool, data,
+				page_zip_get_size(&bpage->zip));
+
+			buf_pool_mutex_exit_allow(buf_pool);
 			mutex_enter(&((buf_block_t*) bpage)->mutex);
 			page_zip_set_size(&bpage->zip, 0);
 		}
@@ -1869,7 +1965,10 @@ buf_LRU_block_free_hashed_page(
 	buf_block_t*	block)	/*!< in: block, must contain a file page and
 				be in a state where it can be freed */
 {
-	ut_ad(buf_pool_mutex_own());
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_block(block);
+	ut_ad(buf_pool_mutex_own(buf_pool));
+#endif
 	ut_ad(mutex_own(&block->mutex));
 
 	buf_block_set_state(block, BUF_BLOCK_MEMORY);
@@ -1878,17 +1977,18 @@ buf_LRU_block_free_hashed_page(
 }
 
 /**********************************************************************//**
-Updates buf_LRU_old_ratio.
+Updates buf_pool->LRU_old_ratio for one buffer pool instance.
 @return	updated old_pct */
-UNIV_INTERN
+static
 uint
-buf_LRU_old_ratio_update(
-/*=====================*/
-	uint	old_pct,/*!< in: Reserve this percentage of
-			the buffer pool for "old" blocks. */
-	ibool	adjust)	/*!< in: TRUE=adjust the LRU list;
-			FALSE=just assign buf_LRU_old_ratio
-			during the initialization of InnoDB */
+buf_LRU_old_ratio_update_instance(
+/*==============================*/
+	buf_pool_t*	buf_pool,/*!< in: buffer pool instance */
+	uint		old_pct,/*!< in: Reserve this percentage of
+				the buffer pool for "old" blocks. */
+	ibool		adjust)	/*!< in: TRUE=adjust the LRU list;
+				FALSE=just assign buf_pool->LRU_old_ratio
+				during the initialization of InnoDB */
 {
 	uint	ratio;
 
@@ -1900,27 +2000,55 @@ buf_LRU_old_ratio_update(
 	}
 
 	if (adjust) {
-		buf_pool_mutex_enter();
+		buf_pool_mutex_enter(buf_pool);
 
-		if (ratio != buf_LRU_old_ratio) {
-			buf_LRU_old_ratio = ratio;
+		if (ratio != buf_pool->LRU_old_ratio) {
+			buf_pool->LRU_old_ratio = ratio;
 
 			if (UT_LIST_GET_LEN(buf_pool->LRU)
-			    >= BUF_LRU_OLD_MIN_LEN) {
-				buf_LRU_old_adjust_len();
+			   >= BUF_LRU_OLD_MIN_LEN) {
+
+				buf_LRU_old_adjust_len(buf_pool);
 			}
 		}
 
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 	} else {
-		buf_LRU_old_ratio = ratio;
+		buf_pool->LRU_old_ratio = ratio;
 	}
-
 	/* the reverse of 
 	ratio = old_pct * BUF_LRU_OLD_RATIO_DIV / 100 */
 	return((uint) (ratio * 100 / (double) BUF_LRU_OLD_RATIO_DIV + 0.5));
 }
 
+/**********************************************************************//**
+Updates buf_pool->LRU_old_ratio.
+@return	updated old_pct */
+UNIV_INTERN
+ulint
+buf_LRU_old_ratio_update(
+/*=====================*/
+	uint	old_pct,/*!< in: Reserve this percentage of
+			the buffer pool for "old" blocks. */
+	ibool	adjust)	/*!< in: TRUE=adjust the LRU list;
+			FALSE=just assign buf_pool->LRU_old_ratio
+			during the initialization of InnoDB */
+{
+	ulint	i;
+	ulint	new_ratio = 0;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+
+		new_ratio = buf_LRU_old_ratio_update_instance(
+			buf_pool, old_pct, adjust);
+	}
+
+	return(new_ratio);
+}
+
 /********************************************************************//**
 Update the historical stats that we are collecting for LRU eviction
 policy at the end of each interval. */
@@ -1929,14 +2057,25 @@ void
 buf_LRU_stat_update(void)
 /*=====================*/
 {
+	ulint		i;
 	buf_LRU_stat_t*	item;
+	buf_pool_t*	buf_pool;
+	ibool		evict_started = FALSE;
 
 	/* If we haven't started eviction yet then don't update stats. */
-	if (buf_pool->freed_page_clock == 0) {
-		goto func_exit;
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+
+		buf_pool = buf_pool_from_array(i);
+
+		if (buf_pool->freed_page_clock != 0) {
+			evict_started = TRUE;
+			break;
+		}
 	}
 
-	buf_pool_mutex_enter();
+	if (!evict_started) {
+		goto func_exit;
+	}
 
 	/* Update the index. */
 	item = &buf_LRU_stat_arr[buf_LRU_stat_arr_ind];
@@ -1950,8 +2089,6 @@ buf_LRU_stat_update(void)
 	/* Put current entry in the array. */
 	memcpy(item, &buf_LRU_stat_cur, sizeof *item);
 
-	buf_pool_mutex_exit();
-
 func_exit:
 	/* Clear the current entry. */
 	memset(&buf_LRU_stat_cur, 0, sizeof buf_LRU_stat_cur);
@@ -1959,12 +2096,12 @@ func_exit:
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 /**********************************************************************//**
-Validates the LRU list.
-@return	TRUE */
-UNIV_INTERN
-ibool
-buf_LRU_validate(void)
-/*==================*/
+Validates the LRU list for one buffer pool instance. */
+static
+void
+buf_LRU_validate_instance(
+/*======================*/
+	buf_pool_t*	buf_pool)
 {
 	buf_page_t*	bpage;
 	buf_block_t*	block;
@@ -1972,14 +2109,15 @@ buf_LRU_validate(void)
 	ulint		new_len;
 
 	ut_ad(buf_pool);
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	if (UT_LIST_GET_LEN(buf_pool->LRU) >= BUF_LRU_OLD_MIN_LEN) {
 
 		ut_a(buf_pool->LRU_old);
 		old_len = buf_pool->LRU_old_len;
 		new_len = ut_min(UT_LIST_GET_LEN(buf_pool->LRU)
-				 * buf_LRU_old_ratio / BUF_LRU_OLD_RATIO_DIV,
+				 * buf_pool->LRU_old_ratio
+				 / BUF_LRU_OLD_RATIO_DIV,
 				 UT_LIST_GET_LEN(buf_pool->LRU)
 				 - (BUF_LRU_OLD_TOLERANCE
 				    + BUF_LRU_NON_OLD_MIN_LEN));
@@ -2055,23 +2193,43 @@ buf_LRU_validate(void)
 		ut_a(buf_page_belongs_to_unzip_LRU(&block->page));
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
+}
+
+/**********************************************************************//**
+Validates the LRU list.
+@return	TRUE */
+UNIV_INTERN
+ibool
+buf_LRU_validate(void)
+/*==================*/
+{
+	ulint	i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+		buf_LRU_validate_instance(buf_pool);
+	}
+
 	return(TRUE);
 }
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
 #if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 /**********************************************************************//**
-Prints the LRU list. */
+Prints the LRU list for one buffer pool instance. */
 UNIV_INTERN
 void
-buf_LRU_print(void)
-/*===============*/
+buf_LRU_print_instance(
+/*===================*/
+	buf_pool_t*	buf_pool)
 {
 	const buf_page_t*	bpage;
 
 	ut_ad(buf_pool);
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	bpage = UT_LIST_GET_FIRST(buf_pool->LRU);
 
@@ -2130,6 +2288,22 @@ buf_LRU_print(void)
 		bpage = UT_LIST_GET_NEXT(LRU, bpage);
 	}
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
+}
+
+/**********************************************************************//**
+Prints the LRU list. */
+UNIV_INTERN
+void
+buf_LRU_print(void)
+/*===============*/
+{
+	ulint		i;
+	buf_pool_t*	buf_pool;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool = buf_pool_from_array(i);
+		buf_LRU_print_instance(buf_pool);
+	}
 }
 #endif /* UNIV_DEBUG_PRINT || UNIV_DEBUG || UNIV_BUF_DEBUG */
diff --git a/storage/innobase/buf/buf0rea.c b/storage/innobase/buf/buf0rea.c
index 81f788baac2..99a56bf91bc 100644
--- a/storage/innobase/buf/buf0rea.c
+++ b/storage/innobase/buf/buf0rea.c
@@ -171,6 +171,7 @@ buf_read_page(
 	ulint	zip_size,/*!< in: compressed page size in bytes, or 0 */
 	ulint	offset)	/*!< in: page number */
 {
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 	ib_int64_t	tablespace_version;
 	ulint		count;
 	ulint		err;
@@ -195,7 +196,7 @@ buf_read_page(
 	}
 
 	/* Flush pages from the end of the LRU list if necessary */
-	buf_flush_free_margin();
+	buf_flush_free_margin(buf_pool);
 
 	/* Increment number of I/O operations used for LRU policy. */
 	buf_LRU_stat_inc_io();
@@ -236,6 +237,7 @@ buf_read_ahead_linear(
 	ulint	offset)	/*!< in: page number of a page; NOTE: the current thread
 			must want access to this page (see NOTE 3 above) */
 {
+	buf_pool_t*	buf_pool = buf_pool_get(space, offset);
 	ib_int64_t	tablespace_version;
 	buf_page_t*	bpage;
 	buf_frame_t*	frame;
@@ -251,7 +253,7 @@ buf_read_ahead_linear(
 	ulint		err;
 	ulint		i;
 	const ulint	buf_read_ahead_linear_area
-		= BUF_READ_AHEAD_LINEAR_AREA;
+		= BUF_READ_AHEAD_LINEAR_AREA(buf_pool);
 	ulint		threshold;
 
 	if (UNIV_UNLIKELY(srv_startup_is_before_trx_rollback_phase)) {
@@ -286,10 +288,10 @@ buf_read_ahead_linear(
 
 	tablespace_version = fil_space_get_version(space);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
 	if (high > fil_space_get_size(space)) {
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 		/* The area is not whole, return */
 
 		return(0);
@@ -297,7 +299,7 @@ buf_read_ahead_linear(
 
 	if (buf_pool->n_pend_reads
 	    > buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) {
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		return(0);
 	}
@@ -315,14 +317,14 @@ buf_read_ahead_linear(
 	/* How many out of order accessed pages can we ignore
 	when working out the access pattern for linear readahead */
 	threshold = ut_min((64 - srv_read_ahead_threshold),
-			   BUF_READ_AHEAD_AREA);
+			   BUF_READ_AHEAD_AREA(buf_pool));
 
 	fail_count = 0;
 
 	for (i = low; i < high; i++) {
-		bpage = buf_page_hash_get(space, i);
+		bpage = buf_page_hash_get(buf_pool, space, i);
 
-		if ((bpage == NULL) || !buf_page_is_accessed(bpage)) {
+		if (bpage == NULL || !buf_page_is_accessed(bpage)) {
 			/* Not accessed */
 			fail_count++;
 
@@ -346,7 +348,7 @@ buf_read_ahead_linear(
 
 		if (fail_count > threshold) {
 			/* Too many failures: return */
-			buf_pool_mutex_exit();
+			buf_pool_mutex_exit(buf_pool);
 			return(0);
 		}
 
@@ -358,10 +360,10 @@ buf_read_ahead_linear(
 	/* If we got this far, we know that enough pages in the area have
 	been accessed in the right order: linear read-ahead can be sensible */
 
-	bpage = buf_page_hash_get(space, offset);
+	bpage = buf_page_hash_get(buf_pool, space, offset);
 
 	if (bpage == NULL) {
-		buf_pool_mutex_exit();
+		buf_pool_mutex_exit(buf_pool);
 
 		return(0);
 	}
@@ -387,7 +389,7 @@ buf_read_ahead_linear(
 	pred_offset = fil_page_get_prev(frame);
 	succ_offset = fil_page_get_next(frame);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	if ((offset == low) && (succ_offset == offset + 1)) {
 
@@ -466,7 +468,7 @@ buf_read_ahead_linear(
 	os_aio_simulated_wake_handler_threads();
 
 	/* Flush pages from the end of the LRU list if necessary */
-	buf_flush_free_margin();
+	buf_flush_free_margin(buf_pool);
 
 #ifdef UNIV_DEBUG
 	if (buf_debug_prints && (count > 0)) {
@@ -518,14 +520,18 @@ buf_read_ibuf_merge_pages(
 #ifdef UNIV_IBUF_DEBUG
 	ut_a(n_stored < UNIV_PAGE_SIZE);
 #endif
-	while (buf_pool->n_pend_reads
-	       > buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) {
-		os_thread_sleep(500000);
-	}
 
 	for (i = 0; i < n_stored; i++) {
-		ulint	zip_size = fil_space_get_zip_size(space_ids[i]);
-		ulint	err;
+		ulint		err;
+		buf_pool_t*	buf_pool;
+		ulint		zip_size = fil_space_get_zip_size(space_ids[i]);
+
+		buf_pool = buf_pool_get(space_ids[i], space_versions[i]);
+
+		while (buf_pool->n_pend_reads
+		       > buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) {
+			os_thread_sleep(500000);
+		}
 
 		if (UNIV_UNLIKELY(zip_size == ULINT_UNDEFINED)) {
 
@@ -550,8 +556,8 @@ tablespace_deleted:
 
 	os_aio_simulated_wake_handler_threads();
 
-	/* Flush pages from the end of the LRU list if necessary */
-	buf_flush_free_margin();
+	/* Flush pages from the end of all the LRU lists if necessary */
+	buf_flush_free_margins();
 
 #ifdef UNIV_DEBUG
 	if (buf_debug_prints) {
@@ -600,11 +606,12 @@ buf_read_recv_pages(
 	tablespace_version = fil_space_get_version(space);
 
 	for (i = 0; i < n_stored; i++) {
+		buf_pool_t*	buf_pool;
 
 		count = 0;
 
 		os_aio_print_debug = FALSE;
-
+		buf_pool = buf_pool_get(space, page_nos[i]);
 		while (buf_pool->n_pend_reads >= recv_n_pool_free_frames / 2) {
 
 			os_aio_simulated_wake_handler_threads();
@@ -643,8 +650,8 @@ buf_read_recv_pages(
 
 	os_aio_simulated_wake_handler_threads();
 
-	/* Flush pages from the end of the LRU list if necessary */
-	buf_flush_free_margin();
+	/* Flush pages from the end of all the LRU lists if necessary */
+	buf_flush_free_margins();
 
 #ifdef UNIV_DEBUG
 	if (buf_debug_prints) {
diff --git a/storage/innobase/ha/ha0ha.c b/storage/innobase/ha/ha0ha.c
index db85288298d..9d9d341ad39 100644
--- a/storage/innobase/ha/ha0ha.c
+++ b/storage/innobase/ha/ha0ha.c
@@ -403,8 +403,6 @@ ha_print_info(
 	FILE*		file,	/*!< in: file where to print */
 	hash_table_t*	table)	/*!< in: hash table */
 {
-	ut_ad(table);
-	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 #ifdef UNIV_DEBUG
 /* Some of the code here is disabled for performance reasons in production
 builds, see http://bugs.mysql.com/36941 */
@@ -418,6 +416,8 @@ builds, see http://bugs.mysql.com/36941 */
 #endif /* PRINT_USED_CELLS */
 	ulint		n_bufs;
 
+	ut_ad(table);
+	ut_ad(table->magic_n == HASH_TABLE_MAGIC_N);
 #ifdef PRINT_USED_CELLS
 	for (i = 0; i < hash_get_n_cells(table); i++) {
 
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index fb3db95f33e..e526be7c55c 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -135,6 +135,7 @@ static long innobase_mirrored_log_groups, innobase_log_files_in_group,
 static ulong innobase_commit_concurrency = 0;
 static ulong innobase_read_io_threads;
 static ulong innobase_write_io_threads;
+static long innobase_buffer_pool_instances = 1;
 
 static long long innobase_buffer_pool_size, innobase_log_file_size;
 
@@ -241,7 +242,7 @@ static PSI_mutex_info all_innodb_mutexes[] = {
 	{&file_format_max_mutex_key, "file_format_max_mutex", 0},
 	{&fil_system_mutex_key, "fil_system_mutex", 0},
 	{&flush_list_mutex_key, "flush_list_mutex", 0},
-	{&flush_order_mutex_key, "flush_order_mutex", 0},
+	{&log_flush_order_mutex_key, "log_flush_order_mutex", 0},
 	{&hash_table_mutex_key, "hash_table_mutex", 0},
 	{&ibuf_bitmap_mutex_key, "ibuf_bitmap_mutex", 0},
 	{&ibuf_mutex_key, "ibuf_mutex", 0},
@@ -2305,6 +2306,7 @@ innobase_change_buffering_inited_ok:
 	srv_log_buffer_size = (ulint) innobase_log_buffer_size;
 
 	srv_buf_pool_size = (ulint) innobase_buffer_pool_size;
+	srv_buf_pool_instances = (ulint) innobase_buffer_pool_instances;
 
 	srv_mem_pool_size = (ulint) innobase_additional_mem_pool_size;
 
@@ -2348,9 +2350,6 @@ innobase_change_buffering_inited_ok:
 	ut_a(0 == strcmp(my_charset_latin1.name, "latin1_swedish_ci"));
 	srv_latin1_ordering = my_charset_latin1.sort_order;
 
-	innobase_old_blocks_pct = buf_LRU_old_ratio_update(
-		innobase_old_blocks_pct, FALSE);
-
 	innobase_commit_concurrency_init_default();
 
 #ifdef HAVE_PSI_INTERFACE
@@ -2404,6 +2403,9 @@ innobase_change_buffering_inited_ok:
 		goto mem_free_and_error;
 	}
 
+	innobase_old_blocks_pct = buf_LRU_old_ratio_update(
+		innobase_old_blocks_pct, TRUE);
+
 	innobase_open_tables = hash_create(200);
 	mysql_mutex_init(innobase_share_mutex_key,
 			 &innobase_share_mutex,
@@ -3337,6 +3339,8 @@ innobase_build_index_translation(
 
 	DBUG_ENTER("innobase_build_index_translation");
 
+	mutex_enter(&dict_sys->mutex);
+
 	mysql_num_index = table->s->keys;
 	ib_num_index = UT_LIST_GET_LEN(ib_table->indexes);
 
@@ -3367,6 +3371,13 @@ innobase_build_index_translation(
 							MYF(MY_ALLOW_ZERO_PTR));
 
 		if (!index_mapping) {
+			/* Report an error if index_mapping continues to be
+			NULL and mysql_num_index is a non-zero value */
+			sql_print_error("InnoDB: fail to allocate memory for "
+					"index translation table. Number of "
+					"Index:%lu, array size:%lu",
+					mysql_num_index,
+					share->idx_trans_tbl.array_size);
 			ret = FALSE;
 			goto func_exit;
 		}
@@ -3374,7 +3385,6 @@ innobase_build_index_translation(
 		share->idx_trans_tbl.array_size = mysql_num_index;
 	}
 
-
 	/* For each index in the mysql key_info array, fetch its
 	corresponding InnoDB index pointer into index_mapping
 	array. */
@@ -3420,6 +3430,8 @@ func_exit:
 
 	share->idx_trans_tbl.index_mapping = index_mapping;
 
+	mutex_exit(&dict_sys->mutex);
+
 	DBUG_RETURN(ret);
 }
 
@@ -10813,6 +10825,11 @@ static MYSQL_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,
   "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
   NULL, NULL, 128*1024*1024L, 5*1024*1024L, LONGLONG_MAX, 1024*1024L);
 
+static MYSQL_SYSVAR_LONG(buffer_pool_instances, innobase_buffer_pool_instances,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Number of buffer pool instances, set to higher value on high-end machines to increase scalability",
+  NULL, NULL, 1L, 1L, MAX_BUFFER_POOLS, 1L);
+
 static MYSQL_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
   PLUGIN_VAR_RQCMDARG,
   "Helps in performance tuning in heavily concurrent environments.",
@@ -10948,6 +10965,7 @@ static struct st_mysql_sys_var* innobase_system_variables[]= {
   MYSQL_SYSVAR(additional_mem_pool_size),
   MYSQL_SYSVAR(autoextend_increment),
   MYSQL_SYSVAR(buffer_pool_size),
+  MYSQL_SYSVAR(buffer_pool_instances),
   MYSQL_SYSVAR(checksums),
   MYSQL_SYSVAR(commit_concurrency),
   MYSQL_SYSVAR(concurrency_tickets),
diff --git a/storage/innobase/handler/i_s.cc b/storage/innobase/handler/i_s.cc
index 7d8b4a8dd40..ed429a9175f 100644
--- a/storage/innobase/handler/i_s.cc
+++ b/storage/innobase/handler/i_s.cc
@@ -1307,6 +1307,14 @@ static ST_FIELD_INFO	i_s_cmpmem_fields_info[] =
 	 STRUCT_FLD(old_name,		"Buddy Block Size"),
 	 STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
 
+	{STRUCT_FLD(field_name,		"buffer_pool_instance"),
+	STRUCT_FLD(field_length,	MY_INT32_NUM_DECIMAL_DIGITS),
+	STRUCT_FLD(field_type,		MYSQL_TYPE_LONG),
+	STRUCT_FLD(value,		0),
+	STRUCT_FLD(field_flags,	0),
+	STRUCT_FLD(old_name,		"Buffer Pool Id"),
+	STRUCT_FLD(open_method,	SKIP_OPEN_TABLE)},
+
 	{STRUCT_FLD(field_name,		"pages_used"),
 	 STRUCT_FLD(field_length,	MY_INT32_NUM_DECIMAL_DIGITS),
 	 STRUCT_FLD(field_type,		MYSQL_TYPE_LONG),
@@ -1356,8 +1364,8 @@ i_s_cmpmem_fill_low(
 	COND*		cond,	/*!< in: condition (ignored) */
 	ibool		reset)	/*!< in: TRUE=reset cumulated counts */
 {
+	int		status = 0;
 	TABLE*	table	= (TABLE *) tables->table;
-	int	status	= 0;
 
 	DBUG_ENTER("i_s_cmpmem_fill_low");
 
@@ -1369,33 +1377,50 @@ i_s_cmpmem_fill_low(
 
 	RETURN_IF_INNODB_NOT_STARTED(tables->schema_table_name);
 
-	buf_pool_mutex_enter();
+	for (ulint i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
 
-	for (uint x = 0; x <= BUF_BUDDY_SIZES; x++) {
-		buf_buddy_stat_t*	buddy_stat = &buf_buddy_stat[x];
+		status	= 0;
 
-		table->field[0]->store(BUF_BUDDY_LOW << x);
-		table->field[1]->store(buddy_stat->used);
-		table->field[2]->store(UNIV_LIKELY(x < BUF_BUDDY_SIZES)
-				       ? UT_LIST_GET_LEN(buf_pool->zip_free[x])
-				       : 0);
-		table->field[3]->store((longlong) buddy_stat->relocated, true);
-		table->field[4]->store(
-			(ulong) (buddy_stat->relocated_usec / 1000000));
+		buf_pool = buf_pool_from_array(i);
 
-		if (reset) {
-			/* This is protected by buf_pool_mutex. */
-			buddy_stat->relocated = 0;
-			buddy_stat->relocated_usec = 0;
+		buf_pool_mutex_enter(buf_pool);
+
+		for (uint x = 0; x <= BUF_BUDDY_SIZES; x++) {
+			buf_buddy_stat_t*	buddy_stat;
+
+			buddy_stat = &buf_pool->buddy_stat[x];
+
+			table->field[0]->store(BUF_BUDDY_LOW << x);
+			table->field[1]->store(i);
+			table->field[2]->store(buddy_stat->used);
+			table->field[3]->store(UNIV_LIKELY(x < BUF_BUDDY_SIZES)
+				? UT_LIST_GET_LEN(buf_pool->zip_free[x])
+				: 0);
+			table->field[4]->store((longlong)
+			buddy_stat->relocated, true);
+			table->field[5]->store(
+				(ulong) (buddy_stat->relocated_usec / 1000000));
+
+			if (reset) {
+				/* This is protected by buf_pool->mutex. */
+				buddy_stat->relocated = 0;
+				buddy_stat->relocated_usec = 0;
+			}
+
+			if (schema_table_store_record(thd, table)) {
+				status = 1;
+				break;
+			}
 		}
 
-		if (schema_table_store_record(thd, table)) {
-			status = 1;
+		buf_pool_mutex_exit(buf_pool);
+
+		if (status) {
 			break;
 		}
 	}
 
-	buf_pool_mutex_exit();
 	DBUG_RETURN(status);
 }
 
diff --git a/storage/innobase/ibuf/ibuf0ibuf.c b/storage/innobase/ibuf/ibuf0ibuf.c
index d405d90fe25..0397af88ff4 100644
--- a/storage/innobase/ibuf/ibuf0ibuf.c
+++ b/storage/innobase/ibuf/ibuf0ibuf.c
@@ -2323,7 +2323,7 @@ ibuf_get_merge_page_nos(
 
 	*n_stored = 0;
 
-	limit = ut_min(IBUF_MAX_N_PAGES_MERGED, buf_pool->curr_size / 4);
+	limit = ut_min(IBUF_MAX_N_PAGES_MERGED, buf_pool_get_curr_size() / 4);
 
 	if (page_rec_is_supremum(rec)) {
 
@@ -3139,9 +3139,9 @@ ibuf_set_entry_counter(
 	ibool		is_optimistic,	/*!< in: is this an optimistic insert */
 	mtr_t*		mtr)		/*!< in: mtr */
 {
-	ulint		counter;
 	dfield_t*	field;
 	byte*		data;
+	ulint		counter = 0;
 
 	/* pcur points to either a user rec or to a page's infimum record. */
 	ut_ad(page_validate(btr_pcur_get_page(pcur), ibuf->index));
@@ -3682,10 +3682,11 @@ check_watch:
 	{
 		buf_page_t*	bpage;
 		ulint		fold = buf_page_address_fold(space, page_no);
+		buf_pool_t*	buf_pool = buf_pool_get(space, page_no);
 
-		buf_pool_mutex_enter();
-		bpage = buf_page_hash_get_low(space, page_no, fold);
-		buf_pool_mutex_exit();
+		buf_pool_mutex_enter(buf_pool);
+		bpage = buf_page_hash_get_low(buf_pool, space, page_no, fold);
+		buf_pool_mutex_exit(buf_pool);
 
 		if (UNIV_LIKELY_NULL(bpage)) {
 			/* A buffer pool watch has been set or the
diff --git a/storage/innobase/include/buf0buddy.h b/storage/innobase/include/buf0buddy.h
index 7648950d5d1..03588d18197 100644
--- a/storage/innobase/include/buf0buddy.h
+++ b/storage/innobase/include/buf0buddy.h
@@ -36,22 +36,24 @@ Created December 2006 by Marko Makela
 
 /**********************************************************************//**
 Allocate a block.  The thread calling this function must hold
-buf_pool_mutex and must not hold buf_pool_zip_mutex or any
-block->mutex.  The buf_pool_mutex may only be released and reacquired
+buf_pool->mutex and must not hold buf_pool_zip_mutex or any
+block->mutex.  The buf_pool->mutex may only be released and reacquired
 if lru != NULL.  This function should only be used for allocating
 compressed page frames or control blocks (buf_page_t).  Allocated
 control blocks must be properly initialized immediately after
 buf_buddy_alloc() has returned the memory, before releasing
-buf_pool_mutex.
+buf_pool->mutex.
 @return	allocated block, possibly NULL if lru == NULL */
 UNIV_INLINE
 void*
 buf_buddy_alloc(
 /*============*/
+	buf_pool_t*	buf_pool,
+			/*!< buffer pool in which the block resides */
 	ulint	size,	/*!< in: block size, up to UNIV_PAGE_SIZE */
 	ibool*	lru)	/*!< in: pointer to a variable that will be assigned
 			TRUE if storage was allocated from the LRU list
-			and buf_pool_mutex was temporarily released,
+			and buf_pool->mutex was temporarily released,
 			or NULL if the LRU list should not be used */
 	__attribute__((malloc));
 
@@ -61,28 +63,13 @@ UNIV_INLINE
 void
 buf_buddy_free(
 /*===========*/
+	buf_pool_t*	buf_pool,
+			/*!< buffer pool in which the block resides */
 	void*	buf,	/*!< in: block to be freed, must not be
 			pointed to by the buffer pool */
 	ulint	size)	/*!< in: block size, up to UNIV_PAGE_SIZE */
 	__attribute__((nonnull));
 
-/** Statistics of buddy blocks of a given size. */
-struct buf_buddy_stat_struct {
-	/** Number of blocks allocated from the buddy system. */
-	ulint		used;
-	/** Number of blocks relocated by the buddy system. */
-	ib_uint64_t	relocated;
-	/** Total duration of block relocations, in microseconds. */
-	ib_uint64_t	relocated_usec;
-};
-
-/** Statistics of buddy blocks of a given size. */
-typedef struct buf_buddy_stat_struct buf_buddy_stat_t;
-
-/** Statistics of the buddy system, indexed by block size.
-Protected by buf_pool_mutex. */
-extern buf_buddy_stat_t buf_buddy_stat[BUF_BUDDY_SIZES + 1];
-
 #ifndef UNIV_NONINL
 # include "buf0buddy.ic"
 #endif
diff --git a/storage/innobase/include/buf0buddy.ic b/storage/innobase/include/buf0buddy.ic
index c419a2374d9..387eacc754a 100644
--- a/storage/innobase/include/buf0buddy.ic
+++ b/storage/innobase/include/buf0buddy.ic
@@ -35,18 +35,20 @@ Created December 2006 by Marko Makela
 
 /**********************************************************************//**
 Allocate a block.  The thread calling this function must hold
-buf_pool_mutex and must not hold buf_pool_zip_mutex or any block->mutex.
-The buf_pool_mutex may only be released and reacquired if lru != NULL.
+buf_pool->mutex and must not hold buf_pool_zip_mutex or any block->mutex.
+The buf_pool->mutex may only be released and reacquired if lru != NULL.
 @return	allocated block, possibly NULL if lru==NULL */
 UNIV_INTERN
 void*
 buf_buddy_alloc_low(
 /*================*/
+	buf_pool_t*	buf_pool,
+			/*!< in: buffer pool in which the page resides */
 	ulint	i,	/*!< in: index of buf_pool->zip_free[],
 			or BUF_BUDDY_SIZES */
 	ibool*	lru)	/*!< in: pointer to a variable that will be assigned
 			TRUE if storage was allocated from the LRU list
-			and buf_pool_mutex was temporarily released,
+			and buf_pool->mutex was temporarily released,
 			or NULL if the LRU list should not be used */
 	__attribute__((malloc));
 
@@ -56,10 +58,11 @@ UNIV_INTERN
 void
 buf_buddy_free_low(
 /*===============*/
-	void*	buf,	/*!< in: block to be freed, must not be
-			pointed to by the buffer pool */
-	ulint	i)	/*!< in: index of buf_pool->zip_free[],
-			or BUF_BUDDY_SIZES */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	void*		buf,		/*!< in: block to be freed, must not be
+					pointed to by the buffer pool */
+	ulint		i)		/*!< in: index of buf_pool->zip_free[],
+					or BUF_BUDDY_SIZES */
 	__attribute__((nonnull));
 
 /**********************************************************************//**
@@ -83,27 +86,32 @@ buf_buddy_get_slot(
 
 /**********************************************************************//**
 Allocate a block.  The thread calling this function must hold
-buf_pool_mutex and must not hold buf_pool_zip_mutex or any
-block->mutex.  The buf_pool_mutex may only be released and reacquired
+buf_pool->mutex and must not hold buf_pool_zip_mutex or any
+block->mutex.  The buf_pool->mutex may only be released and reacquired
 if lru != NULL.  This function should only be used for allocating
 compressed page frames or control blocks (buf_page_t).  Allocated
 control blocks must be properly initialized immediately after
 buf_buddy_alloc() has returned the memory, before releasing
-buf_pool_mutex.
+buf_pool->mutex.
 @return	allocated block, possibly NULL if lru == NULL */
 UNIV_INLINE
 void*
 buf_buddy_alloc(
 /*============*/
-	ulint	size,	/*!< in: block size, up to UNIV_PAGE_SIZE */
-	ibool*	lru)	/*!< in: pointer to a variable that will be assigned
-			TRUE if storage was allocated from the LRU list
-			and buf_pool_mutex was temporarily released,
-			or NULL if the LRU list should not be used */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool in which
+					the page resides */
+	ulint		size,		/*!< in: block size, up to
+					UNIV_PAGE_SIZE */
+	ibool*		lru)		/*!< in: pointer to a variable
+					that will be assigned TRUE if
+				       	storage was allocated from the
+				       	LRU list and buf_pool->mutex was
+				       	temporarily released, or NULL if
+				       	the LRU list should not be used */
 {
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
-	return(buf_buddy_alloc_low(buf_buddy_get_slot(size), lru));
+	return(buf_buddy_alloc_low(buf_pool, buf_buddy_get_slot(size), lru));
 }
 
 /**********************************************************************//**
@@ -112,13 +120,15 @@ UNIV_INLINE
 void
 buf_buddy_free(
 /*===========*/
-	void*	buf,	/*!< in: block to be freed, must not be
-			pointed to by the buffer pool */
-	ulint	size)	/*!< in: block size, up to UNIV_PAGE_SIZE */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	void*		buf,		/*!< in: block to be freed, must not be
+					pointed to by the buffer pool */
+	ulint		size)		/*!< in: block size, up to
+					UNIV_PAGE_SIZE */
 {
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 
-	buf_buddy_free_low(buf, buf_buddy_get_slot(size));
+	buf_buddy_free_low(buf_pool, buf, buf_buddy_get_slot(size));
 }
 
 #ifdef UNIV_MATERIALIZE
diff --git a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h
index 62e4f54559a..5326ca9c14f 100644
--- a/storage/innobase/include/buf0buf.h
+++ b/storage/innobase/include/buf0buf.h
@@ -63,7 +63,14 @@ Created 11/5/1995 Heikki Tuuri
 					position of the block. */
 /* @} */
 
-extern buf_pool_t*	buf_pool;	/*!< The buffer pool of the database */
+#define MAX_BUFFER_POOLS 64		/*!< The maximum number of buffer
+					pools that can be defined */
+
+#define BUF_POOL_WATCH_SIZE 1		/*!< Maximum number of concurrent
+					buffer pool watches */
+
+extern	buf_pool_t*	buf_pool_ptr[MAX_BUFFER_POOLS]; /*!< The buffer pools
+					of the database */
 #ifdef UNIV_DEBUG
 extern ibool		buf_debug_prints;/*!< If this is set TRUE, the program
 					prints info whenever read or flush
@@ -71,6 +78,8 @@ extern ibool		buf_debug_prints;/*!< If this is set TRUE, the program
 #endif /* UNIV_DEBUG */
 extern ulint srv_buf_pool_write_requests; /*!< variable to count write request
 					  issued */
+extern ulint srv_buf_pool_instances;
+extern ulint srv_buf_pool_curr_size;
 #else /* !UNIV_HOTBACKUP */
 extern buf_block_t*	back_block1;	/*!< first block, for --apply-log */
 extern buf_block_t*	back_block2;	/*!< second block, for page reorganize */
@@ -109,19 +118,36 @@ enum buf_page_state {
 
 #ifndef UNIV_HOTBACKUP
 /********************************************************************//**
+Acquire mutex on all buffer pool instances */
+UNIV_INLINE
+void
+buf_pool_mutex_enter_all(void);
+/*===========================*/
+
+/********************************************************************//**
+Release mutex on all buffer pool instances */
+UNIV_INLINE
+void
+buf_pool_mutex_exit_all(void);
+/*==========================*/
+
+/********************************************************************//**
 Creates the buffer pool.
 @return	own: buf_pool object, NULL if not enough memory or error */
 UNIV_INTERN
-buf_pool_t*
-buf_pool_init(void);
-/*===============*/
+ulint
+buf_pool_init(
+/*=========*/
+	ulint	size,		/*!< in: Size of the total pool in bytes */
+	ulint	n_instances);	/*!< in: Number of instances */
 /********************************************************************//**
 Frees the buffer pool at shutdown.  This must not be invoked before
 freeing all mutexes. */
 UNIV_INTERN
 void
-buf_pool_free(void);
-/*===============*/
+buf_pool_free(
+/*==========*/
+	ulint	n_instances);	/*!< in: numbere of instances to free */
 
 /********************************************************************//**
 Drops the adaptive hash index.  To prevent a livelock, this function
@@ -158,23 +184,31 @@ UNIV_INLINE
 ulint
 buf_pool_get_curr_size(void);
 /*========================*/
+/*********************************************************************//**
+Gets the current size of buffer buf_pool in frames.
+@return	size in pages */
+UNIV_INLINE
+ulint
+buf_pool_get_n_pages(void);
+/*=======================*/
 /********************************************************************//**
 Gets the smallest oldest_modification lsn for any page in the pool. Returns
 zero if all modified pages have been flushed to disk.
 @return	oldest modification in pool, zero if none */
-UNIV_INLINE
+UNIV_INTERN
 ib_uint64_t
 buf_pool_get_oldest_modification(void);
 /*==================================*/
 /********************************************************************//**
 Allocates a buffer block.
 @return	own: the allocated block, in state BUF_BLOCK_MEMORY */
-UNIV_INLINE
+UNIV_INTERN
 buf_block_t*
 buf_block_alloc(
 /*============*/
-	ulint	zip_size);	/*!< in: compressed page size in bytes,
-				or 0 if uncompressed tablespace */
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	ulint		zip_size);	/*!< in: compressed page size in bytes,
+					or 0 if uncompressed tablespace */
 /********************************************************************//**
 Frees a buffer block which does not contain a file page. */
 UNIV_INLINE
@@ -454,7 +488,7 @@ buf_page_get_newest_modification(
 					page frame */
 /********************************************************************//**
 Increments the modify clock of a frame by 1. The caller must (1) own the
-buf_pool mutex and block bufferfix count has to be zero, (2) or own an x-lock
+buf_pool->mutex and block bufferfix count has to be zero, (2) or own an x-lock
 on the block. */
 UNIV_INLINE
 void
@@ -536,7 +570,8 @@ UNIV_INTERN
 buf_block_t*
 buf_pool_contains_zip(
 /*==================*/
-	const void*	data);	/*!< in: pointer to compressed page */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	const void*	data);		/*!< in: pointer to compressed page */
 #endif /* UNIV_DEBUG */
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 /*********************************************************************//**
@@ -610,8 +645,15 @@ buf_get_modified_ratio_pct(void);
 Refreshes the statistics used to print per-second averages. */
 UNIV_INTERN
 void
-buf_refresh_io_stats(void);
-/*======================*/
+buf_refresh_io_stats(
+/*=================*/
+	buf_pool_t*	buf_pool);	/*!< buffer pool instance */
+/**********************************************************************//**
+Refreshes the statistics used to print per-second averages. */
+UNIV_INTERN
+void
+buf_refresh_io_stats_all(void);
+/*=================*/
 /*********************************************************************//**
 Asserts that all file pages in the buffer are in a replaceable state.
 @return	TRUE */
@@ -992,15 +1034,51 @@ buf_page_address_fold(
 	ulint	offset)	/*!< in: offset of the page within space */
 	__attribute__((const));
 /******************************************************************//**
+Returns the buffer pool instance given a page instance
+@return buf_pool */
+UNIV_INLINE
+buf_pool_t*
+buf_pool_from_bpage(
+/*================*/
+	const buf_page_t*	bpage); /*!< in: buffer pool page */
+/******************************************************************//**
+Returns the buffer pool instance given a block instance
+@return buf_pool */
+UNIV_INLINE
+buf_pool_t*
+buf_pool_from_block(
+/*================*/
+	const buf_block_t*	block); /*!< in: block */
+/******************************************************************//**
+Returns the buffer pool instance given space and offset of page
+@return buffer pool */
+UNIV_INLINE
+buf_pool_t*
+buf_pool_get(
+/*==========*/
+	ulint	space,	/*!< in: space id */
+	ulint	offset);/*!< in: offset of the page within space */
+/******************************************************************//**
+Returns the buffer pool instance given its array index
+@return buffer pool */
+UNIV_INLINE
+buf_pool_t*
+buf_pool_from_array(
+/*====================*/
+	ulint	index);	/*!< in: array index to get buffer pool instance from */
+/******************************************************************//**
 Returns the control block of a file page, NULL if not found.
 @return	block, NULL if not found */
 UNIV_INLINE
 buf_page_t*
 buf_page_hash_get_low(
 /*==================*/
-	ulint	space,	/*!< in: space id */
-	ulint	offset,	/*!< in: offset of the page within space */
-	ulint	fold);	/*!< in: buf_page_address_fold(space, offset) */
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	ulint		space,		/*!< in: space id */
+	ulint		offset,		/*!< in: offset of the page
+					within space */
+	ulint		fold);		/*!< in: buf_page_address_fold(
+					space, offset) */
 /******************************************************************//**
 Returns the control block of a file page, NULL if not found.
 @return	block, NULL if not found or not a real control block */
@@ -1008,8 +1086,10 @@ UNIV_INLINE
 buf_page_t*
 buf_page_hash_get(
 /*==============*/
-	ulint	space,	/*!< in: space id */
-	ulint	offset);/*!< in: offset of the page within space */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		space,		/*!< in: space id */
+	ulint		offset);	/*!< in: offset of the page
+					within space */
 /******************************************************************//**
 Returns the control block of a file page, NULL if not found
 or an uncompressed page frame does not exist.
@@ -1018,8 +1098,10 @@ UNIV_INLINE
 buf_block_t*
 buf_block_hash_get(
 /*===============*/
-	ulint	space,	/*!< in: space id */
-	ulint	offset);/*!< in: offset of the page within space */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		space,		/*!< in: space id */
+	ulint		offset);	/*!< in: offset of the page
+					within space */
 /*********************************************************************//**
 Gets the current length of the free list of buffer blocks.
 @return	length of the free list */
@@ -1033,9 +1115,10 @@ Determine if a block is a sentinel for a buffer pool watch.
 @return	TRUE if a sentinel for a buffer pool watch, FALSE if not */
 UNIV_INTERN
 ibool
-buf_pool_watch_is(
-/*==============*/
-	const buf_page_t*	bpage)	/*!< in: block */
+buf_pool_watch_is_sentinel(
+/*=======================*/
+	buf_pool_t*		buf_pool,	/*!< buffer pool instance */
+	const buf_page_t*	bpage)		/*!< in: block */
 	__attribute__((nonnull, warn_unused_result));
 /****************************************************************//**
 Add watch for the given page to be read in. Caller must have the buffer pool
@@ -1069,6 +1152,23 @@ buf_pool_watch_occurred(
 	ulint	space,	/*!< in: space id */
 	ulint	offset)	/*!< in: page number */
 	__attribute__((warn_unused_result));
+/********************************************************************//**
+Get total buffer pool statistics. */
+UNIV_INTERN
+void
+buf_get_total_list_len(
+/*===================*/
+	ulint*		LRU_len,	/*!< out: length of all LRU lists */
+	ulint*		free_len,	/*!< out: length of all free lists */
+	ulint*		flush_list_len);/*!< out: length of all flush lists */
+/********************************************************************//**
+Get total buffer pool statistics. */
+UNIV_INTERN
+void
+buf_get_total_stat(
+/*===============*/
+	buf_pool_stat_t*tot_stat);	/*!< out: buffer pool stats */
+
 #endif /* !UNIV_HOTBACKUP */
 
 /** The common buffer control block structure
@@ -1078,18 +1178,18 @@ struct buf_page_struct{
 	/** @name General fields
 	None of these bit-fields must be modified without holding
 	buf_page_get_mutex() [buf_block_struct::mutex or
-	buf_pool_zip_mutex], since they can be stored in the same
+	buf_pool->zip_mutex], since they can be stored in the same
 	machine word.  Some of these fields are additionally protected
-	by buf_pool_mutex. */
+	by buf_pool->mutex. */
 	/* @{ */
 
 	unsigned	space:32;	/*!< tablespace id; also protected
-					by buf_pool_mutex. */
+					by buf_pool->mutex. */
 	unsigned	offset:32;	/*!< page number; also protected
-					by buf_pool_mutex. */
+					by buf_pool->mutex. */
 
 	unsigned	state:3;	/*!< state of the control block; also
-					protected by buf_pool_mutex.
+					protected by buf_pool->mutex.
 					State transitions from
 					BUF_BLOCK_READY_FOR_USE to
 					BUF_BLOCK_MEMORY need not be
@@ -1101,7 +1201,7 @@ struct buf_page_struct{
 					flush_type.
 					@see enum buf_flush */
 	unsigned	io_fix:2;	/*!< type of pending I/O operation;
-					also protected by buf_pool_mutex
+					also protected by buf_pool->mutex
 					@see enum buf_io_fix */
 	unsigned	buf_fix_count:25;/*!< count of how manyfold this block
 					is currently bufferfixed */
@@ -1190,8 +1290,8 @@ struct buf_page_struct{
 					any one of the two mutexes */
 	/* @} */
 	/** @name LRU replacement algorithm fields
-	These fields are protected by buf_pool_mutex only (not
-	buf_pool_zip_mutex or buf_block_struct::mutex). */
+	These fields are protected by buf_pool->mutex only (not
+	buf_pool->zip_mutex or buf_block_struct::mutex). */
 	/* @{ */
 
 	UT_LIST_NODE_T(buf_page_t) LRU;
@@ -1221,6 +1321,8 @@ struct buf_page_struct{
 					frees a page in buffer pool */
 # endif /* UNIV_DEBUG_FILE_ACCESSES */
 #endif /* !UNIV_HOTBACKUP */
+	buf_pool_t*	buf_pool;	/*!< buffer pool instance this
+					page belongs to */
 };
 
 /** The buffer control block structure */
@@ -1260,7 +1362,7 @@ struct buf_block_struct{
 	unsigned	lock_hash_val:32;/*!< hashed value of the page address
 					in the record lock hash table;
 					protected by buf_block_t::lock
-					(or buf_block_t::mutex, buf_pool_mutex
+					(or buf_block_t::mutex, buf_pool->mutex
 				        in buf_page_get_gen(),
 					buf_page_init_for_read()
 					and buf_page_create()) */
@@ -1389,6 +1491,16 @@ struct buf_pool_stat_struct{
 				buf_page_peek_if_too_old() */
 };
 
+/** Statistics of buddy blocks of a given size. */
+struct buf_buddy_stat_struct {
+	/** Number of blocks allocated from the buddy system. */
+	ulint		used;
+	/** Number of blocks relocated by the buddy system. */
+	ib_uint64_t	relocated;
+	/** Total duration of block relocations, in microseconds. */
+	ib_uint64_t	relocated_usec;
+};
+
 /** @brief The buffer pool structure.
 
 NOTE! The definition appears here only for other modules of this
@@ -1398,7 +1510,25 @@ struct buf_pool_struct{
 
 	/** @name General fields */
 	/* @{ */
-
+	mutex_t		mutex;		/*!< Buffer pool mutex of this
+					instance */
+	mutex_t		zip_mutex;	/*!< Zip mutex of this buffer
+					pool instance, protects compressed
+					only pages (of type buf_page_t, not
+					buf_block_t */
+	ulint		instance_no;	/*!< Array index of this buffer
+					pool instance */
+	ulint		old_pool_size;  /*!< Old pool size in bytes */
+	ulint		curr_pool_size;	/*!< Current pool size in bytes */
+	ulint		LRU_old_ratio;  /*!< Reserve this much of the buffer
+					pool for "old" blocks */
+#ifdef UNIV_DEBUG
+	ulint		buddy_n_frames; /*!< Number of frames allocated from
+					the buffer pool to the buddy system */
+#endif
+#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
+	ulint		mutex_exit_forbidden; /*!< Forbid release mutex */
+#endif
 	ulint		n_chunks;	/*!< number of buffer pool chunks */
 	buf_chunk_t*	chunks;		/*!< buffer pool chunks */
 	ulint		curr_size;	/*!< current pool size in pages */
@@ -1410,12 +1540,16 @@ struct buf_pool_struct{
 					whose frames are allocated to the
 					zip buddy system,
 					indexed by block->frame */
-	ulint		n_pend_reads;	/*!< number of pending read operations */
+	ulint		n_pend_reads;	/*!< number of pending read
+					operations */
 	ulint		n_pend_unzip;	/*!< number of pending decompressions */
 
 	time_t		last_printout_time;
 					/*!< when buf_print_io was last time
 					called */
+	buf_buddy_stat_t buddy_stat[BUF_BUDDY_SIZES + 1];
+					/*!< Statistics of buddy system,
+					indexed by block size */
 	buf_pool_stat_t	stat;		/*!< current statistics */
 	buf_pool_stat_t	old_stat;	/*!< old statistics */
 
@@ -1432,14 +1566,6 @@ struct buf_pool_struct{
 					the bpage is on flush_list. It
 					also protects writes to
 					bpage::oldest_modification */
-	mutex_t		flush_order_mutex;/*!< mutex to serialize access to
-					the flush list when we are putting
-					dirty blocks in the list. The idea
-					behind this mutex is to be able
-					to release log_sys->mutex during
-					mtr_commit and still ensure that
-					insertions in the flush_list happen
-					in the LSN order. */
 	UT_LIST_BASE_NODE_T(buf_page_t) flush_list;
 					/*!< base node of the modified block
 					list */
@@ -1519,6 +1645,12 @@ struct buf_pool_struct{
 					/*!< unmodified compressed pages */
 	UT_LIST_BASE_NODE_T(buf_page_t) zip_free[BUF_BUDDY_SIZES];
 					/*!< buddy free lists */
+
+	buf_page_t			watch[BUF_POOL_WATCH_SIZE];
+					/*!< Sentinel records for buffer
+					pool watches. Protected by
+				       	buf_pool->mutex. */
+
 #if BUF_BUDDY_HIGH != UNIV_PAGE_SIZE
 # error "BUF_BUDDY_HIGH != UNIV_PAGE_SIZE"
 #endif
@@ -1540,65 +1672,51 @@ Use these instead of accessing buf_pool_mutex directly. */
 /* @{ */
 
 /** Test if buf_pool_mutex is owned. */
-#define buf_pool_mutex_own() mutex_own(&buf_pool_mutex)
+#define buf_pool_mutex_own(b) mutex_own(&b->mutex)
 /** Acquire the buffer pool mutex. */
-#define buf_pool_mutex_enter() do {		\
-	ut_ad(!mutex_own(&buf_pool_zip_mutex));	\
-	mutex_enter(&buf_pool_mutex);		\
+#define buf_pool_mutex_enter(b) do {		\
+	ut_ad(!mutex_own(&b->zip_mutex));	\
+	mutex_enter(&b->mutex);		\
 } while (0)
 
 /** Test if flush list mutex is owned. */
-#define buf_flush_list_mutex_own() mutex_own(&buf_pool->flush_list_mutex)
+#define buf_flush_list_mutex_own(b) mutex_own(&b->flush_list_mutex)
 
 /** Acquire the flush list mutex. */
-#define buf_flush_list_mutex_enter() do {	\
-	mutex_enter(&buf_pool->flush_list_mutex);	\
+#define buf_flush_list_mutex_enter(b) do {	\
+	mutex_enter(&b->flush_list_mutex);	\
 } while (0)
 /** Release the flush list mutex. */
-# define buf_flush_list_mutex_exit() do {	\
-	mutex_exit(&buf_pool->flush_list_mutex);	\
+# define buf_flush_list_mutex_exit(b) do {	\
+	mutex_exit(&b->flush_list_mutex);	\
 } while (0)
 
-/** Test if flush order mutex is owned. */
-#define buf_flush_order_mutex_own() mutex_own(&buf_pool->flush_order_mutex)
-
-/** Acquire the flush order mutex. */
-#define buf_flush_order_mutex_enter() do {	\
-	mutex_enter(&buf_pool->flush_order_mutex);	\
-} while (0)
-/** Release the flush order mutex. */
-# define buf_flush_order_mutex_exit() do {	\
-	mutex_exit(&buf_pool->flush_order_mutex);	\
-} while (0)
 
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
-/** Flag to forbid the release of the buffer pool mutex.
-Protected by buf_pool_mutex. */
-extern ulint	buf_pool_mutex_exit_forbidden;
 /** Forbid the release of the buffer pool mutex. */
-# define buf_pool_mutex_exit_forbid() do {	\
-	ut_ad(buf_pool_mutex_own());		\
-	buf_pool_mutex_exit_forbidden++;	\
+# define buf_pool_mutex_exit_forbid(b) do {	\
+	ut_ad(buf_pool_mutex_own(b));		\
+	b->mutex_exit_forbidden++;		\
 } while (0)
 /** Allow the release of the buffer pool mutex. */
-# define buf_pool_mutex_exit_allow() do {	\
-	ut_ad(buf_pool_mutex_own());		\
-	ut_a(buf_pool_mutex_exit_forbidden);	\
-	buf_pool_mutex_exit_forbidden--;	\
+# define buf_pool_mutex_exit_allow(b) do {	\
+	ut_ad(buf_pool_mutex_own(b));		\
+	ut_a(b->mutex_exit_forbidden);	\
+	b->mutex_exit_forbidden--;		\
 } while (0)
 /** Release the buffer pool mutex. */
-# define buf_pool_mutex_exit() do {		\
-	ut_a(!buf_pool_mutex_exit_forbidden);	\
-	mutex_exit(&buf_pool_mutex);		\
+# define buf_pool_mutex_exit(b) do {		\
+	ut_a(!b->mutex_exit_forbidden);		\
+	mutex_exit(&b->mutex);			\
 } while (0)
 #else
 /** Forbid the release of the buffer pool mutex. */
-# define buf_pool_mutex_exit_forbid() ((void) 0)
+# define buf_pool_mutex_exit_forbid(b) ((void) 0)
 /** Allow the release of the buffer pool mutex. */
-# define buf_pool_mutex_exit_allow() ((void) 0)
+# define buf_pool_mutex_exit_allow(b) ((void) 0)
 /** Release the buffer pool mutex. */
-# define buf_pool_mutex_exit() mutex_exit(&buf_pool_mutex)
+# define buf_pool_mutex_exit(b) mutex_exit(&b->mutex)
 #endif
 #endif /* !UNIV_HOTBACKUP */
 /* @} */
diff --git a/storage/innobase/include/buf0buf.ic b/storage/innobase/include/buf0buf.ic
index b9a9662fdc5..c30be5b2635 100644
--- a/storage/innobase/include/buf0buf.ic
+++ b/storage/innobase/include/buf0buf.ic
@@ -31,11 +31,32 @@ Created 11/5/1995 Heikki Tuuri
 *******************************************************/
 
 #include "mtr0mtr.h"
-#ifndef UNIV_HOTBACKUP
 #include "buf0flu.h"
 #include "buf0lru.h"
 #include "buf0rea.h"
 
+/*********************************************************************//**
+Gets the current size of buffer buf_pool in bytes.
+@return size in bytes */
+UNIV_INLINE
+ulint
+buf_pool_get_curr_size(void)
+/*========================*/
+{
+	return(srv_buf_pool_curr_size);
+}
+
+/*********************************************************************//**
+Gets the current size of buffer buf_pool in pages.
+@return size in pages*/
+UNIV_INLINE
+ulint
+buf_pool_get_n_pages(void)
+/*======================*/
+{
+	return(buf_pool_get_curr_size() / UNIV_PAGE_SIZE);
+}
+
 /********************************************************************//**
 Reads the freed_page_clock of a buffer block.
 @return	freed_page_clock */
@@ -45,7 +66,7 @@ buf_page_get_freed_page_clock(
 /*==========================*/
 	const buf_page_t*	bpage)	/*!< in: block */
 {
-	/* This is sometimes read without holding buf_pool_mutex. */
+	/* This is sometimes read without holding buf_pool->mutex. */
 	return(bpage->freed_page_clock);
 }
 
@@ -72,6 +93,8 @@ buf_page_peek_if_too_old(
 /*=====================*/
 	const buf_page_t*	bpage)	/*!< in: block to make younger */
 {
+	buf_pool_t*		buf_pool = buf_pool_from_bpage(bpage);
+
 	if (UNIV_UNLIKELY(buf_pool->freed_page_clock == 0)) {
 		/* If eviction has not started yet, do not update the
 		statistics or move blocks in the LRU list.  This is
@@ -93,55 +116,12 @@ buf_page_peek_if_too_old(
 		return((buf_pool->freed_page_clock & ((1UL << 31) - 1))
 		       > ((ulint) bpage->freed_page_clock
 			  + (buf_pool->curr_size
-			     * (BUF_LRU_OLD_RATIO_DIV - buf_LRU_old_ratio)
+			     * (BUF_LRU_OLD_RATIO_DIV - buf_pool->LRU_old_ratio)
 			     / (BUF_LRU_OLD_RATIO_DIV * 4))));
 	}
 }
 
 /*********************************************************************//**
-Gets the current size of buffer buf_pool in bytes.
-@return	size in bytes */
-UNIV_INLINE
-ulint
-buf_pool_get_curr_size(void)
-/*========================*/
-{
-	return(buf_pool->curr_size * UNIV_PAGE_SIZE);
-}
-
-/********************************************************************//**
-Gets the smallest oldest_modification lsn for any page in the pool. Returns
-zero if all modified pages have been flushed to disk.
-@return	oldest modification in pool, zero if none */
-UNIV_INLINE
-ib_uint64_t
-buf_pool_get_oldest_modification(void)
-/*==================================*/
-{
-	buf_page_t*	bpage;
-	ib_uint64_t	lsn;
-
-	buf_flush_list_mutex_enter();
-
-	bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
-
-	if (bpage == NULL) {
-		lsn = 0;
-	} else {
-		ut_ad(bpage->in_flush_list);
-		lsn = bpage->oldest_modification;
-	}
-
-	buf_flush_list_mutex_exit();
-
-	/* The returned answer may be out of date: the flush_list can
-	change after the mutex has been released. */
-
-	return(lsn);
-}
-#endif /* !UNIV_HOTBACKUP */
-
-/*********************************************************************//**
 Gets the state of a block.
 @return	state */
 UNIV_INLINE
@@ -293,13 +273,15 @@ buf_page_get_mutex(
 /*===============*/
 	const buf_page_t*	bpage)	/*!< in: pointer to control block */
 {
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+
 	switch (buf_page_get_state(bpage)) {
 	case BUF_BLOCK_ZIP_FREE:
 		ut_error;
 		return(NULL);
 	case BUF_BLOCK_ZIP_PAGE:
 	case BUF_BLOCK_ZIP_DIRTY:
-		return(&buf_pool_zip_mutex);
+		return(&buf_pool->zip_mutex);
 	default:
 		return(&((buf_block_t*) bpage)->mutex);
 	}
@@ -385,7 +367,7 @@ Gets the io_fix state of a block.
 UNIV_INLINE
 enum buf_io_fix
 buf_block_get_io_fix(
-/*================*/
+/*=================*/
 	const buf_block_t*	block)	/*!< in: pointer to the control block */
 {
 	return(buf_page_get_io_fix(&block->page));
@@ -400,7 +382,10 @@ buf_page_set_io_fix(
 	buf_page_t*	bpage,	/*!< in/out: control block */
 	enum buf_io_fix	io_fix)	/*!< in: io_fix state */
 {
-	ut_ad(buf_pool_mutex_own());
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+	ut_ad(buf_pool_mutex_own(buf_pool));
+#endif
 	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 
 	bpage->io_fix = io_fix;
@@ -428,7 +413,10 @@ buf_page_can_relocate(
 /*==================*/
 	const buf_page_t*	bpage)	/*!< control block being relocated */
 {
-	ut_ad(buf_pool_mutex_own());
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+	ut_ad(buf_pool_mutex_own(buf_pool));
+#endif
 	ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 	ut_ad(buf_page_in_file(bpage));
 	ut_ad(bpage->in_LRU_list);
@@ -446,8 +434,11 @@ buf_page_is_old(
 /*============*/
 	const buf_page_t*	bpage)	/*!< in: control block */
 {
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+	ut_ad(buf_pool_mutex_own(buf_pool));
+#endif
 	ut_ad(buf_page_in_file(bpage));
-	ut_ad(buf_pool_mutex_own());
 
 	return(bpage->old);
 }
@@ -461,8 +452,11 @@ buf_page_set_old(
 	buf_page_t*	bpage,	/*!< in/out: control block */
 	ibool		old)	/*!< in: old */
 {
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+#endif /* UNIV_DEBUG */
 	ut_a(buf_page_in_file(bpage));
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(bpage->in_LRU_list);
 
 #ifdef UNIV_LRU_DEBUG
@@ -508,8 +502,11 @@ buf_page_set_accessed(
 	buf_page_t*	bpage,		/*!< in/out: control block */
 	ulint		time_ms)	/*!< in: ut_time_ms() */
 {
+#ifdef UNIV_DEBUG
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
+	ut_ad(buf_pool_mutex_own(buf_pool));
+#endif
 	ut_a(buf_page_in_file(bpage));
-	ut_ad(buf_pool_mutex_own());
 
 	if (!bpage->access_time) {
 		/* Make this the time of the first access. */
@@ -715,25 +712,6 @@ buf_block_get_lock_hash_val(
 }
 
 /********************************************************************//**
-Allocates a buffer block.
-@return	own: the allocated block, in state BUF_BLOCK_MEMORY */
-UNIV_INLINE
-buf_block_t*
-buf_block_alloc(
-/*============*/
-	ulint	zip_size)	/*!< in: compressed page size in bytes,
-				or 0 if uncompressed tablespace */
-{
-	buf_block_t*	block;
-
-	block = buf_LRU_get_free_block(zip_size);
-
-	buf_block_set_state(block, BUF_BLOCK_MEMORY);
-
-	return(block);
-}
-
-/********************************************************************//**
 Frees a buffer block which does not contain a file page. */
 UNIV_INLINE
 void
@@ -741,7 +719,9 @@ buf_block_free(
 /*===========*/
 	buf_block_t*	block)	/*!< in, own: block to be freed */
 {
-	buf_pool_mutex_enter();
+	buf_pool_t*	buf_pool = buf_pool_from_bpage((buf_page_t*)block);
+
+	buf_pool_mutex_enter(buf_pool);
 
 	mutex_enter(&block->mutex);
 
@@ -751,7 +731,7 @@ buf_block_free(
 
 	mutex_exit(&block->mutex);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 }
 #endif /* !UNIV_HOTBACKUP */
 
@@ -825,7 +805,9 @@ buf_block_modify_clock_inc(
 	buf_block_t*	block)	/*!< in: block */
 {
 #ifdef UNIV_SYNC_DEBUG
-	ut_ad((buf_pool_mutex_own()
+	buf_pool_t*	buf_pool = buf_pool_from_bpage((buf_page_t*)block);
+
+	ut_ad((buf_pool_mutex_own(buf_pool)
 	       && (block->page.buf_fix_count == 0))
 	      || rw_lock_own(&(block->lock), RW_LOCK_EXCLUSIVE));
 #endif /* UNIV_SYNC_DEBUG */
@@ -904,20 +886,83 @@ buf_block_buf_fix_dec(
 }
 
 /******************************************************************//**
+Returns the buffer pool instance given a page instance
+@return buf_pool */
+UNIV_INLINE
+buf_pool_t*
+buf_pool_from_bpage(
+/*================*/
+	const buf_page_t*	bpage) /*!< in: buffer pool page */
+{
+	/* Every page must be in some buffer pool. */
+	ut_ad(bpage->buf_pool != NULL);
+
+	return(bpage->buf_pool);
+}
+
+/******************************************************************//**
+Returns the buffer pool instance given a block instance
+@return buf_pool */
+UNIV_INLINE
+buf_pool_t*
+buf_pool_from_block(
+/*================*/
+	const buf_block_t*	block) /*!< in: block */
+{
+	return(buf_pool_from_bpage(&block->page));
+}
+
+/******************************************************************//**
+Returns the buffer pool instance given space and offset of page
+@return buffer pool */
+UNIV_INLINE
+buf_pool_t*
+buf_pool_get(
+/*==========*/
+	ulint	space,	/*!< in: space id */
+	ulint	offset)	/*!< in: offset of the page within space */
+{
+	ulint	fold;
+	ulint	index;
+	ulint	ignored_offset;
+
+	ignored_offset = offset >> 6; /* 2log of BUF_READ_AHEAD_AREA (64)*/
+	fold = buf_page_address_fold(space, ignored_offset);
+	index = fold % srv_buf_pool_instances;
+	return buf_pool_ptr[index];
+}
+
+/******************************************************************//**
+Returns the buffer pool instance given its array index
+@return buffer pool */
+UNIV_INLINE
+buf_pool_t*
+buf_pool_from_array(
+/*================*/
+	ulint	index) 		/*!< in: array index to get
+				buffer pool instance from */
+{
+	return buf_pool_ptr[index];
+}
+
+/******************************************************************//**
 Returns the control block of a file page, NULL if not found.
 @return	block, NULL if not found */
 UNIV_INLINE
 buf_page_t*
 buf_page_hash_get_low(
 /*==================*/
-	ulint	space,	/*!< in: space id */
-	ulint	offset,	/*!< in: offset of the page within space */
-	ulint	fold)	/*!< in: buf_page_address_fold(space, offset) */
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	ulint		space,		/*!< in: space id */
+	ulint		offset,		/*!< in: offset of the page
+					within space */
+	ulint		fold)		/*!< in: buf_page_address_fold(
+					space, offset) */
 {
 	buf_page_t*	bpage;
 
 	ut_ad(buf_pool);
-	ut_ad(buf_pool_mutex_own());
+	ut_ad(buf_pool_mutex_own(buf_pool));
 	ut_ad(fold == buf_page_address_fold(space, offset));
 
 	/* Look for the page in the hash table */
@@ -943,13 +988,17 @@ UNIV_INLINE
 buf_page_t*
 buf_page_hash_get(
 /*==============*/
-	ulint	space,	/*!< in: space id */
-	ulint	offset)	/*!< in: offset of the page within space */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		space,		/*!< in: space id */
+	ulint		offset)		/*!< in: offset of the page
+					within space */
 {
+	buf_page_t*	bpage;
 	ulint		fold	= buf_page_address_fold(space, offset);
-	buf_page_t*	bpage	= buf_page_hash_get_low(space, offset, fold);
 
-	if (bpage && UNIV_UNLIKELY(buf_pool_watch_is(bpage))) {
+	bpage	= buf_page_hash_get_low(buf_pool, space, offset, fold);
+
+	if (bpage && buf_pool_watch_is_sentinel(buf_pool, bpage)) {
 		bpage = NULL;
 	}
 
@@ -964,12 +1013,14 @@ UNIV_INLINE
 buf_block_t*
 buf_block_hash_get(
 /*===============*/
-	ulint	space,	/*!< in: space id */
-	ulint	offset)	/*!< in: offset of the page within space */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		space,		/*!< in: space id */
+	ulint		offset)		/*!< in: offset of the page
+					within space */
 {
 	buf_block_t*	block;
 
-	block = buf_page_get_block(buf_page_hash_get(space, offset));
+	block = buf_page_get_block(buf_page_hash_get(buf_pool, space, offset));
 
 	return(block);
 }
@@ -989,12 +1040,13 @@ buf_page_peek(
 	ulint	offset)	/*!< in: page number */
 {
 	const buf_page_t*	bpage;
+	buf_pool_t*		buf_pool = buf_pool_get(space, offset);
 
-	buf_pool_mutex_enter();
+	buf_pool_mutex_enter(buf_pool);
 
-	bpage = buf_page_hash_get(space, offset);
+	bpage = buf_page_hash_get(buf_pool, space, offset);
 
-	buf_pool_mutex_exit();
+	buf_pool_mutex_exit(buf_pool);
 
 	return(bpage != NULL);
 }
@@ -1008,6 +1060,7 @@ buf_page_release_zip(
 	buf_page_t*	bpage)		/*!< in: buffer block */
 {
 	buf_block_t*	block;
+	buf_pool_t*	buf_pool = buf_pool_from_bpage(bpage);
 
 	ut_ad(bpage);
 	ut_a(bpage->buf_fix_count > 0);
@@ -1015,9 +1068,9 @@ buf_page_release_zip(
 	switch (buf_page_get_state(bpage)) {
 	case BUF_BLOCK_ZIP_PAGE:
 	case BUF_BLOCK_ZIP_DIRTY:
-		mutex_enter(&buf_pool_zip_mutex);
+		mutex_enter(&buf_pool->zip_mutex);
 		bpage->buf_fix_count--;
-		mutex_exit(&buf_pool_zip_mutex);
+		mutex_exit(&buf_pool->zip_mutex);
 		return;
 	case BUF_BLOCK_FILE_PAGE:
 		block = (buf_block_t*) bpage;
@@ -1036,6 +1089,7 @@ buf_page_release_zip(
 		break;
 	}
 
+	
 	ut_error;
 }
 
@@ -1087,4 +1141,37 @@ buf_block_dbg_add_level(
 	sync_thread_add_level(&block->lock, level);
 }
 #endif /* UNIV_SYNC_DEBUG */
+/********************************************************************//**
+Acquire mutex on all buffer pool instances. */
+UNIV_INLINE
+void
+buf_pool_mutex_enter_all(void)
+/*==========================*/
+{
+	ulint   i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+		buf_pool_mutex_enter(buf_pool);
+	}
+}
+
+/********************************************************************//**
+Release mutex on all buffer pool instances. */
+UNIV_INLINE
+void
+buf_pool_mutex_exit_all(void)
+/*=========================*/
+{
+	ulint   i;
+
+	for (i = 0; i < srv_buf_pool_instances; i++) {
+		buf_pool_t*	buf_pool;
+
+		buf_pool = buf_pool_from_array(i);
+		buf_pool_mutex_exit(buf_pool);
+	}
+}
 #endif /* !UNIV_HOTBACKUP */
diff --git a/storage/innobase/include/buf0flu.h b/storage/innobase/include/buf0flu.h
index c76fcace46e..55814b6bf86 100644
--- a/storage/innobase/include/buf0flu.h
+++ b/storage/innobase/include/buf0flu.h
@@ -31,6 +31,7 @@ Created 11/5/1995 Heikki Tuuri
 #ifndef UNIV_HOTBACKUP
 #include "mtr0types.h"
 #include "buf0types.h"
+#include "log0log.h"
 
 /********************************************************************//**
 Remove a block from the flush list of modified blocks. */
@@ -58,11 +59,19 @@ buf_flush_write_complete(
 	buf_page_t*	bpage);	/*!< in: pointer to the block in question */
 /*********************************************************************//**
 Flushes pages from the end of the LRU list if there is too small
-a margin of replaceable pages there. */
+a margin of replaceable pages there. If buffer pool is NULL it
+means flush free margin on all buffer pool instances. */
 UNIV_INTERN
 void
-buf_flush_free_margin(void);
-/*=======================*/
+buf_flush_free_margin(
+/*==================*/
+	 buf_pool_t*	buf_pool);
+/*********************************************************************//**
+Flushes pages from the end of all the LRU lists. */
+UNIV_INTERN
+void
+buf_flush_free_margins(void);
+/*=========================*/
 #endif /* !UNIV_HOTBACKUP */
 /********************************************************************//**
 Initializes a page for writing to the tablespace. */
@@ -76,21 +85,30 @@ buf_flush_init_for_writing(
 					to the page */
 #ifndef UNIV_HOTBACKUP
 /*******************************************************************//**
-This utility flushes dirty blocks from the end of the LRU list or flush_list.
-NOTE 1: in the case of an LRU flush the calling thread may own latches to
-pages: to avoid deadlocks, this function must be written so that it cannot
-end up waiting for these latches! NOTE 2: in the case of a flush list flush,
-the calling thread is not allowed to own any latches on pages!
+This utility flushes dirty blocks from the end of the LRU list.
+NOTE: The calling thread may own latches to pages: to avoid deadlocks,
+this function must be written so that it cannot end up waiting for these
+latches!
+@return number of blocks for which the write request was queued;
+ULINT_UNDEFINED if there was a flush of the same type already running */
+UNIV_INTERN
+ulint
+buf_flush_LRU(
+/*==========*/
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		min_n);		/*!< in: wished minimum mumber of blocks
+					flushed (it is not guaranteed that the
+					actual number is that big, though) */
+/*******************************************************************//**
+This utility flushes dirty blocks from the end of the flush_list of
+all buffer pool instances.
+NOTE: The calling thread is not allowed to own any latches on pages!
 @return number of blocks for which the write request was queued;
 ULINT_UNDEFINED if there was a flush of the same type already running */
 UNIV_INTERN
 ulint
-buf_flush_batch(
+buf_flush_list(
 /*============*/
-	enum buf_flush	flush_type,	/*!< in: BUF_FLUSH_LRU or
-					BUF_FLUSH_LIST; if BUF_FLUSH_LIST,
-					then the caller must not own any
-					latches on pages */
 	ulint		min_n,		/*!< in: wished minimum mumber of blocks
 					flushed (it is not guaranteed that the
 					actual number is that big, though) */
@@ -105,7 +123,9 @@ UNIV_INTERN
 void
 buf_flush_wait_batch_end(
 /*=====================*/
-	enum buf_flush	type);	/*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	enum buf_flush	type);		/*!< in: BUF_FLUSH_LRU
+					or BUF_FLUSH_LIST */
 /********************************************************************//**
 This function should be called at a mini-transaction commit, if a page was
 modified in it. Puts the block to the list of modified blocks, if it not
@@ -181,8 +201,9 @@ Validates the flush list.
 @return	TRUE if ok */
 UNIV_INTERN
 ibool
-buf_flush_validate(void);
-/*====================*/
+buf_flush_validate(
+/*===============*/
+	buf_pool_t*	buf_pool);
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
 /********************************************************************//**
@@ -205,9 +226,10 @@ buf_flush_free_flush_rbt(void);
 available to replacement in the free list and at the end of the LRU list (to
 make sure that a read-ahead batch can be read efficiently in a single
 sweep). */
-#define BUF_FLUSH_FREE_BLOCK_MARGIN	(5 + BUF_READ_AHEAD_AREA)
+#define BUF_FLUSH_FREE_BLOCK_MARGIN(b)	(5 + BUF_READ_AHEAD_AREA(b))
 /** Extra margin to apply above BUF_FLUSH_FREE_BLOCK_MARGIN */
-#define BUF_FLUSH_EXTRA_MARGIN		(BUF_FLUSH_FREE_BLOCK_MARGIN / 4 + 100)
+#define BUF_FLUSH_EXTRA_MARGIN(b)	(BUF_FLUSH_FREE_BLOCK_MARGIN(b) / 4 \
+					+ 100)
 #endif /* !UNIV_HOTBACKUP */
 
 #ifndef UNIV_NONINL
diff --git a/storage/innobase/include/buf0flu.ic b/storage/innobase/include/buf0flu.ic
index fb71932e453..30e2cc8efe8 100644
--- a/storage/innobase/include/buf0flu.ic
+++ b/storage/innobase/include/buf0flu.ic
@@ -33,8 +33,9 @@ UNIV_INTERN
 void
 buf_flush_insert_into_flush_list(
 /*=============================*/
-	buf_block_t*	block,	/*!< in/out: block which is modified */
-	ib_uint64_t	lsn);	/*!< in: oldest modification */
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	buf_block_t*	block,		/*!< in/out: block which is modified */
+	ib_uint64_t	lsn);		/*!< in: oldest modification */
 /********************************************************************//**
 Inserts a modified block into the flush list in the right sorted position.
 This function is used by recovery, because there the modifications do not
@@ -43,8 +44,9 @@ UNIV_INTERN
 void
 buf_flush_insert_sorted_into_flush_list(
 /*====================================*/
-	buf_block_t*	block,	/*!< in/out: block which is modified */
-	ib_uint64_t	lsn);	/*!< in: oldest modification */
+	buf_pool_t*	buf_pool,	/*!< buffer pool instance */
+	buf_block_t*	block,		/*!< in/out: block which is modified */
+	ib_uint64_t	lsn);		/*!< in: oldest modification */
 
 /********************************************************************//**
 This function should be called at a mini-transaction commit, if a page was
@@ -57,6 +59,8 @@ buf_flush_note_modification(
 	buf_block_t*	block,	/*!< in: block which is modified */
 	mtr_t*		mtr)	/*!< in: mtr */
 {
+	buf_pool_t*	buf_pool = buf_pool_from_block(block);
+
 	ut_ad(block);
 	ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 	ut_ad(block->page.buf_fix_count > 0);
@@ -64,9 +68,9 @@ buf_flush_note_modification(
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	ut_ad(!buf_pool_mutex_own());
-	ut_ad(!buf_flush_list_mutex_own());
-	ut_ad(buf_flush_order_mutex_own());
+	ut_ad(!buf_pool_mutex_own(buf_pool));
+	ut_ad(!buf_flush_list_mutex_own(buf_pool));
+	ut_ad(log_flush_order_mutex_own());
 
 	ut_ad(mtr->start_lsn != 0);
 	ut_ad(mtr->modifications);
@@ -77,7 +81,8 @@ buf_flush_note_modification(
 	block->page.newest_modification = mtr->end_lsn;
 
 	if (!block->page.oldest_modification) {
-		buf_flush_insert_into_flush_list(block, mtr->start_lsn);
+		buf_flush_insert_into_flush_list(
+			buf_pool, block, mtr->start_lsn);
 	} else {
 		ut_ad(block->page.oldest_modification <= mtr->start_lsn);
 	}
@@ -99,6 +104,8 @@ buf_flush_recv_note_modification(
 	ib_uint64_t	end_lsn)	/*!< in: end lsn of the last mtr in the
 					set of mtr's */
 {
+	buf_pool_t*	buf_pool = buf_pool_from_block(block);
+
 	ut_ad(block);
 	ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 	ut_ad(block->page.buf_fix_count > 0);
@@ -106,9 +113,9 @@ buf_flush_recv_note_modification(
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	ut_ad(!buf_pool_mutex_own());
-	ut_ad(!buf_flush_list_mutex_own());
-	ut_ad(buf_flush_order_mutex_own());
+	ut_ad(!buf_pool_mutex_own(buf_pool));
+	ut_ad(!buf_flush_list_mutex_own(buf_pool));
+	ut_ad(log_flush_order_mutex_own());
 
 	ut_ad(start_lsn != 0);
 	ut_ad(block->page.newest_modification <= end_lsn);
@@ -117,7 +124,8 @@ buf_flush_recv_note_modification(
 	block->page.newest_modification = end_lsn;
 
 	if (!block->page.oldest_modification) {
-		buf_flush_insert_sorted_into_flush_list(block, start_lsn);
+		buf_flush_insert_sorted_into_flush_list(
+			buf_pool, block, start_lsn);
 	} else {
 		ut_ad(block->page.oldest_modification <= start_lsn);
 	}
diff --git a/storage/innobase/include/buf0lru.h b/storage/innobase/include/buf0lru.h
index 009430af35b..4fda88ef90c 100644
--- a/storage/innobase/include/buf0lru.h
+++ b/storage/innobase/include/buf0lru.h
@@ -52,8 +52,9 @@ operations need new buffer blocks, and the i/o work done in flushing would be
 wasted. */
 UNIV_INTERN
 void
-buf_LRU_try_free_flushed_blocks(void);
-/*==================================*/
+buf_LRU_try_free_flushed_blocks(
+/*============================*/
+	buf_pool_t*	buf_pool);	/*!< in: buffer pool instance */
 /******************************************************************//**
 Returns TRUE if less than 25 % of the buffer pool is available. This can be
 used in heuristics to prevent huge transactions eating up the whole buffer
@@ -72,7 +73,7 @@ These are low-level functions
 #define BUF_LRU_OLD_MIN_LEN	512	/* 8 megabytes of 16k pages */
 
 /** Maximum LRU list search length in buf_flush_LRU_recommendation() */
-#define BUF_LRU_FREE_SEARCH_LEN		(5 + 2 * BUF_READ_AHEAD_AREA)
+#define BUF_LRU_FREE_SEARCH_LEN(b)	(5 + 2 * BUF_READ_AHEAD_AREA(b))
 
 /******************************************************************//**
 Invalidates all pages belonging to a given tablespace when we are deleting
@@ -97,10 +98,10 @@ Try to free a block.  If bpage is a descriptor of a compressed-only
 page, the descriptor object will be freed as well.
 
 NOTE: If this function returns BUF_LRU_FREED, it will not temporarily
-release buf_pool_mutex.  Furthermore, the page frame will no longer be
+release buf_pool->mutex.  Furthermore, the page frame will no longer be
 accessible via bpage.
 
-The caller must hold buf_pool_mutex and buf_page_get_mutex(bpage) and
+The caller must hold buf_pool->mutex and buf_page_get_mutex(bpage) and
 release these two mutexes after the call.  No other
 buf_page_get_mutex() may be held when calling this function.
 @return BUF_LRU_FREED if freed, BUF_LRU_CANNOT_RELOCATE or
@@ -114,7 +115,7 @@ buf_LRU_free_block(
 				compressed page of an uncompressed page */
 	ibool*		buf_pool_mutex_released);
 				/*!< in: pointer to a variable that will
-				be assigned TRUE if buf_pool_mutex
+				be assigned TRUE if buf_pool->mutex
 				was temporarily released, or NULL */
 /******************************************************************//**
 Try to free a replaceable block.
@@ -123,22 +124,26 @@ UNIV_INTERN
 ibool
 buf_LRU_search_and_free_block(
 /*==========================*/
-	ulint	n_iterations);	/*!< in: how many times this has been called
-				repeatedly without result: a high value means
-				that we should search farther; if
-				n_iterations < 10, then we search
-				n_iterations / 10 * buf_pool->curr_size
-				pages from the end of the LRU list; if
-				n_iterations < 5, then we will also search
-				n_iterations / 5 of the unzip_LRU list. */
+	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */
+	ulint		n_iterations);	/*!< in: how many times this has
+					been called repeatedly without
+					result: a high value means that
+					we should search farther; if
+					n_iterations < 10, then we search
+					n_iterations / 10 * buf_pool->curr_size
+					pages from the end of the LRU list; if
+					n_iterations < 5, then we will
+					also search n_iterations / 5
+					of the unzip_LRU list. */
 /******************************************************************//**
 Returns a free block from the buf_pool.  The block is taken off the
 free list.  If it is empty, returns NULL.
 @return	a free control block, or NULL if the buf_block->free list is empty */
 UNIV_INTERN
 buf_block_t*
-buf_LRU_get_free_only(void);
-/*=======================*/
+buf_LRU_get_free_only(
+/*==================*/
+	buf_pool_t*	buf_pool);	/*!< buffer pool instance */
 /******************************************************************//**
 Returns a free block from the buf_pool. The block is taken off the
 free list. If it is empty, blocks are moved from the end of the
@@ -148,8 +153,9 @@ UNIV_INTERN
 buf_block_t*
 buf_LRU_get_free_block(
 /*===================*/
-	ulint	zip_size);	/*!< in: compressed page size in bytes,
-				or 0 if uncompressed tablespace */
+	buf_pool_t*	buf_pool,	/*!< in: preferred buffer pool */
+	ulint		zip_size);	/*!< in: compressed page size in bytes,
+					or 0 if uncompressed tablespace */
 
 /******************************************************************//**
 Puts a block back to the free list. */
@@ -196,7 +202,7 @@ buf_LRU_make_block_old(
 Updates buf_LRU_old_ratio.
 @return	updated old_pct */
 UNIV_INTERN
-uint
+ulint
 buf_LRU_old_ratio_update(
 /*=====================*/
 	uint	old_pct,/*!< in: Reserve this percentage of
@@ -232,7 +238,7 @@ buf_LRU_print(void);
 
 /** @name Heuristics for detecting index scan @{ */
 /** Reserve this much/BUF_LRU_OLD_RATIO_DIV of the buffer pool for
-"old" blocks.  Protected by buf_pool_mutex. */
+"old" blocks.  Protected by buf_pool->mutex. */
 extern uint	buf_LRU_old_ratio;
 /** The denominator of buf_LRU_old_ratio. */
 #define BUF_LRU_OLD_RATIO_DIV	1024
@@ -278,7 +284,7 @@ Cleared by buf_LRU_stat_update(). */
 extern buf_LRU_stat_t	buf_LRU_stat_cur;
 
 /** Running sum of past values of buf_LRU_stat_cur.
-Updated by buf_LRU_stat_update().  Protected by buf_pool_mutex. */
+Updated by buf_LRU_stat_update().  Protected by buf_pool->mutex. */
 extern buf_LRU_stat_t	buf_LRU_stat_sum;
 
 /********************************************************************//**
diff --git a/storage/innobase/include/buf0rea.h b/storage/innobase/include/buf0rea.h
index 093750623d6..4a52f9dcd8d 100644
--- a/storage/innobase/include/buf0rea.h
+++ b/storage/innobase/include/buf0rea.h
@@ -124,8 +124,8 @@ buf_read_recv_pages(
 
 /** The size in pages of the area which the read-ahead algorithms read if
 invoked */
-#define	BUF_READ_AHEAD_AREA					\
-	ut_min(64, ut_2_power_up(buf_pool->curr_size / 32))
+#define	BUF_READ_AHEAD_AREA(b)					\
+	ut_min(64, ut_2_power_up((b)->curr_size / 32))
 
 /** @name Modes used in read-ahead @{ */
 /** read only pages belonging to the insert buffer tree */
diff --git a/storage/innobase/include/buf0types.h b/storage/innobase/include/buf0types.h
index bfae6477135..a2175098704 100644
--- a/storage/innobase/include/buf0types.h
+++ b/storage/innobase/include/buf0types.h
@@ -36,6 +36,8 @@ typedef struct buf_chunk_struct		buf_chunk_t;
 typedef	struct buf_pool_struct		buf_pool_t;
 /** Buffer pool statistics struct */
 typedef	struct buf_pool_stat_struct	buf_pool_stat_t;
+/** Buffer pool buddy statistics struct */
+typedef	struct buf_buddy_stat_struct	buf_buddy_stat_t;
 
 /** A buffer frame. @see page_t */
 typedef	byte	buf_frame_t;
diff --git a/storage/innobase/include/ibuf0ibuf.ic b/storage/innobase/include/ibuf0ibuf.ic
index 84c7a004be2..aee27cf9739 100644
--- a/storage/innobase/include/ibuf0ibuf.ic
+++ b/storage/innobase/include/ibuf0ibuf.ic
@@ -110,7 +110,7 @@ ibuf_should_try(
 
 		if (ibuf_flush_count % 4 == 0) {
 
-			buf_LRU_try_free_flushed_blocks();
+			buf_LRU_try_free_flushed_blocks(NULL);
 		}
 
 		return(TRUE);
diff --git a/storage/innobase/include/log0log.h b/storage/innobase/include/log0log.h
index 8fce4ef96bc..1ae94a332e5 100644
--- a/storage/innobase/include/log0log.h
+++ b/storage/innobase/include/log0log.h
@@ -763,6 +763,15 @@ struct log_struct{
 #ifndef UNIV_HOTBACKUP
 	mutex_t		mutex;		/*!< mutex protecting the log */
 #endif /* !UNIV_HOTBACKUP */
+
+	mutex_t		log_flush_order_mutex;/*!< mutex to serialize access to
+					the flush list when we are putting
+					dirty blocks in the list. The idea
+					behind this mutex is to be able
+					to release log_sys->mutex during
+					mtr_commit and still ensure that
+					insertions in the flush_list happen
+					in the LSN order. */
 	byte*		buf_ptr;	/* unaligned log buffer */
 	byte*		buf;		/*!< log buffer */
 	ulint		buf_size;	/*!< log buffer size in bytes */
@@ -952,6 +961,19 @@ struct log_struct{
 #endif /* UNIV_LOG_ARCHIVE */
 };
 
+/** Test if flush order mutex is owned. */
+#define log_flush_order_mutex_own()	\
+	mutex_own(&log_sys->log_flush_order_mutex)
+
+/** Acquire the flush order mutex. */
+#define log_flush_order_mutex_enter() do {		\
+	mutex_enter(&log_sys->log_flush_order_mutex);	\
+} while (0)
+/** Release the flush order mutex. */
+# define log_flush_order_mutex_exit() do {		\
+	mutex_exit(&log_sys->log_flush_order_mutex);	\
+} while (0)
+
 #ifdef UNIV_LOG_ARCHIVE
 /** Archiving state @{ */
 #define LOG_ARCH_ON		71
diff --git a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h
index 74c604124f5..2cec4b919fb 100644
--- a/storage/innobase/include/srv0srv.h
+++ b/storage/innobase/include/srv0srv.h
@@ -142,6 +142,7 @@ extern my_bool	srv_use_sys_malloc;
 extern ibool	srv_use_sys_malloc;
 #endif /* UNIV_HOTBACKUP */
 extern ulint	srv_buf_pool_size;	/*!< requested size in bytes */
+extern ulint    srv_buf_pool_instances; /*!< requested number of buffer pool instances */
 extern ulint	srv_buf_pool_old_size;	/*!< previously requested size */
 extern ulint	srv_buf_pool_curr_size;	/*!< current size in bytes */
 extern ulint	srv_mem_pool_size;
diff --git a/storage/innobase/include/sync0sync.h b/storage/innobase/include/sync0sync.h
index 69c0382d5b9..4e73bee9108 100644
--- a/storage/innobase/include/sync0sync.h
+++ b/storage/innobase/include/sync0sync.h
@@ -81,13 +81,13 @@ extern mysql_pfs_key_t	dict_sys_mutex_key;
 extern mysql_pfs_key_t	file_format_max_mutex_key;
 extern mysql_pfs_key_t	fil_system_mutex_key;
 extern mysql_pfs_key_t	flush_list_mutex_key;
-extern mysql_pfs_key_t	flush_order_mutex_key;
 extern mysql_pfs_key_t	hash_table_mutex_key;
 extern mysql_pfs_key_t	ibuf_bitmap_mutex_key;
 extern mysql_pfs_key_t	ibuf_mutex_key;
 extern mysql_pfs_key_t	ibuf_pessimistic_insert_mutex_key;
 extern mysql_pfs_key_t	ios_mutex_key;
 extern mysql_pfs_key_t	log_sys_mutex_key;
+extern mysql_pfs_key_t	log_flush_order_mutex_key;
 extern mysql_pfs_key_t	kernel_mutex_key;
 # ifdef UNIV_MEM_DEBUG
 extern mysql_pfs_key_t	mem_hash_mutex_key;
@@ -661,6 +661,7 @@ or row lock! */
 #define	SYNC_TRX_LOCK_HEAP	298
 #define SYNC_TRX_SYS_HEADER	290
 #define SYNC_LOG		170
+#define SYNC_LOG_FLUSH_ORDER	147
 #define SYNC_RECV		168
 #define	SYNC_WORK_QUEUE		162
 #define	SYNC_SEARCH_SYS_CONF	161	/* for assigning btr_search_enabled */
@@ -671,7 +672,6 @@ or row lock! */
 					can call routines there! Otherwise
 					the level is SYNC_MEM_HASH. */
 #define	SYNC_BUF_POOL		150	/* Buffer pool mutex */
-#define SYNC_BUF_FLUSH_ORDER	147
 #define	SYNC_BUF_BLOCK		146	/* Block mutex */
 #define	SYNC_BUF_FLUSH_LIST	145	/* Buffer flush list mutex */
 #define SYNC_DOUBLEWRITE	140
diff --git a/storage/innobase/include/ut0mem.h b/storage/innobase/include/ut0mem.h
index cf41cba4643..57dfb08f41c 100644
--- a/storage/innobase/include/ut0mem.h
+++ b/storage/innobase/include/ut0mem.h
@@ -113,12 +113,13 @@ ut_test_malloc(
 	ulint	n);	/*!< in: try to allocate this many bytes */
 #endif /* !UNIV_HOTBACKUP */
 /**********************************************************************//**
-Frees a memory block allocated with ut_malloc. */
+Frees a memory block allocated with ut_malloc. Freeing a NULL pointer is
+a nop. */
 UNIV_INTERN
 void
 ut_free(
 /*====*/
-	void* ptr);  /*!< in, own: memory block */
+	void* ptr);  /*!< in, own: memory block, can be NULL */
 #ifndef UNIV_HOTBACKUP
 /**********************************************************************//**
 Implements realloc. This is needed by /pars/lexyy.c. Otherwise, you should not
diff --git a/storage/innobase/include/ut0rbt.h b/storage/innobase/include/ut0rbt.h
index a35807be442..7902dc91f09 100644
--- a/storage/innobase/include/ut0rbt.h
+++ b/storage/innobase/include/ut0rbt.h
@@ -1,6 +1,29 @@
-/******************************************************
-Red-Black tree implementation.
-(c) 2007 Oracle/Innobase Oy
+/***************************************************************************//**
+
+Copyright (c) 2007, 2010, Innobase Oy. All Rights Reserved.
+
+Portions of this file contain modifications contributed and copyrighted by
+Sun Microsystems, Inc. Those modifications are gratefully acknowledged and
+are described briefly in the InnoDB documentation. The contributions by
+Sun Microsystems are incorporated with their permission, and subject to the
+conditions contained in the file COPYING.Sun_Microsystems.
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+
+*****************************************************************************/
+/******************************************************************//**
+@file include/ut0rbt.h
+Various utilities
 
 Created 2007-03-20 Sunny Bains
 *******************************************************/
@@ -35,7 +58,7 @@ typedef struct ib_rbt_bound_struct ib_rbt_bound_t;
 typedef void (*ib_rbt_print_node)(const ib_rbt_node_t* node);
 typedef int (*ib_rbt_compare)(const void* p1, const void* p2);
 
-/* Red black tree color types */
+/** Red black tree color types */
 enum ib_rbt_color_enum {
 	IB_RBT_RED,
 	IB_RBT_BLACK
@@ -43,7 +66,7 @@ enum ib_rbt_color_enum {
 
 typedef enum ib_rbt_color_enum ib_rbt_color_t;
 
-/* Red black tree node */
+/** Red black tree node */
 struct ib_rbt_node_struct {
 	ib_rbt_color_t	color;			/* color of this node */
 
@@ -54,7 +77,7 @@ struct ib_rbt_node_struct {
 	char		value[1];		/* Data value */
 };
 
-/* Red black tree instance.*/
+/** Red black tree instance.*/
 struct	ib_rbt_struct {
 	ib_rbt_node_t*	nil;			/* Black colored node that is
 						used as a sentinel. This is
@@ -70,7 +93,7 @@ struct	ib_rbt_struct {
 	ulint		sizeof_value;		/* Sizeof the item in bytes */
 };
 
-/* The result of searching for a key in the tree, this is useful for
+/** The result of searching for a key in the tree, this is useful for
 a speedy lookup and insert if key doesn't exist.*/
 struct ib_rbt_bound_struct {
 	const ib_rbt_node_t*
@@ -93,14 +116,14 @@ struct ib_rbt_bound_struct {
 /* Compare a key with the node value (t is tree, k is key, n is node)*/
 #define rbt_compare(t, k, n) (t->compare(k, n->value))
 
-/************************************************************************
+/**********************************************************************//**
 Free an instance of  a red black tree */
 UNIV_INTERN
 void
 rbt_free(
 /*=====*/
 	ib_rbt_t*	tree);			/*!< in: rb tree to free */
-/************************************************************************
+/**********************************************************************//**
 Create an instance of a red black tree
 @return	rb tree instance */
 UNIV_INTERN
@@ -109,7 +132,7 @@ rbt_create(
 /*=======*/
 	size_t		sizeof_value,		/*!< in: size in bytes */
 	ib_rbt_compare	compare);		/*!< in: comparator */
-/************************************************************************
+/**********************************************************************//**
 Delete a node from the red black tree, identified by key */
 UNIV_INTERN
 ibool
@@ -118,7 +141,7 @@ rbt_delete(
 						/* in: TRUE on success */
 	ib_rbt_t*	tree,			/* in: rb tree */
 	const void*	key);			/* in: key to delete */
-/************************************************************************
+/**********************************************************************//**
 Remove a node from the red black tree, NOTE: This function will not delete
 the node instance, THAT IS THE CALLERS RESPONSIBILITY.
 @return	the deleted node with the const. */
@@ -132,7 +155,7 @@ rbt_remove_node(
 						is a fudge and declared const
 						because the caller has access
 						only to const nodes.*/
-/************************************************************************
+/**********************************************************************//**
 Return a node from the red black tree, identified by
 key, NULL if not found
 @return	node if found else return NULL */
@@ -142,7 +165,7 @@ rbt_lookup(
 /*=======*/
 	const ib_rbt_t*	tree,			/*!< in: rb tree to search */
 	const void*	key);			/*!< in: key to lookup */
-/************************************************************************
+/**********************************************************************//**
 Add data to the red black tree, identified by key (no dups yet!)
 @return	inserted node */
 UNIV_INTERN
@@ -153,7 +176,7 @@ rbt_insert(
 	const void*	key,			/*!< in: key for ordering */
 	const void*	value);			/*!< in: data that will be
 						copied to the node.*/
-/************************************************************************
+/**********************************************************************//**
 Add a new node to the tree, useful for data that is pre-sorted.
 @return	appended node */
 UNIV_INTERN
@@ -164,7 +187,7 @@ rbt_add_node(
 	ib_rbt_bound_t*	parent,			/*!< in: parent */
 	const void*	value);			/*!< in: this value is copied
 						to the node */
-/************************************************************************
+/**********************************************************************//**
 Return the left most data node in the tree
 @return	left most node */
 UNIV_INTERN
@@ -172,7 +195,7 @@ const ib_rbt_node_t*
 rbt_first(
 /*======*/
 	const ib_rbt_t*	tree);			/*!< in: rb tree */
-/************************************************************************
+/**********************************************************************//**
 Return the right most data node in the tree
 @return	right most node */
 UNIV_INTERN
@@ -180,7 +203,7 @@ const ib_rbt_node_t*
 rbt_last(
 /*=====*/
 	const ib_rbt_t*	tree);			/*!< in: rb tree */
-/************************************************************************
+/**********************************************************************//**
 Return the next node from current.
 @return	successor node to current that is passed in. */
 UNIV_INTERN
@@ -190,7 +213,7 @@ rbt_next(
 	const ib_rbt_t*	tree,			/*!< in: rb tree */
 	const ib_rbt_node_t*			/* in: current node */
 			current);
-/************************************************************************
+/**********************************************************************//**
 Return the prev node from current.
 @return	precedessor node to current that is passed in */
 UNIV_INTERN
@@ -200,7 +223,7 @@ rbt_prev(
 	const ib_rbt_t*	tree,			/*!< in: rb tree */
 	const ib_rbt_node_t*			/* in: current node */
 			current);
-/************************************************************************
+/**********************************************************************//**
 Find the node that has the lowest key that is >= key.
 @return	node that satisfies the lower bound constraint or NULL */
 UNIV_INTERN
@@ -209,7 +232,7 @@ rbt_lower_bound(
 /*============*/
 	const ib_rbt_t*	tree,			/*!< in: rb tree */
 	const void*	key);			/*!< in: key to search */
-/************************************************************************
+/**********************************************************************//**
 Find the node that has the greatest key that is <= key.
 @return	node that satisifies the upper bound constraint or NULL */
 UNIV_INTERN
@@ -218,7 +241,7 @@ rbt_upper_bound(
 /*============*/
 	const ib_rbt_t*	tree,			/*!< in: rb tree */
 	const void*	key);			/*!< in: key to search */
-/************************************************************************
+/**********************************************************************//**
 Search for the key, a node will be retuned in parent.last, whether it
 was found or not. If not found then parent.last will contain the
 parent node for the possibly new key otherwise the matching node.
@@ -230,7 +253,7 @@ rbt_search(
 	const ib_rbt_t*	tree,			/*!< in: rb tree */
 	ib_rbt_bound_t*	parent,			/*!< in: search bounds */
 	const void*	key);			/*!< in: key to search */
-/************************************************************************
+/**********************************************************************//**
 Search for the key, a node will be retuned in parent.last, whether it
 was found or not. If not found then parent.last will contain the
 parent node for the possibly new key otherwise the matching node.
@@ -243,14 +266,14 @@ rbt_search_cmp(
 	ib_rbt_bound_t*	parent,			/*!< in: search bounds */
 	const void*	key,			/*!< in: key to search */
 	ib_rbt_compare	compare);		/*!< in: comparator */
-/************************************************************************
+/**********************************************************************//**
 Clear the tree, deletes (and free's) all the nodes. */
 UNIV_INTERN
 void
 rbt_clear(
 /*======*/
 	ib_rbt_t*	tree);			/*!< in: rb tree */
-/************************************************************************
+/**********************************************************************//**
 Merge the node from dst into src. Return the number of nodes merged.
 @return	no. of recs merged */
 UNIV_INTERN
@@ -259,7 +282,7 @@ rbt_merge_uniq(
 /*===========*/
 	ib_rbt_t*	dst,			/*!< in: dst rb tree */
 	const ib_rbt_t*	src);			/*!< in: src rb tree */
-/************************************************************************
+/**********************************************************************//**
 Merge the node from dst into src. Return the number of nodes merged.
 Delete the nodes from src after copying node to dst. As a side effect
 the duplicates will be left untouched in the src, since we don't support
@@ -272,7 +295,7 @@ rbt_merge_uniq_destructive(
 /*=======================*/
 	ib_rbt_t*	dst,			/*!< in: dst rb tree */
 	ib_rbt_t*	src);			/*!< in: src rb tree */
-/************************************************************************
+/**********************************************************************//**
 Verify the integrity of the RB tree. For debugging. 0 failure else height
 of tree (in count of black nodes).
 @return	TRUE if OK FALSE if tree invalid. */
@@ -281,7 +304,7 @@ ibool
 rbt_validate(
 /*=========*/
 	const ib_rbt_t*	tree);			/*!< in: tree to validate */
-/************************************************************************
+/**********************************************************************//**
 Iterate over the tree in depth first order. */
 UNIV_INTERN
 void
diff --git a/storage/innobase/log/log0log.c b/storage/innobase/log/log0log.c
index 04ced18bc69..e450307d773 100644
--- a/storage/innobase/log/log0log.c
+++ b/storage/innobase/log/log0log.c
@@ -91,6 +91,7 @@ UNIV_INTERN mysql_pfs_key_t	archive_lock_key;
 
 #ifdef UNIV_PFS_MUTEX
 UNIV_INTERN mysql_pfs_key_t	log_sys_mutex_key;
+UNIV_INTERN mysql_pfs_key_t	log_flush_order_mutex_key;
 #endif /* UNIV_PFS_MUTEX */
 
 #ifdef UNIV_DEBUG
@@ -769,6 +770,10 @@ log_init(void)
 
 	mutex_create(log_sys_mutex_key, &log_sys->mutex, SYNC_LOG);
 
+	mutex_create(log_flush_order_mutex_key,
+		     &log_sys->log_flush_order_mutex,
+		     SYNC_LOG_FLUSH_ORDER);
+
 	mutex_enter(&(log_sys->mutex));
 
 	/* Start the lsn from one log block from zero: this way every
@@ -1650,10 +1655,10 @@ log_preflush_pool_modified_pages(
 		recv_apply_hashed_log_recs(TRUE);
 	}
 
-	n_pages = buf_flush_batch(BUF_FLUSH_LIST, ULINT_MAX, new_oldest);
+	n_pages = buf_flush_list(ULINT_MAX, new_oldest);
 
 	if (sync) {
-		buf_flush_wait_batch_end(BUF_FLUSH_LIST);
+		buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
 	}
 
 	if (n_pages == ULINT_UNDEFINED) {
@@ -3285,9 +3290,9 @@ log_check_log_recs(
 
 	ut_memcpy(scan_buf, start, end - start);
 
-	recv_scan_log_recs((buf_pool->curr_size
-			    - recv_n_pool_free_frames) * UNIV_PAGE_SIZE,
-			   FALSE, scan_buf, end - start,
+	recv_scan_log_recs((buf_pool_get_n_pages()
+			   - (recv_n_pool_free_frames * srv_buf_pool_instances))
+			   * UNIV_PAGE_SIZE, FALSE, scan_buf, end - start,
 			   ut_uint64_align_down(buf_start_lsn,
 						OS_FILE_LOG_BLOCK_SIZE),
 			   &contiguous_lsn, &scanned_lsn);
diff --git a/storage/innobase/log/log0recv.c b/storage/innobase/log/log0recv.c
index 0e96dbbb960..04c06f62df5 100644
--- a/storage/innobase/log/log0recv.c
+++ b/storage/innobase/log/log0recv.c
@@ -1659,11 +1659,15 @@ recv_recover_page_func(
 
 #ifndef UNIV_HOTBACKUP
 	if (modification_to_page) {
+		buf_pool_t*	buf_pool;
+
 		ut_a(block);
 
-		buf_flush_order_mutex_enter();
+		buf_pool = buf_pool_from_block(block);
+
+		log_flush_order_mutex_enter();
 		buf_flush_recv_note_modification(block, start_lsn, end_lsn);
-		buf_flush_order_mutex_exit();
+		log_flush_order_mutex_exit();
 	}
 #endif /* !UNIV_HOTBACKUP */
 
@@ -1848,11 +1852,10 @@ loop:
 		mutex_exit(&(recv_sys->mutex));
 		mutex_exit(&(log_sys->mutex));
 
-		n_pages = buf_flush_batch(BUF_FLUSH_LIST, ULINT_MAX,
-					  IB_ULONGLONG_MAX);
-		ut_a(n_pages != ULINT_UNDEFINED);
-
-		buf_flush_wait_batch_end(BUF_FLUSH_LIST);
+ 		n_pages = buf_flush_list(ULINT_MAX, IB_ULONGLONG_MAX);
+  		ut_a(n_pages != ULINT_UNDEFINED);
+  
+ 		buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
 
 		buf_pool_invalidate();
 
@@ -2762,8 +2765,8 @@ recv_scan_log_recs(
 		recv_parse_log_recs(store_to_hash);
 
 #ifndef UNIV_HOTBACKUP
-		if (store_to_hash && mem_heap_get_size(recv_sys->heap)
-		    > available_memory) {
+		if (store_to_hash
+		    && mem_heap_get_size(recv_sys->heap) > available_memory) {
 
 			/* Hash table of log records has grown too big:
 			empty it; FALSE means no ibuf operations
@@ -2815,8 +2818,10 @@ recv_group_scan_log_recs(
 				       group, start_lsn, end_lsn);
 
 		finished = recv_scan_log_recs(
-			(buf_pool->curr_size - recv_n_pool_free_frames)
-			* UNIV_PAGE_SIZE, TRUE, log_sys->buf, RECV_SCAN_SIZE,
+			(buf_pool_get_n_pages()
+			- (recv_n_pool_free_frames * srv_buf_pool_instances))
+			* UNIV_PAGE_SIZE,
+			TRUE, log_sys->buf, RECV_SCAN_SIZE,
 			start_lsn, contiguous_lsn, group_scanned_lsn);
 		start_lsn = end_lsn;
 	}
@@ -3497,6 +3502,7 @@ recv_reset_log_files_for_backup(
 #endif /* UNIV_HOTBACKUP */
 
 #ifdef UNIV_LOG_ARCHIVE
+/* Dead code */
 /******************************************************//**
 Reads from the archive of a log group and performs recovery.
 @return	TRUE if no more complete consistent archive files */
@@ -3662,7 +3668,8 @@ ask_again:
 		       read_offset % UNIV_PAGE_SIZE, len, buf, NULL);
 
 		ret = recv_scan_log_recs(
-			(buf_pool->n_frames - recv_n_pool_free_frames)
+			(buf_pool_get_n_pages()
+			- (recv_n_pool_free_frames * srv_buf_pool_instances))
 			* UNIV_PAGE_SIZE, TRUE, buf, len, start_lsn,
 			&dummy_lsn, &scanned_lsn);
 
diff --git a/storage/innobase/mem/mem0mem.c b/storage/innobase/mem/mem0mem.c
index c0ce8a3e1ac..3e0e31c0891 100644
--- a/storage/innobase/mem/mem0mem.c
+++ b/storage/innobase/mem/mem0mem.c
@@ -347,7 +347,7 @@ mem_heap_create_block(
 				return(NULL);
 			}
 		} else {
-			buf_block = buf_block_alloc(0);
+			buf_block = buf_block_alloc(NULL, 0);
 		}
 
 		block = (mem_block_t*) buf_block->frame;
diff --git a/storage/innobase/mtr/mtr0mtr.c b/storage/innobase/mtr/mtr0mtr.c
index 78618564ef1..b01462f6b9b 100644
--- a/storage/innobase/mtr/mtr0mtr.c
+++ b/storage/innobase/mtr/mtr0mtr.c
@@ -120,10 +120,14 @@ mtr_memo_slot_note_modification(
 	ut_ad(mtr);
 	ut_ad(mtr->magic_n == MTR_MAGIC_N);
 	ut_ad(mtr->modifications);
-	ut_ad(buf_flush_order_mutex_own());
 
 	if (slot->object != NULL && slot->type == MTR_MEMO_PAGE_X_FIX) {
-		buf_flush_note_modification((buf_block_t*) slot->object, mtr);
+		buf_block_t*	block = (buf_block_t*) slot->object;
+
+#ifdef UNIV_DEBUG
+		ut_ad(log_flush_order_mutex_own());
+#endif /* UNIV_DEBUG */
+		buf_flush_note_modification(block, mtr);
 	}
 }
 
@@ -221,16 +225,18 @@ mtr_log_reserve_and_write(
 	mtr->end_lsn = log_close();
 
 func_exit:
-	buf_flush_order_mutex_enter();
+	log_flush_order_mutex_enter();
 
 	/* It is now safe to release the log mutex because the
 	flush_order mutex will ensure that we are the first one
 	to insert into the flush list. */
 	log_release();
+
 	if (mtr->modifications) {
 		mtr_memo_note_modifications(mtr);
 	}
-	buf_flush_order_mutex_exit();
+
+	log_flush_order_mutex_exit();
 }
 #endif /* !UNIV_HOTBACKUP */
 
@@ -324,7 +330,7 @@ mtr_memo_release(
 
 	offset = dyn_array_get_data_size(memo);
 
-	buf_flush_order_mutex_enter();
+	log_flush_order_mutex_enter();
 	while (offset > 0) {
 		offset -= sizeof(mtr_memo_slot_t);
 
@@ -340,7 +346,7 @@ mtr_memo_release(
 			break;
 		}
 	}
-	buf_flush_order_mutex_exit();
+	log_flush_order_mutex_exit();
 }
 #endif /* !UNIV_HOTBACKUP */
 
diff --git a/storage/innobase/page/page0zip.c b/storage/innobase/page/page0zip.c
index aa5e39ff04a..cc7ec2f404c 100644
--- a/storage/innobase/page/page0zip.c
+++ b/storage/innobase/page/page0zip.c
@@ -4416,6 +4416,7 @@ page_zip_reorganize(
 	dict_index_t*	index,	/*!< in: index of the B-tree node */
 	mtr_t*		mtr)	/*!< in: mini-transaction */
 {
+	buf_pool_t*	buf_pool	= buf_pool_from_block(block);
 	page_zip_des_t*	page_zip	= buf_block_get_page_zip(block);
 	page_t*		page		= buf_block_get_frame(block);
 	buf_block_t*	temp_block;
@@ -4433,7 +4434,7 @@ page_zip_reorganize(
 	log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
 
 #ifndef UNIV_HOTBACKUP
-	temp_block = buf_block_alloc(0);
+	temp_block = buf_block_alloc(buf_pool, 0);
 	btr_search_drop_page_hash_index(block);
 	block->check_index_page_at_flush = TRUE;
 #else /* !UNIV_HOTBACKUP */
diff --git a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c
index 838df292bfc..560dafa6138 100644
--- a/storage/innobase/srv/srv0srv.c
+++ b/storage/innobase/srv/srv0srv.c
@@ -195,6 +195,8 @@ UNIV_INTERN const byte*	srv_latin1_ordering;
 UNIV_INTERN my_bool	srv_use_sys_malloc	= TRUE;
 /* requested size in kilobytes */
 UNIV_INTERN ulint	srv_buf_pool_size	= ULINT_MAX;
+/* requested number of buffer pool instances */
+UNIV_INTERN ulint       srv_buf_pool_instances  = 1;
 /* previously requested size */
 UNIV_INTERN ulint	srv_buf_pool_old_size;
 /* current size in kilobytes */
@@ -1700,7 +1702,7 @@ srv_refresh_innodb_monitor_stats(void)
 
 	log_refresh_stats();
 
-	buf_refresh_io_stats();
+	buf_refresh_io_stats_all();
 
 	srv_n_rows_inserted_old = srv_n_rows_inserted;
 	srv_n_rows_updated_old = srv_n_rows_updated;
@@ -1911,6 +1913,14 @@ void
 srv_export_innodb_status(void)
 /*==========================*/
 {
+	buf_pool_stat_t	stat;
+	ulint		LRU_len;
+	ulint		free_len;
+	ulint		flush_list_len;
+
+	buf_get_total_stat(&stat);
+	buf_get_total_list_len(&LRU_len, &free_len, &flush_list_len);
+
 	mutex_enter(&srv_innodb_monitor_mutex);
 
 	export_vars.innodb_data_pending_reads
@@ -1925,31 +1935,26 @@ srv_export_innodb_status(void)
 	export_vars.innodb_data_reads = os_n_file_reads;
 	export_vars.innodb_data_writes = os_n_file_writes;
 	export_vars.innodb_data_written = srv_data_written;
-	export_vars.innodb_buffer_pool_read_requests = buf_pool->stat.n_page_gets;
+	export_vars.innodb_buffer_pool_read_requests = stat.n_page_gets;
 	export_vars.innodb_buffer_pool_write_requests
 		= srv_buf_pool_write_requests;
 	export_vars.innodb_buffer_pool_wait_free = srv_buf_pool_wait_free;
 	export_vars.innodb_buffer_pool_pages_flushed = srv_buf_pool_flushed;
 	export_vars.innodb_buffer_pool_reads = srv_buf_pool_reads;
 	export_vars.innodb_buffer_pool_read_ahead
-		= buf_pool->stat.n_ra_pages_read;
+		= stat.n_ra_pages_read;
 	export_vars.innodb_buffer_pool_read_ahead_evicted
-		= buf_pool->stat.n_ra_pages_evicted;
-	export_vars.innodb_buffer_pool_pages_data
-		= UT_LIST_GET_LEN(buf_pool->LRU);
-	export_vars.innodb_buffer_pool_pages_dirty
-		= UT_LIST_GET_LEN(buf_pool->flush_list);
-	export_vars.innodb_buffer_pool_pages_free
-		= UT_LIST_GET_LEN(buf_pool->free);
+		= stat.n_ra_pages_evicted;
+	export_vars.innodb_buffer_pool_pages_data = LRU_len;
+	export_vars.innodb_buffer_pool_pages_dirty = flush_list_len;
+	export_vars.innodb_buffer_pool_pages_free = free_len;
 #ifdef UNIV_DEBUG
 	export_vars.innodb_buffer_pool_pages_latched
 		= buf_get_latched_pages_number();
 #endif /* UNIV_DEBUG */
-	export_vars.innodb_buffer_pool_pages_total = buf_pool->curr_size;
+	export_vars.innodb_buffer_pool_pages_total = buf_pool_get_curr_size();
 
-	export_vars.innodb_buffer_pool_pages_misc = buf_pool->curr_size
-		- UT_LIST_GET_LEN(buf_pool->LRU)
-		- UT_LIST_GET_LEN(buf_pool->free);
+	export_vars.innodb_buffer_pool_pages_misc = buf_pool_get_curr_size();
 #ifdef HAVE_ATOMIC_BUILTINS
 	export_vars.innodb_have_atomic_builtins = 1;
 #else
@@ -1965,9 +1970,9 @@ srv_export_innodb_status(void)
 	export_vars.innodb_log_writes = srv_log_writes;
 	export_vars.innodb_dblwr_pages_written = srv_dblwr_pages_written;
 	export_vars.innodb_dblwr_writes = srv_dblwr_writes;
-	export_vars.innodb_pages_created = buf_pool->stat.n_pages_created;
-	export_vars.innodb_pages_read = buf_pool->stat.n_pages_read;
-	export_vars.innodb_pages_written = buf_pool->stat.n_pages_written;
+	export_vars.innodb_pages_created = stat.n_pages_created;
+	export_vars.innodb_pages_read = stat.n_pages_read;
+	export_vars.innodb_pages_written = stat.n_pages_written;
 	export_vars.innodb_row_lock_waits = srv_n_lock_wait_count;
 	export_vars.innodb_row_lock_current_waits
 		= srv_n_lock_wait_current_count;
@@ -2279,7 +2284,7 @@ srv_error_monitor_thread(
 #endif
 
 #ifdef UNIV_PFS_THREAD
-        pfs_register_thread(srv_error_monitor_thread_key);
+	pfs_register_thread(srv_error_monitor_thread_key);
 #endif
 
 loop:
@@ -2503,6 +2508,7 @@ srv_master_thread(
 			/*!< in: a dummy parameter required by
 			os_thread_create */
 {
+	buf_pool_stat_t buf_stat;
 	os_event_t	event;
 	ulint		old_activity_count;
 	ulint		n_pages_purged	= 0;
@@ -2544,8 +2550,9 @@ loop:
 
 	srv_main_thread_op_info = "reserving kernel mutex";
 
-	n_ios_very_old = log_sys->n_log_ios + buf_pool->stat.n_pages_read
-		+ buf_pool->stat.n_pages_written;
+	buf_get_total_stat(&buf_stat);
+	n_ios_very_old = log_sys->n_log_ios + buf_stat.n_pages_read
+		+ buf_stat.n_pages_written;
 	mutex_enter(&kernel_mutex);
 
 	/* Store the user activity counter at the start of this loop */
@@ -2566,8 +2573,12 @@ loop:
 
 	for (i = 0; i < 10; i++) {
 		ulint	cur_time = ut_time_ms();
-		n_ios_old = log_sys->n_log_ios + buf_pool->stat.n_pages_read
-			+ buf_pool->stat.n_pages_written;
+
+		buf_get_total_stat(&buf_stat);
+
+		n_ios_old = log_sys->n_log_ios + buf_stat.n_pages_read
+			+ buf_stat.n_pages_written;
+
 		srv_main_thread_op_info = "sleeping";
 		srv_main_1_second_loops++;
 
@@ -2607,13 +2618,14 @@ loop:
 		log_free_check();
 
 		/* If i/os during one second sleep were less than 5% of
-                capacity, we assume that there is free disk i/o capacity
-                available, and it makes sense to do an insert buffer merge. */
+		capacity, we assume that there is free disk i/o capacity
+		available, and it makes sense to do an insert buffer merge. */
 
+		buf_get_total_stat(&buf_stat);
 		n_pend_ios = buf_get_n_pending_ios()
 			+ log_sys->n_pending_writes;
-		n_ios = log_sys->n_log_ios + buf_pool->stat.n_pages_read
-			+ buf_pool->stat.n_pages_written;
+		n_ios = log_sys->n_log_ios + buf_stat.n_pages_read
+			+ buf_stat.n_pages_written;
 		if (n_pend_ios < SRV_PEND_IO_THRESHOLD
 		    && (n_ios - n_ios_old < SRV_RECENT_IO_ACTIVITY)) {
 			srv_main_thread_op_info = "doing insert buffer merge";
@@ -2631,9 +2643,8 @@ loop:
 
 			srv_main_thread_op_info =
 				"flushing buffer pool pages";
-			n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
-							  PCT_IO(100),
-							  IB_ULONGLONG_MAX);
+			n_pages_flushed = buf_flush_list(
+				PCT_IO(100), IB_ULONGLONG_MAX);
 
 		} else if (srv_adaptive_flushing) {
 
@@ -2647,8 +2658,7 @@ loop:
 					"flushing buffer pool pages";
 				n_flush = ut_min(PCT_IO(100), n_flush);
 				n_pages_flushed =
-					buf_flush_batch(
-						BUF_FLUSH_LIST,
+					buf_flush_list(
 						n_flush,
 						IB_ULONGLONG_MAX);
 			}
@@ -2680,17 +2690,17 @@ loop:
 	loop above requests writes for that case. The writes done here
 	are not required, and may be disabled. */
 
+	buf_get_total_stat(&buf_stat);
 	n_pend_ios = buf_get_n_pending_ios() + log_sys->n_pending_writes;
-	n_ios = log_sys->n_log_ios + buf_pool->stat.n_pages_read
-		+ buf_pool->stat.n_pages_written;
+	n_ios = log_sys->n_log_ios + buf_stat.n_pages_read
+		+ buf_stat.n_pages_written;
 
 	srv_main_10_second_loops++;
 	if (n_pend_ios < SRV_PEND_IO_THRESHOLD
 	    && (n_ios - n_ios_very_old < SRV_PAST_IO_ACTIVITY)) {
 
 		srv_main_thread_op_info = "flushing buffer pool pages";
-		buf_flush_batch(BUF_FLUSH_LIST, PCT_IO(100),
-				IB_ULONGLONG_MAX);
+		buf_flush_list(PCT_IO(100), IB_ULONGLONG_MAX);
 
 		/* Flush logs if needed */
 		srv_sync_log_buffer_in_background();
@@ -2705,8 +2715,6 @@ loop:
 	/* Flush logs if needed */
 	srv_sync_log_buffer_in_background();
 
-	/* We run a full purge every 10 seconds, even if the server
-	were active */
 	if (srv_n_purge_threads == 0) {
 		srv_main_thread_op_info = "master purging";
 
@@ -2728,17 +2736,15 @@ loop:
 		(> 70 %), we assume we can afford reserving the disk(s) for
 		the time it requires to flush 100 pages */
 
-		n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
-						  PCT_IO(100),
-						  IB_ULONGLONG_MAX);
+		n_pages_flushed = buf_flush_list(
+			PCT_IO(100), IB_ULONGLONG_MAX);
 	} else {
 		/* Otherwise, we only flush a small number of pages so that
 		we do not unnecessarily use much disk i/o capacity from
 		other work */
 
-		n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
-						  PCT_IO(10),
-						  IB_ULONGLONG_MAX);
+		n_pages_flushed = buf_flush_list(
+			  PCT_IO(10), IB_ULONGLONG_MAX);
 	}
 
 	srv_main_thread_op_info = "making checkpoint";
@@ -2807,7 +2813,7 @@ background_loop:
 	} else {
 		/* This should do an amount of IO similar to the number of
 		dirty pages that will be flushed in the call to
-		buf_flush_batch below. Otherwise, the system favors
+		buf_flush_list below. Otherwise, the system favors
 		clean pages over cleanup throughput. */
 		n_bytes_merged = ibuf_contract_for_n_pages(FALSE,
 							   PCT_IO(100));
@@ -2826,9 +2832,8 @@ flush_loop:
 	srv_main_thread_op_info = "flushing buffer pool pages";
 	srv_main_flush_loops++;
 	if (srv_fast_shutdown < 2) {
-		n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
-						  PCT_IO(100),
-						  IB_ULONGLONG_MAX);
+		n_pages_flushed = buf_flush_list(
+			  PCT_IO(100), IB_ULONGLONG_MAX);
 	} else {
 		/* In the fastest shutdown we do not flush the buffer pool
 		to data files: we set n_pages_flushed to 0 artificially. */
@@ -2846,7 +2851,7 @@ flush_loop:
 	mutex_exit(&kernel_mutex);
 
 	srv_main_thread_op_info = "waiting for buffer pool flush to end";
-	buf_flush_wait_batch_end(BUF_FLUSH_LIST);
+	buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
 
 	/* Flush logs if needed */
 	srv_sync_log_buffer_in_background();
diff --git a/storage/innobase/srv/srv0start.c b/storage/innobase/srv/srv0start.c
index a257fd32aab..4c9851e953b 100644
--- a/storage/innobase/srv/srv0start.c
+++ b/storage/innobase/srv/srv0start.c
@@ -1016,7 +1016,6 @@ int
 innobase_start_or_create_for_mysql(void)
 /*====================================*/
 {
-	buf_pool_t*	ret;
 	ibool		create_new_db;
 	ibool		log_file_created;
 	ibool		log_created	= FALSE;
@@ -1241,13 +1240,16 @@ innobase_start_or_create_for_mysql(void)
 #else
 	if (srv_buf_pool_size >= 1000 * 1024 * 1024) {
 		/* If buffer pool is less than 1000 MB,
-		assume fewer threads. */
+		assume fewer threads. Also use only one
+		buffer pool instance */
 		srv_max_n_threads = 50000;
 
 	} else if (srv_buf_pool_size >= 8 * 1024 * 1024) {
 
+		srv_buf_pool_instances = 1;
 		srv_max_n_threads = 10000;
 	} else {
+		srv_buf_pool_instances = 1;
 		srv_max_n_threads = 1000;	/* saves several MB of memory,
 						especially in 64-bit
 						computers */
@@ -1331,9 +1333,9 @@ innobase_start_or_create_for_mysql(void)
 	fil_init(srv_file_per_table ? 50000 : 5000,
 		 srv_max_n_open_files);
 
-	ret = buf_pool_init();
+	err = buf_pool_init(srv_buf_pool_size, srv_buf_pool_instances);
 
-	if (ret == NULL) {
+	if (err != DB_SUCCESS) {
 		fprintf(stderr,
 			"InnoDB: Fatal error: cannot allocate the memory"
 			" for the buffer pool\n");
@@ -2089,7 +2091,7 @@ innobase_shutdown_for_mysql(void)
 
 	pars_lexer_close();
 	log_mem_free();
-	buf_pool_free();
+	buf_pool_free(srv_buf_pool_instances);
 	ut_free_all_mem();
 	mem_close();
 
diff --git a/storage/innobase/sync/sync0sync.c b/storage/innobase/sync/sync0sync.c
index b9b83adba00..235f733382d 100644
--- a/storage/innobase/sync/sync0sync.c
+++ b/storage/innobase/sync/sync0sync.c
@@ -1157,14 +1157,12 @@ sync_thread_add_level(
 	case SYNC_RECV:
 	case SYNC_WORK_QUEUE:
 	case SYNC_LOG:
+	case SYNC_LOG_FLUSH_ORDER:
 	case SYNC_THR_LOCAL:
 	case SYNC_ANY_LATCH:
 	case SYNC_TRX_SYS_HEADER:
 	case SYNC_FILE_FORMAT_TAG:
 	case SYNC_DOUBLEWRITE:
-	case SYNC_BUF_FLUSH_LIST:
-	case SYNC_BUF_FLUSH_ORDER:
-	case SYNC_BUF_POOL:
 	case SYNC_SEARCH_SYS:
 	case SYNC_SEARCH_SYS_CONF:
 	case SYNC_TRX_LOCK_HEAP:
@@ -1186,6 +1184,18 @@ sync_thread_add_level(
 			ut_error;
 		}
 		break;
+	case SYNC_BUF_FLUSH_LIST:
+	case SYNC_BUF_POOL:
+		/* We can have multiple mutexes of this type therefore we
+		can only check whether the greater than condition holds. */
+		if (!sync_thread_levels_g(array, level-1, TRUE)) {
+			fprintf(stderr,
+				"InnoDB: sync_thread_levels_g(array, %lu)"
+				" does not hold!\n", level-1);
+			ut_error;
+		}
+		break;
+
 	case SYNC_BUF_BLOCK:
 		/* Either the thread must own the buffer pool mutex
 		(buf_pool_mutex), or it is allowed to latch only ONE
diff --git a/storage/innobase/trx/trx0trx.c b/storage/innobase/trx/trx0trx.c
index a47fc28c199..cf7fe85c3d1 100644
--- a/storage/innobase/trx/trx0trx.c
+++ b/storage/innobase/trx/trx0trx.c
@@ -764,7 +764,6 @@ trx_commit_off_kernel(
 		if (undo) {
 			mutex_enter(&kernel_mutex);
 			trx->no = trx_sys_get_new_trx_no();
-
 			mutex_exit(&kernel_mutex);
 
 			/* It is not necessary to obtain trx->undo_mutex here
diff --git a/storage/innobase/trx/trx0undo.c b/storage/innobase/trx/trx0undo.c
index 3bb1b1cdf6c..eb5112c4d31 100644
--- a/storage/innobase/trx/trx0undo.c
+++ b/storage/innobase/trx/trx0undo.c
@@ -1938,7 +1938,8 @@ trx_undo_update_cleanup(
 
 		UT_LIST_ADD_FIRST(undo_list, rseg->update_undo_cached, undo);
 	} else {
-		ut_ad(undo->state == TRX_UNDO_TO_PURGE);
+		ut_ad(undo->state == TRX_UNDO_TO_PURGE
+		      || undo->state == TRX_UNDO_TO_FREE);
 
 		trx_undo_mem_free(undo);
 	}
diff --git a/storage/innobase/ut/ut0mem.c b/storage/innobase/ut/ut0mem.c
index 35a325b9ccd..f2baab67f09 100644
--- a/storage/innobase/ut/ut0mem.c
+++ b/storage/innobase/ut/ut0mem.c
@@ -290,17 +290,20 @@ ut_test_malloc(
 #endif /* !UNIV_HOTBACKUP */
 
 /**********************************************************************//**
-Frees a memory block allocated with ut_malloc. */
+Frees a memory block allocated with ut_malloc. Freeing a NULL pointer is
+a nop. */
 UNIV_INTERN
 void
 ut_free(
 /*====*/
-	void* ptr)  /*!< in, own: memory block */
+	void* ptr)  /*!< in, own: memory block, can be NULL */
 {
 #ifndef UNIV_HOTBACKUP
 	ut_mem_block_t* block;
 
-	if (UNIV_LIKELY(srv_use_sys_malloc)) {
+	if (ptr == NULL) {
+		return;
+	} else if (UNIV_LIKELY(srv_use_sys_malloc)) {
 		free(ptr);
 		return;
 	}
diff --git a/storage/innobase/ut/ut0rbt.c b/storage/innobase/ut/ut0rbt.c
index 3279307308f..3d7cfa7636f 100644
--- a/storage/innobase/ut/ut0rbt.c
+++ b/storage/innobase/ut/ut0rbt.c
@@ -1,4 +1,27 @@
-/**********************************************************************
+/***************************************************************************//**
+
+Copyright (c) 2007, 2010, Innobase Oy. All Rights Reserved.
+
+Portions of this file contain modifications contributed and copyrighted by
+Sun Microsystems, Inc. Those modifications are gratefully acknowledged and
+are described briefly in the InnoDB documentation. The contributions by
+Sun Microsystems are incorporated with their permission, and subject to the
+conditions contained in the file COPYING.Sun_Microsystems.
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+
+*****************************************************************************/
+/********************************************************************//**
 Red-Black tree implementation
 
 (c) 2007 Oracle/Innobase Oy
@@ -8,7 +31,7 @@ Created 2007-03-20 Sunny Bains
 
 #include "ut0rbt.h"
 
-/************************************************************************
+/**********************************************************************//**
 Definition of a red-black tree
 ==============================
 
@@ -34,7 +57,7 @@ red-black properties:
 #define ROOT(t)		(t->root->left)
 #define	SIZEOF_NODE(t)	((sizeof(ib_rbt_node_t) + t->sizeof_value) - 1)
 
-/************************************************************************
+/**********************************************************************//**
 Print out the sub-tree recursively. */
 static
 void
@@ -52,7 +75,7 @@ rbt_print_subtree(
 	}
 }
 
-/************************************************************************
+/**********************************************************************//**
 Verify that the keys are in order.
 @return	TRUE of OK. FALSE if not ordered */
 static
@@ -77,7 +100,7 @@ rbt_check_ordering(
 	return(TRUE);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Check that every path from the root to the leaves has the same count.
 Count is expressed in the number of black nodes.
 @return	0 on failure else black height of the subtree */
@@ -125,7 +148,7 @@ rbt_count_black_nodes(
 	return(result);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Turn the node's right child's left sub-tree into node's right sub-tree.
 This will also make node's right child it's parent. */
 static
@@ -161,7 +184,7 @@ rbt_rotate_left(
 	node->parent = right;
 }
 
-/************************************************************************
+/**********************************************************************//**
 Turn the node's left child's right sub-tree into node's left sub-tree.
 This also make node's left child it's parent. */
 static
@@ -197,7 +220,7 @@ rbt_rotate_right(
 	node->parent = left;
 }
 
-/************************************************************************
+/**********************************************************************//**
 Append a node to the tree. */
 static
 ib_rbt_node_t*
@@ -224,7 +247,7 @@ rbt_tree_add_child(
 	return(node);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Generic binary tree insert */
 static
 ib_rbt_node_t*
@@ -260,7 +283,7 @@ rbt_tree_insert(
 	return(node);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Balance a tree after inserting a node. */
 static
 void
@@ -350,7 +373,7 @@ rbt_balance_tree(
 	ROOT(tree)->color = IB_RBT_BLACK;
 }
 
-/************************************************************************
+/**********************************************************************//**
 Find the given node's successor.
 @return	successor node or NULL if no successor */
 static
@@ -390,7 +413,7 @@ rbt_find_successor(
 	return(next);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Find the given node's precedecessor.
 @return	predecessor node or NULL if no predecesor */
 static
@@ -430,7 +453,7 @@ rbt_find_predecessor(
 	return(prev);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Replace node with child. After applying transformations eject becomes
 an orphan. */
 static
@@ -454,7 +477,7 @@ rbt_eject_node(
 	node->parent = eject->parent;
 }
 
-/************************************************************************
+/**********************************************************************//**
 Replace a node with another node. */
 static
 void
@@ -481,7 +504,7 @@ rbt_replace_node(
 	replace->color = color;
 }
 
-/************************************************************************
+/**********************************************************************//**
 Detach node from the tree replacing it with one of it's children.
 @return	the child node that now occupies the position of the detached node */
 static
@@ -524,7 +547,7 @@ rbt_detach_node(
 	return(child);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Rebalance the right sub-tree after deletion.
 @return	node to rebalance if more rebalancing required else NULL */
 static
@@ -584,7 +607,7 @@ rbt_balance_right(
 	return(node);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Rebalance the left sub-tree after deletion.
 @return	node to rebalance if more rebalancing required else NULL */
 static
@@ -644,7 +667,7 @@ rbt_balance_left(
 	return(node);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Delete the node and rebalance the tree if necessary */
 static
 void
@@ -696,7 +719,7 @@ rbt_remove_node_and_rebalance(
 	--tree->n_nodes;
 }
 
-/************************************************************************
+/**********************************************************************//**
 Recursively free the nodes. */
 static
 void
@@ -713,7 +736,7 @@ rbt_free_node(
 	}
 }
 
-/************************************************************************
+/**********************************************************************//**
 Free all the nodes and free the tree. */
 UNIV_INTERN
 void
@@ -726,7 +749,7 @@ rbt_free(
 	ut_free(tree);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Create an instance of a red black tree.
 @return	an empty rb tree */
 UNIV_INTERN
@@ -764,7 +787,7 @@ rbt_create(
 	return(tree);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Generic insert of a value in the rb tree.
 @return	inserted node */
 UNIV_INTERN
@@ -793,7 +816,7 @@ rbt_insert(
 	return(node);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Add a new node to the tree, useful for data that is pre-sorted.
 @return	appended node */
 UNIV_INTERN
@@ -831,7 +854,7 @@ rbt_add_node(
 	return(node);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Find a matching node in the rb tree.
 @return	NULL if not found else the node where key was found */
 UNIV_INTERN
@@ -859,7 +882,7 @@ rbt_lookup(
 	return(current != tree->nil ? current : NULL);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Delete a node indentified by key.
 @return	TRUE if success FALSE if not found */
 UNIV_INTERN
@@ -882,7 +905,7 @@ rbt_delete(
 	return(deleted);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Remove a node from the rb tree, the node is not free'd, that is the
 callers responsibility.
 @return	deleted node but without the const */
@@ -906,7 +929,7 @@ rbt_remove_node(
 	return((ib_rbt_node_t*) const_node);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Find the node that has the lowest key that is >= key.
 @return	node satisfying the lower bound constraint or NULL */
 UNIV_INTERN
@@ -940,7 +963,7 @@ rbt_lower_bound(
 	return(lb_node);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Find the node that has the greatest key that is <= key.
 @return	node satisfying the upper bound constraint or NULL */
 UNIV_INTERN
@@ -974,7 +997,7 @@ rbt_upper_bound(
 	return(ub_node);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Find the node that has the greatest key that is <= key.
 @return	value of result */
 UNIV_INTERN
@@ -1008,7 +1031,7 @@ rbt_search(
 	return(parent->result);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Find the node that has the greatest key that is <= key. But use the
 supplied comparison function.
 @return	value of result */
@@ -1044,7 +1067,7 @@ rbt_search_cmp(
 	return(parent->result);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Return the left most node in the tree. */
 UNIV_INTERN
 const ib_rbt_node_t*
@@ -1064,7 +1087,7 @@ rbt_first(
 	return(first);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Return the right most node in the tree.
 @return	the rightmost node or NULL */
 UNIV_INTERN
@@ -1084,7 +1107,7 @@ rbt_last(
 	return(last);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Return the next node.
 @return	node next from current */
 UNIV_INTERN
@@ -1097,7 +1120,7 @@ rbt_next(
 	return(current ? rbt_find_successor(tree, current) : NULL);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Return the previous node.
 @return	node prev from current */
 UNIV_INTERN
@@ -1110,7 +1133,7 @@ rbt_prev(
 	return(current ? rbt_find_predecessor(tree, current) : NULL);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Reset the tree. Delete all the nodes. */
 UNIV_INTERN
 void
@@ -1124,7 +1147,7 @@ rbt_clear(
 	tree->root->left = tree->root->right = tree->nil;
 }
 
-/************************************************************************
+/**********************************************************************//**
 Merge the node from dst into src. Return the number of nodes merged.
 @return	no. of recs merged */
 UNIV_INTERN
@@ -1153,7 +1176,7 @@ rbt_merge_uniq(
 	return(n_merged);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Merge the node from dst into src. Return the number of nodes merged.
 Delete the nodes from src after copying node to dst. As a side effect
 the duplicates will be left untouched in the src.
@@ -1201,7 +1224,7 @@ rbt_merge_uniq_destructive(
 	return(rbt_size(dst) - old_size);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Check that every path from the root to the leaves has the same count and
 the tree nodes are in order.
 @return	TRUE if OK FALSE otherwise */
@@ -1218,7 +1241,7 @@ rbt_validate(
 	return(FALSE);
 }
 
-/************************************************************************
+/**********************************************************************//**
 Iterate over the tree in depth first order. */
 UNIV_INTERN
 void