~drizzle-trunk/drizzle/development

/*****************************************************************************

Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.

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., 51 Franklin

St, Fifth Floor, Boston, MA 02110-1301 USA

*****************************************************************************/

/**************************************************//**

@file buf/buf0lru.c

The database buffer replacement algorithm

Created 11/5/1995 Heikki Tuuri

*******************************************************/

#include "config.h"

#include "buf0lru.h"

#ifdef UNIV_NONINL

#include "buf0lru.ic"

#endif

#include "ut0byte.h"

#include "ut0lst.h"

#include "ut0rnd.h"

#include "sync0sync.h"

#include "sync0rw.h"

#include "hash0hash.h"

#include "os0sync.h"

#include "fil0fil.h"

#include "btr0btr.h"

#include "buf0buddy.h"

#include "buf0buf.h"

#include "buf0flu.h"

#include "buf0rea.h"

#include "btr0sea.h"

#include "ibuf0ibuf.h"

#include "os0file.h"

#include "page0zip.h"

#include "log0recv.h"

#include "srv0srv.h"

/** The number of blocks from the LRU_old pointer onward, including

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

allowed to point to either end of the LRU list. */

#define BUF_LRU_OLD_TOLERANCE	20

/** The minimum amount of non-old blocks when the LRU_old list exists

(that is, when there are more than BUF_LRU_OLD_MIN_LEN blocks).

@see buf_LRU_old_adjust_len */

#define BUF_LRU_NON_OLD_MIN_LEN	5

#if BUF_LRU_NON_OLD_MIN_LEN >= BUF_LRU_OLD_MIN_LEN

# error "BUF_LRU_NON_OLD_MIN_LEN >= BUF_LRU_OLD_MIN_LEN"

#endif

/** When dropping the search hash index entries before deleting an ibd

file, we build a local array of pages belonging to that tablespace

in the buffer pool. Following is the size of that array. */

#define BUF_LRU_DROP_SEARCH_HASH_SIZE	1024

/** If we switch on the InnoDB monitor because there are too few available

frames in the buffer pool, we set this to TRUE */

static ibool	buf_lru_switched_on_innodb_mon	= FALSE;

/******************************************************************//**

These statistics are not 'of' LRU but 'for' LRU.  We keep count of I/O

and page_zip_decompress() operations.  Based on the statistics,

buf_LRU_evict_from_unzip_LRU() decides if we want to evict from

unzip_LRU or the regular LRU.  From unzip_LRU, we will only evict the

uncompressed frame (meaning we can evict dirty blocks as well).  From

the regular LRU, we will evict the entire block (i.e.: both the

uncompressed and compressed data), which must be clean. */

/* @{ */

/** Number of intervals for which we keep the history of these stats.

Each interval is 1 second, defined by the rate at which

srv_error_monitor_thread() calls buf_LRU_stat_update(). */

#define BUF_LRU_STAT_N_INTERVAL 50

/** Co-efficient with which we multiply I/O operations to equate them

with page_zip_decompress() operations. */

#define BUF_LRU_IO_TO_UNZIP_FACTOR 50

/** Sampled values buf_LRU_stat_cur.

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;

/** Current operation counters.  Not protected by any mutex.  Cleared

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().  Not Protected by any mutex. */

UNIV_INTERN buf_LRU_stat_t	buf_LRU_stat_sum;

/* @} */

/** @name Heuristics for detecting index scan @{ */

/** 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;

/* @} */

/******************************************************************//**

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.

If a compressed page or a compressed-only block descriptor is freed,

other compressed pages or compressed-only block descriptors may be

relocated.

@return the new state of the block (BUF_BLOCK_ZIP_FREE if the state

was BUF_BLOCK_ZIP_PAGE, or BUF_BLOCK_REMOVE_HASH otherwise) */

static

enum buf_page_state

buf_LRU_block_remove_hashed_page(

/*=============================*/

	buf_page_t*	bpage,	/*!< in: block, must contain a file page and

				be in a state where it can be freed; there

				may or may not be a hash index to the page */

	ibool		zip);	/*!< in: TRUE if should remove also the

				compressed page of an uncompressed page */

/******************************************************************//**

Puts a file page whose has no hash index to the free list. */

static

void

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 */

/******************************************************************//**

Determines if the unzip_LRU list should be used for evicting a victim

instead of the general LRU list.

@return	TRUE if should use unzip_LRU */

UNIV_INLINE

ibool

buf_LRU_evict_from_unzip_LRU(

/*=========================*/

	buf_pool_t*	buf_pool)

{

	ulint	io_avg;

	ulint	unzip_avg;

	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) {

		return(FALSE);

	}

	/* If unzip_LRU is at most 10% of the size of the LRU list,

	then use the LRU.  This slack allows us to keep hot

	decompressed pages in the buffer pool. */

	if (UT_LIST_GET_LEN(buf_pool->unzip_LRU)

	    <= UT_LIST_GET_LEN(buf_pool->LRU) / 10) {

		return(FALSE);

	}

	/* If eviction hasn't started yet, we assume by default

	that a workload is disk bound. */

	if (buf_pool->freed_page_clock == 0) {

		return(TRUE);

	}

	/* Calculate the average over past intervals, and add the values

	of the current interval. */

	io_avg = buf_LRU_stat_sum.io / BUF_LRU_STAT_N_INTERVAL

		+ buf_LRU_stat_cur.io;

	unzip_avg = buf_LRU_stat_sum.unzip / BUF_LRU_STAT_N_INTERVAL

		+ buf_LRU_stat_cur.unzip;

	/* Decide based on our formula.  If the load is I/O bound

	(unzip_avg is smaller than the weighted io_avg), evict an

	uncompressed frame from unzip_LRU.  Otherwise we assume that

	the load is CPU bound and evict from the regular LRU. */

	return(unzip_avg <= io_avg * BUF_LRU_IO_TO_UNZIP_FACTOR);

}

/******************************************************************//**

Attempts to drop page hash index on a batch of pages belonging to a

particular space id. */

static

void

buf_LRU_drop_page_hash_batch(

/*=========================*/

	ulint		space_id,	/*!< in: space id */

	ulint		zip_size,	/*!< in: compressed page size in bytes

					or 0 for uncompressed pages */

	const ulint*	arr,		/*!< in: array of page_no */

	ulint		count)		/*!< in: number of entries in array */

{

	ulint	i;

	ut_ad(arr != NULL);

	ut_ad(count <= BUF_LRU_DROP_SEARCH_HASH_SIZE);

	for (i = 0; i < count; ++i) {

		btr_search_drop_page_hash_when_freed(space_id, zip_size,

						     arr[i]);

	}

}

/******************************************************************//**

When doing a DROP TABLE/DISCARD TABLESPACE we have to drop all page

hash index entries belonging to that table. This function tries to

do that in batch. Note that this is a 'best effort' attempt and does

not guarantee that ALL hash entries will be removed. */

static

void

buf_LRU_drop_page_hash_for_tablespace(

/*==================================*/

	buf_pool_t*	buf_pool,	/*!< in: buffer pool instance */

	ulint		id)		/*!< in: space id */

{

	buf_page_t*	bpage;

	ulint*		page_arr;

	ulint		num_entries;

	ulint		zip_size;

	zip_size = fil_space_get_zip_size(id);

	if (UNIV_UNLIKELY(zip_size == ULINT_UNDEFINED)) {

		/* Somehow, the tablespace does not exist.  Nothing to drop. */

		ut_ad(0);

		return;

	}

	page_arr = ut_malloc(

		sizeof(ulint) * BUF_LRU_DROP_SEARCH_HASH_SIZE);

	buf_pool_mutex_enter(buf_pool);

scan_again:

	num_entries = 0;

	bpage = UT_LIST_GET_LAST(buf_pool->LRU);

	while (bpage != NULL) {

		mutex_t*	block_mutex = buf_page_get_mutex(bpage);

		buf_page_t*	prev_bpage;

		mutex_enter(block_mutex);

		prev_bpage = UT_LIST_GET_PREV(LRU, bpage);

		ut_a(buf_page_in_file(bpage));

		if (buf_page_get_state(bpage) != BUF_BLOCK_FILE_PAGE

		    || bpage->space != id

		    || bpage->buf_fix_count > 0

		    || bpage->io_fix != BUF_IO_NONE) {

			/* We leave the fixed pages as is in this scan.

			To be dealt with later in the final scan. */

			mutex_exit(block_mutex);

			goto next_page;

		}

		if (((buf_block_t*) bpage)->is_hashed) {

			/* Store the offset(i.e.: page_no) in the array

			so that we can drop hash index in a batch

			later. */

			page_arr[num_entries] = bpage->offset;

			mutex_exit(block_mutex);

			ut_a(num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE);

			++num_entries;

			if (num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE) {

				goto next_page;

			}

			/* Array full. We release the buf_pool->mutex to

			obey the latching order. */

			buf_pool_mutex_exit(buf_pool);

			buf_LRU_drop_page_hash_batch(

				id, zip_size, page_arr, num_entries);

			num_entries = 0;

			buf_pool_mutex_enter(buf_pool);

		} else {

			mutex_exit(block_mutex);

		}

next_page:

		/* Note that we may have released the buf_pool mutex

		above after reading the prev_bpage during processing

		of a page_hash_batch (i.e.: when the array was full).

		This means that prev_bpage can change in LRU list.

		This is OK because this function is a 'best effort'

		to drop as many search hash entries as possible and

		it does not guarantee that ALL such entries will be

		dropped. */

		bpage = prev_bpage;

		/* If, however, bpage has been removed from LRU list

		to the free list then we should restart the scan.

		bpage->state is protected by buf_pool mutex. */

		if (bpage && !buf_page_in_file(bpage)) {

			ut_a(num_entries == 0);

			goto scan_again;

		}

	}

	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);

	ut_free(page_arr);

}

/******************************************************************//**

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_buf_pool_instance(

/*============================================*/

	buf_pool_t*	buf_pool,	/*!< buffer pool instance */

	ulint		id)		/*!< in: space id */

{

	buf_page_t*	bpage;

	ibool		all_freed;

scan_again:

	buf_pool_mutex_enter(buf_pool);

	all_freed = TRUE;

	bpage = UT_LIST_GET_LAST(buf_pool->LRU);

	while (bpage != NULL) {

		buf_page_t*	prev_bpage;

		ibool		prev_bpage_buf_fix = FALSE;

		ut_a(buf_page_in_file(bpage));

		prev_bpage = UT_LIST_GET_PREV(LRU, bpage);

		/* bpage->space and bpage->io_fix are protected by

		buf_pool->mutex and block_mutex.  It is safe to check

		them while holding buf_pool->mutex only. */

		if (buf_page_get_space(bpage) != id) {

			/* Skip this block, as it does not belong to

			the space that is being invalidated. */

		} else if (buf_page_get_io_fix(bpage) != BUF_IO_NONE) {

			/* We cannot remove this page during this scan

			yet; maybe the system is currently reading it

			in, or flushing the modifications to the file */

			all_freed = FALSE;

		} else {

			mutex_t* block_mutex = buf_page_get_mutex(bpage);

			mutex_enter(block_mutex);

			if (bpage->buf_fix_count > 0) {

				/* We cannot remove this page during

				this scan yet; maybe the system is

				currently reading it in, or flushing

				the modifications to the file */

				all_freed = FALSE;

				goto next_page;

			}

#ifdef UNIV_DEBUG

			if (buf_debug_prints) {

				fprintf(stderr,

					"Dropping space %lu page %lu\n",

					(ulong) buf_page_get_space(bpage),

					(ulong) buf_page_get_page_no(bpage));

			}

#endif

			if (buf_page_get_state(bpage) != BUF_BLOCK_FILE_PAGE) {

				/* This is a compressed-only block

				descriptor.  Ensure that prev_bpage

				cannot be relocated when bpage is freed. */

				if (UNIV_LIKELY(prev_bpage != NULL)) {

					switch (buf_page_get_state(

							prev_bpage)) {

					case BUF_BLOCK_FILE_PAGE:

						/* Descriptors of uncompressed

						blocks will not be relocated,

						because we are holding the

						buf_pool->mutex. */

						break;

					case BUF_BLOCK_ZIP_PAGE:

					case BUF_BLOCK_ZIP_DIRTY:

						/* Descriptors of compressed-

						only blocks can be relocated,

						unless they are buffer-fixed.

						Because both bpage and

						prev_bpage are protected by

						buf_pool_zip_mutex, it is

						not necessary to acquire

						further mutexes. */

						ut_ad(&buf_pool->zip_mutex

						      == block_mutex);

						ut_ad(mutex_own(block_mutex));

						prev_bpage_buf_fix = TRUE;

						prev_bpage->buf_fix_count++;

						break;

					default:

						ut_error;

					}

				}

			} else if (((buf_block_t*) bpage)->is_hashed) {

				ulint	page_no;

				ulint	zip_size;

				buf_pool_mutex_exit(buf_pool);

				zip_size = buf_page_get_zip_size(bpage);

				page_no = buf_page_get_page_no(bpage);

				mutex_exit(block_mutex);

				/* Note that the following call will acquire

				an S-latch on the page */

				btr_search_drop_page_hash_when_freed(

					id, zip_size, page_no);

				goto scan_again;

			}

			if (bpage->oldest_modification != 0) {

				buf_flush_remove(bpage);

			}

			/* Remove from the LRU list. */

			if (buf_LRU_block_remove_hashed_page(bpage, TRUE)

			    != BUF_BLOCK_ZIP_FREE) {

				buf_LRU_block_free_hashed_page((buf_block_t*)

							       bpage);

			} else {

				/* 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(!mutex_own(block_mutex));

				if (prev_bpage_buf_fix) {

					/* We temporarily buffer-fixed

					prev_bpage, so that

					buf_buddy_free() could not

					relocate it, in case it was a

					compressed-only block

					descriptor. */

					mutex_enter(block_mutex);

					ut_ad(prev_bpage->buf_fix_count > 0);

					prev_bpage->buf_fix_count--;

					mutex_exit(block_mutex);

				}

				goto next_page_no_mutex;

			}

next_page:

			mutex_exit(block_mutex);

		}

next_page_no_mutex:

		bpage = prev_bpage;

	}

	buf_pool_mutex_exit(buf_pool);

	if (!all_freed) {

		os_thread_sleep(20000);

		goto scan_again;

	}

}

/******************************************************************//**

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

void

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(buf_pool));

	ut_ad(buf_page_get_state(bpage) == BUF_BLOCK_ZIP_PAGE);

	/* Find the first successor of bpage in the LRU list

	that is in the zip_clean list. */

	b = bpage;

	do {

		b = UT_LIST_GET_NEXT(LRU, b);

	} while (b && buf_page_get_state(b) != BUF_BLOCK_ZIP_PAGE);

	/* Insert bpage before b, i.e., after the predecessor of b. */

	if (b) {

		b = UT_LIST_GET_PREV(list, b);

	}

	if (b) {

		UT_LIST_INSERT_AFTER(list, buf_pool->zip_clean, b, bpage);

	} else {

		UT_LIST_ADD_FIRST(list, buf_pool->zip_clean, bpage);

	}

}

/******************************************************************//**

Try to free an uncompressed page of a compressed block from the unzip

LRU list.  The compressed page is preserved, and it need not be clean.

@return	TRUE if freed */

UNIV_INLINE

ibool

buf_LRU_free_from_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; 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(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

	be evicting only the uncompressed frame).  In a very unlikely

	eventuality that we are unable to find a victim from

	unzip_LRU, we fall back to the regular LRU list.  We do this

	if we have done five iterations so far. */

	if (UNIV_UNLIKELY(n_iterations >= 5)

	    || !buf_LRU_evict_from_unzip_LRU(buf_pool)) {

		return(FALSE);

	}

	distance = 100 + (n_iterations

			  * UT_LIST_GET_LEN(buf_pool->unzip_LRU)) / 5;

	for (block = UT_LIST_GET_LAST(buf_pool->unzip_LRU);

	     UNIV_LIKELY(block != NULL) && UNIV_LIKELY(distance > 0);

	     block = UT_LIST_GET_PREV(unzip_LRU, block), distance--) {

		enum buf_lru_free_block_status	freed;

		ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);

		ut_ad(block->in_unzip_LRU_list);

		ut_ad(block->page.in_LRU_list);

		mutex_enter(&block->mutex);

		freed = buf_LRU_free_block(&block->page, FALSE, NULL);

		mutex_exit(&block->mutex);

		switch (freed) {

		case BUF_LRU_FREED:

			return(TRUE);

		case BUF_LRU_CANNOT_RELOCATE:

			/* If we failed to relocate, try

			regular LRU eviction. */

			return(FALSE);

		case BUF_LRU_NOT_FREED:

			/* The block was buffer-fixed or I/O-fixed.

			Keep looking. */

			continue;

		}

		/* inappropriate return value from

		buf_LRU_free_block() */

		ut_error;

	}

	return(FALSE);

}

/******************************************************************//**

Try to free a clean page from the common LRU list.

@return	TRUE if freed */

UNIV_INLINE

ibool

buf_LRU_free_from_common_LRU_list(

/*==============================*/

	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

				n_iterations / 10 * buf_pool->curr_size

				pages from the end of the LRU list */

{

	buf_page_t*	bpage;

	ulint		distance;

	ut_ad(buf_pool_mutex_own(buf_pool));

	distance = 100 + (n_iterations * buf_pool->curr_size) / 10;

	for (bpage = UT_LIST_GET_LAST(buf_pool->LRU);

	     UNIV_LIKELY(bpage != NULL) && UNIV_LIKELY(distance > 0);

	     bpage = UT_LIST_GET_PREV(LRU, bpage), distance--) {

		enum buf_lru_free_block_status	freed;

		unsigned			accessed;

		mutex_t*			block_mutex

			= buf_page_get_mutex(bpage);

		ut_ad(buf_page_in_file(bpage));

		ut_ad(bpage->in_LRU_list);

		mutex_enter(block_mutex);

		accessed = buf_page_is_accessed(bpage);

		freed = buf_LRU_free_block(bpage, TRUE, NULL);

		mutex_exit(block_mutex);

		switch (freed) {

		case BUF_LRU_FREED:

			/* Keep track of pages that are evicted without

			ever being accessed. This gives us a measure of

			the effectiveness of readahead */

			if (!accessed) {

				++buf_pool->stat.n_ra_pages_evicted;

			}

			return(TRUE);

		case BUF_LRU_NOT_FREED:

			/* The block was dirty, buffer-fixed, or I/O-fixed.

			Keep looking. */

			continue;

		case BUF_LRU_CANNOT_RELOCATE:

			/* This should never occur, because we

			want to discard the compressed page too. */

			break;

		}

		/* inappropriate return value from

		buf_LRU_free_block() */

		ut_error;

	}

	return(FALSE);

}

/******************************************************************//**

Try to free a replaceable block.

@return	TRUE if found and freed */

UNIV_INTERN

ibool

buf_LRU_search_and_free_block(

/*==========================*/

	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. */

{

	ibool	freed = FALSE;

	buf_pool_mutex_enter(buf_pool);

	freed = buf_LRU_free_from_unzip_LRU_list(buf_pool, n_iterations);

	if (!freed) {

		freed = buf_LRU_free_from_common_LRU_list(

			buf_pool, n_iterations);

	}

	if (!freed) {

		buf_pool->LRU_flush_ended = 0;

	} else if (buf_pool->LRU_flush_ended > 0) {

		buf_pool->LRU_flush_ended--;

	}

	buf_pool_mutex_exit(buf_pool);

	return(freed);

}

/******************************************************************//**

Tries to remove LRU flushed blocks from the end of the LRU list and put them

to the free list. This is beneficial for the efficiency of the insert buffer

operation, as flushed pages from non-unique non-clustered indexes are here

taken out of the buffer pool, and their inserts redirected to the insert

buffer. Otherwise, the flushed blocks could get modified again before read

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(

/*============================*/

	buf_pool_t*	buf_pool)		/*!< in: buffer pool instance */

{

	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);

		while (buf_pool->LRU_flush_ended > 0) {

			buf_pool_mutex_exit(buf_pool);

			buf_LRU_search_and_free_block(buf_pool, 1);

			buf_pool_mutex_enter(buf_pool);

		}

		buf_pool_mutex_exit(buf_pool);

	}

}

/******************************************************************//**

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)

/*==============================*/

{

	ulint	i;

	ibool	ret = FALSE;

	for (i = 0; i < srv_buf_pool_instances && !ret; i++) {

		buf_pool_t*	buf_pool;

		buf_pool = buf_pool_from_array(i);

		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) {

			ret = TRUE;

		}

		buf_pool_mutex_exit(buf_pool);

	}

	return(ret);

}

/******************************************************************//**

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(

/*==================*/

	buf_pool_t*	buf_pool)

{

	buf_block_t*	block;

	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);