mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-18 04:53:01 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

branches/zip: Implement wrappers for all operations on the buffer pool mutex.

Browse source 
buf_pool->mutex: Rename to buf_pool_mutex, so that the wrappers will have
to be used when changes are merged from other source trees.

buf_pool->zip_mutex: Rename to buf_pool_zip_mutex.

buf_pool_mutex_own(), buf_pool_mutex_enter(), buf_pool_mutex_exit():
Wrappers for buf_pool_mutex.
This commit is contained in:
marko 2008-01-10 09:37:13 +00:00
parent 4c8c6f378a
commit cdb5b46445
17 changed files with 314 additions and 293 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
btr/btr0cur.c
View file

@ -3619,7 +3619,7 @@ btr_blob_free(
mtr_commit(mtr);
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
mutex_enter(&block->mutex);
/* Only free the block if it is still allocated to
@ -3639,7 +3639,7 @@ btr_blob_free(
}
}
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
mutex_exit(&block->mutex);
}

16
btr/btr0sea.c
View file

@ -781,9 +781,9 @@ btr_search_guess_on_hash(
ulint page_no = page_get_page_no(page);
ulint space_id = page_get_space_id(page);
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
block = (buf_block_t*) buf_page_hash_get(space_id, page_no);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
}
if (UNIV_UNLIKELY(!block)
@ -1650,7 +1650,7 @@ btr_search_validate(void)
rec_offs_init(offsets_);
rw_lock_x_lock(&btr_search_latch);
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
cell_count = hash_get_n_cells(btr_search_sys->hash_index);
@ -1658,11 +1658,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)) {
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
rw_lock_x_unlock(&btr_search_latch);
os_thread_yield();
rw_lock_x_lock(&btr_search_latch);
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
}
node = hash_get_nth_cell(btr_search_sys->hash_index, i)->node;
@ -1753,11 +1753,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) {
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
rw_lock_x_unlock(&btr_search_latch);
os_thread_yield();
rw_lock_x_lock(&btr_search_latch);
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
}
if (!ha_validate(btr_search_sys->hash_index, i, end_index)) {
@ -1765,7 +1765,7 @@ btr_search_validate(void)
}
}
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
rw_lock_x_unlock(&btr_search_latch);
if (UNIV_LIKELY_NULL(heap)) {
mem_heap_free(heap);

66
buf/buf0buddy.c
View file

@ -20,24 +20,24 @@ Created December 2006 by Marko Makela
/* Statistic counters */
/** Number of frames allocated from the buffer pool to the buddy system.
Protected by buf_pool->mutex. */
Protected by buf_pool_mutex. */
ulint buf_buddy_n_frames;
/** Counts of blocks allocated from the buddy system.
Protected by buf_pool->mutex. */
Protected by buf_pool_mutex. */
ulint buf_buddy_used[BUF_BUDDY_SIZES + 1];
/** Counts of blocks relocated by the buddy system.
Protected by buf_pool->mutex. */
Protected by buf_pool_mutex. */
ib_uint64_t buf_buddy_relocated[BUF_BUDDY_SIZES + 1];
/** Preferred minimum number of frames allocated from the buffer pool
to the buddy system. Unless this number is exceeded or the buffer
pool is scarce, the LRU algorithm will not free compressed-only pages
in order to satisfy an allocation request. Protected by buf_pool->mutex. */
in order to satisfy an allocation request. Protected by buf_pool_mutex. */
ulint buf_buddy_min_n_frames = 0;
/** Preferred maximum number of frames allocated from the buffer pool
to the buddy system. Unless this number is exceeded, the buddy allocator
will not try to free clean compressed-only pages before falling back
to the LRU algorithm. Protected by buf_pool->mutex. */
to the LRU algorithm. Protected by buf_pool_mutex. */
ulint buf_buddy_max_n_frames = ULINT_UNDEFINED;
/**************************************************************************
@ -127,7 +127,7 @@ buf_buddy_alloc_zip(
{
buf_page_t* bpage;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
ut_a(i < BUF_BUDDY_SIZES);
#if defined UNIV_DEBUG && !defined UNIV_DEBUG_VALGRIND
@ -179,8 +179,8 @@ buf_buddy_block_free(
buf_page_t* bpage;
buf_block_t* block;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(!mutex_own(&buf_pool->zip_mutex));
ut_ad(buf_pool_mutex_own());
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,
@ -213,8 +213,8 @@ buf_buddy_block_register(
buf_block_t* block) /* in: buffer frame to allocate */
{
const ulint fold = BUF_POOL_ZIP_FOLD(block);
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(!mutex_own(&buf_pool->zip_mutex));
ut_ad(buf_pool_mutex_own());
ut_ad(!mutex_own(&buf_pool_zip_mutex));
buf_block_set_state(block, BUF_BLOCK_MEMORY);
@ -276,12 +276,12 @@ buf_buddy_alloc_clean(
ulint i, /* in: index of buf_pool->zip_free[] */
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 */
{
buf_page_t* bpage;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(!mutex_own(&buf_pool->zip_mutex));
ut_ad(buf_pool_mutex_own());
ut_ad(!mutex_own(&buf_pool_zip_mutex));
if (buf_buddy_n_frames < buf_buddy_max_n_frames) {
@ -301,7 +301,7 @@ buf_buddy_alloc_clean(
j = ut_min(UT_LIST_GET_LEN(buf_pool->zip_clean), 100);
bpage = UT_LIST_GET_FIRST(buf_pool->zip_clean);
mutex_enter(&buf_pool->zip_mutex);
mutex_enter(&buf_pool_zip_mutex);
for (; j--; bpage = UT_LIST_GET_NEXT(list, bpage)) {
if (bpage->zip.ssize != dummy_zip.ssize
@ -312,7 +312,7 @@ buf_buddy_alloc_clean(
/* Reuse the block. */
mutex_exit(&buf_pool->zip_mutex);
mutex_exit(&buf_pool_zip_mutex);
bpage = buf_buddy_alloc_zip(i);
/* bpage may be NULL if buf_buddy_free()
@ -320,7 +320,7 @@ buf_buddy_alloc_clean(
buf_LRU_block_remove_hashed_page()]
recombines blocks and invokes
buf_buddy_block_free(). Because
buf_pool->mutex will not be released
buf_pool_mutex will not be released
after buf_buddy_block_free(), there will
be at least one block available in the
buffer pool, and thus it does not make sense
@ -329,7 +329,7 @@ buf_buddy_alloc_clean(
return(bpage);
}
mutex_exit(&buf_pool->zip_mutex);
mutex_exit(&buf_pool_zip_mutex);
}
/* Free blocks from the end of the LRU list until enough space
@ -381,7 +381,7 @@ free_LRU:
}
/* A successful buf_LRU_free_block() may release and
reacquire buf_pool->mutex, and thus bpage->LRU of
reacquire buf_pool_mutex, and thus bpage->LRU of
an uncompressed page may point to garbage. Furthermore,
if bpage were a compressed page descriptor, it would
have been deallocated by buf_LRU_free_block().
@ -396,8 +396,8 @@ free_LRU:
/**************************************************************************
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. */
void*
buf_buddy_alloc_low(
@ -408,13 +408,13 @@ buf_buddy_alloc_low(
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 */
{
buf_block_t* block;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(!mutex_own(&buf_pool->zip_mutex));
ut_ad(buf_pool_mutex_own());
ut_ad(!mutex_own(&buf_pool_zip_mutex));
if (i < BUF_BUDDY_SIZES) {
/* Try to allocate from the buddy system. */
@ -449,10 +449,10 @@ buf_buddy_alloc_low(
}
/* Try replacing an uncompressed page in the buffer pool. */
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
block = buf_LRU_get_free_block(0);
*lru = TRUE;
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
alloc_big:
buf_buddy_block_register(block);
@ -476,7 +476,7 @@ buf_buddy_relocate_block(
{
buf_page_t* b;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
switch (buf_page_get_state(bpage)) {
case BUF_BLOCK_ZIP_FREE:
@ -494,10 +494,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);
}
@ -514,7 +514,7 @@ buf_buddy_relocate_block(
UT_LIST_ADD_FIRST(list, buf_pool->zip_clean, dpage);
}
mutex_exit(&buf_pool->zip_mutex);
mutex_exit(&buf_pool_zip_mutex);
return(TRUE);
}
@ -532,8 +532,8 @@ buf_buddy_relocate(
buf_page_t* bpage;
const ulint size = BUF_BUDDY_LOW << i;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(!mutex_own(&buf_pool->zip_mutex));
ut_ad(buf_pool_mutex_own());
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);
@ -632,8 +632,8 @@ buf_buddy_free_low(
buf_page_t* bpage;
buf_page_t* buddy;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(!mutex_own(&buf_pool->zip_mutex));
ut_ad(buf_pool_mutex_own());
ut_ad(!mutex_own(&buf_pool_zip_mutex));
ut_ad(i <= BUF_BUDDY_SIZES);
ut_ad(buf_buddy_used[i] > 0);

199
buf/buf0buf.c
View file

@ -224,6 +224,13 @@ static const int WAIT_FOR_READ = 5000;
buf_pool_t* buf_pool = NULL; /* The buffer buf_pool of the database */
/* mutex protecting the buffer pool struct and control blocks, except the
read-write lock in them */
mutex_t buf_pool_mutex;
/* mutex protecting the control blocks of compressed-only pages
(of type buf_page_t, not buf_block_t) */
mutex_t buf_pool_zip_mutex;
#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
@ -746,7 +753,7 @@ buf_chunk_contains_zip(
ulint i;
ut_ad(buf_pool);
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
block = chunk->blocks;
@ -800,7 +807,7 @@ buf_chunk_not_freed(
ulint i;
ut_ad(buf_pool);
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
block = chunk->blocks;
@ -833,7 +840,7 @@ buf_chunk_all_free(
ulint i;
ut_ad(buf_pool);
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
block = chunk->blocks;
@ -859,7 +866,7 @@ buf_chunk_free(
buf_block_t* block;
const buf_block_t* block_end;
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
block_end = chunk->blocks + chunk->size;
@ -901,11 +908,11 @@ buf_pool_init(void)
/* 1. Initialize general fields
------------------------------- */
mutex_create(&buf_pool->mutex, SYNC_BUF_POOL);
mutex_create(&buf_pool_mutex, SYNC_BUF_POOL);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
mutex_create(&buf_pool->zip_mutex, SYNC_BUF_BLOCK);
mutex_create(&buf_pool_zip_mutex, SYNC_BUF_BLOCK);
buf_pool->n_chunks = 1;
buf_pool->chunks = chunk = mem_alloc(sizeof *chunk);
@ -941,7 +948,7 @@ buf_pool_init(void)
--------------------------- */
/* All fields are initialized by mem_zalloc(). */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
btr_search_sys_create(buf_pool->curr_size
* UNIV_PAGE_SIZE / sizeof(void*) / 64);
@ -965,7 +972,7 @@ buf_relocate(
buf_page_t* b;
ulint fold;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
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);
@ -1021,11 +1028,11 @@ buf_pool_shrink(
buf_chunk_t* max_chunk;
buf_chunk_t* max_free_chunk;
ut_ad(!mutex_own(&buf_pool->mutex));
ut_ad(!buf_pool_mutex_own());
try_again:
btr_search_disable(); /* Empty the adaptive hash index again */
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
shrink_again:
if (buf_pool->n_chunks <= 1) {
@ -1088,7 +1095,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. */
@ -1104,7 +1111,7 @@ shrink_again:
mutex_exit(&block->mutex);
}
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
/* Request for a flush of the chunk if it helps.
Do not flush if there are non-free blocks, since
@ -1153,7 +1160,7 @@ shrink_again:
func_done:
srv_buf_pool_old_size = srv_buf_pool_size;
func_exit:
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
btr_search_enable();
}
@ -1171,7 +1178,7 @@ buf_pool_page_hash_rebuild(void)
hash_table_t* zip_hash;
buf_page_t* b;
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
/* Free, create, and populate the hash table. */
hash_table_free(buf_pool->page_hash);
@ -1251,7 +1258,7 @@ buf_pool_page_hash_rebuild(void)
}
}
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
}
/************************************************************************
@ -1261,17 +1268,17 @@ void
buf_pool_resize(void)
/*=================*/
{
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
if (srv_buf_pool_old_size == srv_buf_pool_size) {
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
return;
}
if (srv_buf_pool_curr_size + 1048576 > srv_buf_pool_size) {
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
/* Disable adaptive hash indexes and empty the index
in order to free up memory in the buffer pool chunks. */
@ -1305,7 +1312,7 @@ buf_pool_resize(void)
}
srv_buf_pool_old_size = srv_buf_pool_size;
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
}
buf_pool_page_hash_rebuild();
@ -1320,19 +1327,19 @@ buf_block_make_young(
/*=================*/
buf_page_t* bpage) /* in: block to make younger */
{
ut_ad(!mutex_own(&(buf_pool->mutex)));
ut_ad(!buf_pool_mutex_own());
/* Note that we read freed_page_clock's without holding any mutex:
this is allowed since the result is used only in heuristics */
if (buf_page_peek_if_too_old(bpage)) {
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
/* There has been freeing activity in the LRU list:
best to move to the head of the LRU list */
buf_LRU_make_block_young(bpage);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
}
}
@ -1346,13 +1353,13 @@ buf_page_make_young(
/*================*/
buf_page_t* bpage) /* in: buffer block of a file page */
{
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
ut_a(buf_page_in_file(bpage));
buf_LRU_make_block_young(bpage);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
}
/************************************************************************
@ -1367,7 +1374,7 @@ buf_reset_check_index_page_at_flush(
{
buf_block_t* block;
mutex_enter_fast(&(buf_pool->mutex));
buf_pool_mutex_enter();
block = (buf_block_t*) buf_page_hash_get(space, offset);
@ -1375,7 +1382,7 @@ buf_reset_check_index_page_at_flush(
block->check_index_page_at_flush = FALSE;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
}
/************************************************************************
@ -1394,7 +1401,7 @@ buf_page_peek_if_search_hashed(
buf_block_t* block;
ibool is_hashed;
mutex_enter_fast(&(buf_pool->mutex));
buf_pool_mutex_enter();
block = (buf_block_t*) buf_page_hash_get(space, offset);
@ -1404,7 +1411,7 @@ buf_page_peek_if_search_hashed(
is_hashed = block->is_hashed;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(is_hashed);
}
@ -1426,7 +1433,7 @@ buf_page_set_file_page_was_freed(
{
buf_page_t* bpage;
mutex_enter_fast(&(buf_pool->mutex));
buf_pool_mutex_enter();
bpage = buf_page_hash_get(space, offset);
@ -1434,7 +1441,7 @@ buf_page_set_file_page_was_freed(
bpage->file_page_was_freed = TRUE;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(bpage);
}
@ -1455,7 +1462,7 @@ buf_page_reset_file_page_was_freed(
{
buf_page_t* bpage;
mutex_enter_fast(&(buf_pool->mutex));
buf_pool_mutex_enter();
bpage = buf_page_hash_get(space, offset);
@ -1463,7 +1470,7 @@ buf_page_reset_file_page_was_freed(
bpage->file_page_was_freed = FALSE;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(bpage);
}
@ -1490,7 +1497,7 @@ buf_page_get_zip(
buf_pool->n_page_gets++;
for (;;) {
mutex_enter_fast(&buf_pool->mutex);
buf_pool_mutex_enter();
lookup:
bpage = buf_page_hash_get(space, offset);
if (bpage) {
@ -1499,7 +1506,7 @@ lookup:
/* Page not in buf_pool: needs to be read from file */
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
buf_read_page(space, zip_size, offset);
@ -1510,7 +1517,7 @@ lookup:
if (UNIV_UNLIKELY(!bpage->zip.data)) {
/* There is no compressed page. */
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
return(NULL);
}
@ -1544,7 +1551,7 @@ lookup:
must_read = buf_page_get_io_fix(bpage) == BUF_IO_READ;
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
buf_page_set_accessed(bpage, TRUE);
@ -1687,7 +1694,7 @@ buf_block_is_uncompressed(
const buf_chunk_t* chunk = buf_pool->chunks;
const buf_chunk_t* const echunk = chunk + buf_pool->n_chunks;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
if (UNIV_UNLIKELY((((ulint) block) % sizeof *block) != 0)) {
/* The pointer should be aligned. */
@ -1745,7 +1752,7 @@ buf_page_get_gen(
buf_pool->n_page_gets++;
loop:
block = guess;
mutex_enter_fast(&(buf_pool->mutex));
buf_pool_mutex_enter();
if (block) {
/* If the guess is a compressed page descriptor that
@ -1776,7 +1783,7 @@ loop2:
if (block == NULL) {
/* Page not in buf_pool: needs to be read from file */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
if (mode == BUF_GET_IF_IN_POOL) {
@ -1797,7 +1804,7 @@ loop2:
if (must_read && mode == BUF_GET_IF_IN_POOL) {
/* The page is only being read to buffer */
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
return(NULL);
}
@ -1821,19 +1828,19 @@ loop2:
wait_until_unfixed:
/* The block is buffer-fixed or I/O-fixed.
Try again later. */
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
os_thread_sleep(WAIT_FOR_READ);
goto loop;
}
/* Allocate an uncompressed page. */
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
block = buf_LRU_get_free_block(0);
ut_a(block);
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
mutex_enter(&block->mutex);
{
@ -1842,7 +1849,7 @@ wait_until_unfixed:
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);
@ -1858,7 +1865,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. */
@ -1871,7 +1878,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);
@ -1913,14 +1920,14 @@ wait_until_unfixed:
buf_pool->n_pend_unzip++;
rw_lock_x_lock(&block->lock);
mutex_exit(&block->mutex);
mutex_exit(&buf_pool->zip_mutex);
mutex_exit(&buf_pool_zip_mutex);
buf_buddy_free(bpage, sizeof *bpage);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
/* 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)) {
@ -1929,7 +1936,7 @@ wait_until_unfixed:
}
/* Unfix and unlatch the block. */
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
mutex_enter(&block->mutex);
buf_pool->n_pend_unzip--;
block->page.buf_fix_count--;
@ -1939,7 +1946,7 @@ wait_until_unfixed:
if (UNIV_UNLIKELY(!success)) {
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
return(NULL);
}
@ -1960,7 +1967,7 @@ wait_until_unfixed:
UNIV_MEM_ASSERT_RW(&block->page, sizeof block->page);
buf_block_buf_fix_inc(block, file, line);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
/* Check if this is the first access to the page */
@ -2271,16 +2278,16 @@ buf_page_try_get_func(
ibool success;
ulint fix_type;
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
block = buf_block_hash_get(space_id, page_no);
if (!block) {
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
return(NULL);
}
mutex_enter(&block->mutex);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
ut_a(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
@ -2396,7 +2403,7 @@ buf_page_init(
{
buf_page_t* hash_page;
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(&(block->mutex)));
ut_a(buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE);
@ -2429,7 +2436,7 @@ buf_page_init(
(const void*) hash_page, (const void*) block);
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
mutex_exit(&block->mutex);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
buf_print();
buf_LRU_print();
buf_validate();
@ -2507,7 +2514,7 @@ buf_page_init_for_read(
ut_ad(block);
}
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
if (buf_page_hash_get(space, offset)) {
/* The page is already in the buffer pool. */
@ -2519,7 +2526,7 @@ err_exit:
}
err_exit2:
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
if (mode == BUF_READ_IBUF_PAGES_ONLY) {
@ -2561,11 +2568,11 @@ err_exit2:
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. */
@ -2590,7 +2597,7 @@ err_exit2:
bpage = buf_buddy_alloc(sizeof *bpage, &lru);
/* 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)
&& UNIV_LIKELY_NULL(buf_page_hash_get(space, offset))) {
@ -2605,7 +2612,7 @@ err_exit2:
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);
buf_page_init_low(bpage);
@ -2631,11 +2638,11 @@ err_exit2:
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++;
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
if (mode == BUF_READ_IBUF_PAGES_ONLY) {
@ -2671,7 +2678,7 @@ buf_page_create(
free_block = buf_LRU_get_free_block(0);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
block = (buf_block_t*) buf_page_hash_get(space, offset);
@ -2684,7 +2691,7 @@ buf_page_create(
#endif /* UNIV_DEBUG_FILE_ACCESSES */
/* Page can be found in buf_pool */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
buf_block_free(free_block);
@ -2718,7 +2725,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);
@ -2726,10 +2733,10 @@ 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);
@ -2740,7 +2747,7 @@ buf_page_create(
rw_lock_x_unlock(&block->lock);
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
mtr_memo_push(mtr, block, MTR_MEMO_BUF_FIX);
@ -2926,7 +2933,7 @@ corrupt:
}
}
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
mutex_enter(buf_page_get_mutex(bpage));
#ifdef UNIV_IBUF_COUNT_DEBUG
@ -2981,7 +2988,7 @@ corrupt:
}
mutex_exit(buf_page_get_mutex(bpage));
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
@ -3012,11 +3019,11 @@ buf_pool_invalidate(void)
freed = buf_LRU_search_and_free_block(100);
}
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
ut_ad(UT_LIST_GET_LEN(buf_pool->LRU) == 0);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
}
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
@ -3040,7 +3047,7 @@ buf_validate(void)
ut_ad(buf_pool);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
chunk = buf_pool->chunks;
@ -3134,7 +3141,7 @@ buf_validate(void)
}
}
mutex_enter(&buf_pool->zip_mutex);
mutex_enter(&buf_pool_zip_mutex);
/* Check clean compressed-only blocks. */
@ -3211,7 +3218,7 @@ buf_validate(void)
ut_a(buf_page_hash_get(b->space, b->offset) == b);
}
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",
@ -3233,7 +3240,7 @@ 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);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
ut_a(buf_LRU_validate());
ut_a(buf_flush_validate());
@ -3267,7 +3274,7 @@ buf_print(void)
index_ids = mem_alloc(sizeof(dulint) * size);
counts = mem_alloc(sizeof(ulint) * size);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
fprintf(stderr,
"buf_pool size %lu\n"
@ -3330,7 +3337,7 @@ buf_print(void)
}
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
for (i = 0; i < n_found; i++) {
index = dict_index_get_if_in_cache(index_ids[i]);
@ -3367,7 +3374,7 @@ buf_get_latched_pages_number(void)
ulint i;
ulint fixed_pages_number = 0;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
chunk = buf_pool->chunks;
@ -3396,7 +3403,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. */
@ -3436,8 +3443,8 @@ buf_get_latched_pages_number(void)
}
}
mutex_exit(&buf_pool->zip_mutex);
mutex_exit(&(buf_pool->mutex));
mutex_exit(&buf_pool_zip_mutex);
buf_pool_mutex_exit();
return(fixed_pages_number);
}
@ -3465,7 +3472,7 @@ buf_get_modified_ratio_pct(void)
{
ulint ratio;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
ratio = (100 * UT_LIST_GET_LEN(buf_pool->flush_list))
/ (1 + UT_LIST_GET_LEN(buf_pool->LRU)
@ -3473,7 +3480,7 @@ buf_get_modified_ratio_pct(void)
/* 1 + is there to avoid division by zero */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(ratio);
}
@ -3493,7 +3500,7 @@ buf_print_io(
ut_ad(buf_pool);
size = buf_pool->curr_size;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
fprintf(file,
"Buffer pool size %lu\n"
@ -3548,7 +3555,7 @@ buf_print_io(
buf_pool->n_pages_created_old = buf_pool->n_pages_created;
buf_pool->n_pages_written_old = buf_pool->n_pages_written;
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
}
/**************************************************************************
@ -3577,7 +3584,7 @@ buf_all_freed(void)
ut_ad(buf_pool);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
chunk = buf_pool->chunks;
@ -3594,7 +3601,7 @@ buf_all_freed(void)
}
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(TRUE);
}
@ -3610,7 +3617,7 @@ buf_pool_check_no_pending_io(void)
{
ibool ret;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
if (buf_pool->n_pend_reads + buf_pool->n_flush[BUF_FLUSH_LRU]
+ buf_pool->n_flush[BUF_FLUSH_LIST]
@ -3620,7 +3627,7 @@ buf_pool_check_no_pending_io(void)
ret = TRUE;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(ret);
}
@ -3634,11 +3641,11 @@ buf_get_free_list_len(void)
{
ulint len;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
len = UT_LIST_GET_LEN(buf_pool->free);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(len);
}

56
buf/buf0flu.c
View file

@ -51,16 +51,16 @@ buf_flush_insert_into_flush_list(
/*=============================*/
buf_page_t* bpage) /* in: block which is modified */
{
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_ad((UT_LIST_GET_FIRST(buf_pool->flush_list) == NULL)
|| (UT_LIST_GET_FIRST(buf_pool->flush_list)->oldest_modification
<= bpage->oldest_modification));
switch (buf_page_get_state(bpage)) {
case BUF_BLOCK_ZIP_PAGE:
mutex_enter(&buf_pool->zip_mutex);
mutex_enter(&buf_pool_zip_mutex);
buf_page_set_state(bpage, BUF_BLOCK_ZIP_DIRTY);
mutex_exit(&buf_pool->zip_mutex);
mutex_exit(&buf_pool_zip_mutex);
UT_LIST_REMOVE(list, buf_pool->zip_clean, bpage);
/* fall through */
case BUF_BLOCK_ZIP_DIRTY:
@ -99,13 +99,13 @@ buf_flush_insert_sorted_into_flush_list(
buf_page_t* prev_b;
buf_page_t* b;
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
switch (buf_page_get_state(bpage)) {
case BUF_BLOCK_ZIP_PAGE:
mutex_enter(&buf_pool->zip_mutex);
mutex_enter(&buf_pool_zip_mutex);
buf_page_set_state(bpage, BUF_BLOCK_ZIP_DIRTY);
mutex_exit(&buf_pool->zip_mutex);
mutex_exit(&buf_pool_zip_mutex);
UT_LIST_REMOVE(list, buf_pool->zip_clean, bpage);
/* fall through */
case BUF_BLOCK_ZIP_DIRTY:
@ -157,7 +157,7 @@ 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(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(buf_page_get_mutex(bpage)));
ut_ad(bpage->in_LRU_list);
@ -190,7 +190,7 @@ buf_flush_ready_for_flush(
enum buf_flush flush_type)/* in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
{
ut_a(buf_page_in_file(bpage));
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(buf_page_get_mutex(bpage)));
if (bpage->oldest_modification != 0
@ -222,7 +222,7 @@ buf_flush_remove(
/*=============*/
buf_page_t* bpage) /* in: pointer to the block in question */
{
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(buf_page_get_mutex(bpage)));
ut_ad(bpage->in_flush_list);
ut_d(bpage->in_flush_list = FALSE);
@ -758,12 +758,12 @@ buf_flush_try_page(
ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST
|| flush_type == BUF_FLUSH_SINGLE_PAGE);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
bpage = buf_page_hash_get(space, offset);
if (!bpage) {
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(0);
}
@ -774,7 +774,7 @@ buf_flush_try_page(
if (!buf_flush_ready_for_flush(bpage, flush_type)) {
mutex_exit(block_mutex);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
return(0);
}
@ -803,7 +803,7 @@ buf_flush_try_page(
}
mutex_exit(block_mutex);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
if (!locked) {
buf_flush_buffered_writes();
@ -846,7 +846,7 @@ buf_flush_try_page(
immediately. */
mutex_exit(block_mutex);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
break;
case BUF_FLUSH_SINGLE_PAGE:
@ -862,7 +862,7 @@ buf_flush_try_page(
buf_pool->n_flush[flush_type]++;
mutex_exit(block_mutex);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
if (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE) {
rw_lock_s_lock_gen(&((buf_block_t*) bpage)->lock,
@ -922,7 +922,7 @@ buf_flush_try_neighbors(
high = fil_space_get_size(space);
}
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
for (i = low; i < high; i++) {
@ -956,7 +956,7 @@ buf_flush_try_neighbors(
flush the doublewrite buffer before we start
waiting. */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
mutex_exit(block_mutex);
@ -969,14 +969,14 @@ buf_flush_try_neighbors(
count += buf_flush_try_page(space, i,
flush_type);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
} else {
mutex_exit(block_mutex);
}
}
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(count);
}
@ -1020,14 +1020,14 @@ buf_flush_batch(
ut_ad((flush_type != BUF_FLUSH_LIST)
|| sync_thread_levels_empty_gen(TRUE));
#endif /* UNIV_SYNC_DEBUG */
mutex_enter(&(buf_pool->mutex));
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 */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(ULINT_UNDEFINED);
}
@ -1078,7 +1078,7 @@ flush_next:
space = buf_page_get_space(bpage);
offset = buf_page_get_page_no(bpage);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
mutex_exit(block_mutex);
old_page_count = page_count;
@ -1091,7 +1091,7 @@ flush_next:
flush_type, offset,
page_count - old_page_count); */
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
goto flush_next;
} else if (flush_type == BUF_FLUSH_LRU) {
@ -1124,7 +1124,7 @@ flush_next:
os_event_set(buf_pool->no_flush[flush_type]);
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
buf_flush_buffered_writes();
@ -1172,7 +1172,7 @@ buf_flush_LRU_recommendation(void)
ulint n_replaceable;
ulint distance = 0;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
n_replaceable = UT_LIST_GET_LEN(buf_pool->free);
@ -1198,7 +1198,7 @@ buf_flush_LRU_recommendation(void)
bpage = UT_LIST_GET_PREV(LRU, bpage);
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
if (n_replaceable >= BUF_FLUSH_FREE_BLOCK_MARGIN) {
@ -1275,11 +1275,11 @@ buf_flush_validate(void)
{
ibool ret;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
ret = buf_flush_validate_low();
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(ret);
}

92
buf/buf0lru.c
View file

@ -51,7 +51,7 @@ ibool buf_lru_switched_on_innodb_mon = FALSE;
/**********************************************************************
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
@ -92,7 +92,7 @@ buf_LRU_invalidate_tablespace(
ibool all_freed;
scan_again:
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
all_freed = TRUE;
@ -133,7 +133,7 @@ scan_again:
&& ((buf_block_t*) bpage)->is_hashed) {
page_no = buf_page_get_page_no(bpage);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
mutex_exit(block_mutex);
/* Note that the following call will acquire
@ -172,7 +172,7 @@ next_page:
bpage = prev_bpage;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
if (!all_freed) {
os_thread_sleep(20000);
@ -195,14 +195,14 @@ buf_LRU_get_recent_limit(void)
ulint len;
ulint limit;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
len = UT_LIST_GET_LEN(buf_pool->LRU);
if (len < BUF_LRU_OLD_MIN_LEN) {
/* The LRU list is too short to do read-ahead */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(0);
}
@ -211,7 +211,7 @@ buf_LRU_get_recent_limit(void)
limit = buf_page_get_LRU_position(bpage) - len / BUF_LRU_INITIAL_RATIO;
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(limit);
}
@ -226,7 +226,7 @@ buf_LRU_insert_zip_clean(
{
buf_page_t* b;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
ut_ad(buf_page_get_state(bpage) == BUF_BLOCK_ZIP_PAGE);
/* Find the first successor of bpage in the LRU list
@ -266,7 +266,7 @@ buf_LRU_search_and_free_block(
buf_page_t* bpage;
ibool freed;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
freed = FALSE;
bpage = UT_LIST_GET_LAST(buf_pool->LRU);
@ -355,7 +355,7 @@ func_exit:
if (!freed) {
buf_pool->LRU_flush_ended = 0;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(freed);
}
@ -373,18 +373,18 @@ void
buf_LRU_try_free_flushed_blocks(void)
/*=================================*/
{
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
while (buf_pool->LRU_flush_ended > 0) {
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
buf_LRU_search_and_free_block(1);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
}
/**********************************************************************
@ -400,7 +400,7 @@ buf_LRU_buf_pool_running_out(void)
{
ibool ret = FALSE;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
if (!recv_recovery_on && UT_LIST_GET_LEN(buf_pool->free)
+ UT_LIST_GET_LEN(buf_pool->LRU) < buf_pool->curr_size / 4) {
@ -408,7 +408,7 @@ buf_LRU_buf_pool_running_out(void)
ret = TRUE;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(ret);
}
@ -425,7 +425,7 @@ buf_LRU_get_free_only(void)
{
buf_block_t* block;
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
block = (buf_block_t*) UT_LIST_GET_FIRST(buf_pool->free);
@ -467,7 +467,7 @@ buf_LRU_get_free_block(
ibool mon_value_was = FALSE;
ibool started_monitor = FALSE;
loop:
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
if (!recv_recovery_on && UT_LIST_GET_LEN(buf_pool->free)
+ UT_LIST_GET_LEN(buf_pool->LRU) < buf_pool->curr_size / 20) {
@ -554,7 +554,7 @@ loop:
block->page.zip.data = NULL;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
if (started_monitor) {
srv_print_innodb_monitor = mon_value_was;
@ -566,7 +566,7 @@ loop:
/* If no block was in the free list, search from the end of the LRU
list and try to free a block there */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
freed = buf_LRU_search_and_free_block(n_iterations);
@ -615,18 +615,18 @@ loop:
os_aio_simulated_wake_handler_threads();
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
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. */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
buf_LRU_try_free_flushed_blocks();
} else {
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
}
if (n_iterations > 10) {
@ -651,7 +651,7 @@ buf_LRU_old_adjust_len(void)
ulint new_len;
ut_a(buf_pool->LRU_old);
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_ad(3 * (BUF_LRU_OLD_MIN_LEN / 8) > BUF_LRU_OLD_TOLERANCE + 5);
for (;;) {
@ -693,7 +693,7 @@ buf_LRU_old_init(void)
{
buf_page_t* bpage;
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
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
@ -724,7 +724,7 @@ buf_LRU_remove_block(
{
ut_ad(buf_pool);
ut_ad(bpage);
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_a(buf_page_in_file(bpage));
@ -784,7 +784,7 @@ buf_LRU_add_block_to_end_low(
ut_ad(buf_pool);
ut_ad(bpage);
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_a(buf_page_in_file(bpage));
@ -840,7 +840,7 @@ buf_LRU_add_block_low(
{
ut_ad(buf_pool);
ut_ad(bpage);
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_a(buf_page_in_file(bpage));
ut_ad(!bpage->in_LRU_list);
@ -936,19 +936,19 @@ buf_LRU_free_block(
the descriptor object will be freed
as well. If this function returns FALSE,
it will not temporarily release
buf_pool->mutex. */
buf_pool_mutex. */
buf_page_t* bpage, /* in: block to be freed */
ibool zip, /* in: TRUE if should remove also the
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;
mutex_t* block_mutex = buf_page_get_mutex(bpage);
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(block_mutex));
ut_ad(buf_page_in_file(bpage));
ut_ad(bpage->in_LRU_list);
@ -1053,7 +1053,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;
}
@ -1062,7 +1062,7 @@ alloc:
*buf_pool_mutex_released = TRUE;
}
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
mutex_exit(block_mutex);
/* Remove possible adaptive hash index on the page.
@ -1094,14 +1094,14 @@ alloc:
: BUF_NO_CHECKSUM_MAGIC);
}
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
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);
@ -1122,7 +1122,7 @@ buf_LRU_block_free_non_file_page(
{
void* data;
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(&block->mutex));
ut_ad(block);
@ -1169,7 +1169,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
@ -1190,7 +1190,7 @@ buf_LRU_block_remove_hashed_page(
{
const buf_page_t* hashed_bpage;
ut_ad(bpage);
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(buf_page_get_mutex(bpage)));
ut_a(buf_page_get_io_fix(bpage) == BUF_IO_NONE);
@ -1279,7 +1279,7 @@ buf_LRU_block_remove_hashed_page(
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
mutex_exit(buf_page_get_mutex(bpage));
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
buf_print();
buf_LRU_print();
buf_validate();
@ -1304,7 +1304,7 @@ buf_LRU_block_remove_hashed_page(
UT_LIST_REMOVE(list, buf_pool->zip_clean, bpage);
mutex_exit(&buf_pool->zip_mutex);
mutex_exit(&buf_pool_zip_mutex);
buf_buddy_free(bpage->zip.data,
page_zip_get_size(&bpage->zip));
buf_buddy_free(bpage, sizeof(*bpage));
@ -1355,7 +1355,7 @@ 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(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(&block->mutex));
buf_block_set_state(block, BUF_BLOCK_MEMORY);
@ -1377,7 +1377,7 @@ buf_LRU_validate(void)
ulint LRU_pos;
ut_ad(buf_pool);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
if (UT_LIST_GET_LEN(buf_pool->LRU) >= BUF_LRU_OLD_MIN_LEN) {
@ -1431,7 +1431,7 @@ buf_LRU_validate(void)
ut_a(buf_page_get_state(bpage) == BUF_BLOCK_NOT_USED);
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(TRUE);
}
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
@ -1447,7 +1447,7 @@ buf_LRU_print(void)
const buf_page_t* bpage;
ut_ad(buf_pool);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
fprintf(stderr, "Pool ulint clock %lu\n",
(ulong) buf_pool->ulint_clock);
@ -1510,6 +1510,6 @@ buf_LRU_print(void)
bpage = UT_LIST_GET_NEXT(LRU, bpage);
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
}
#endif /* UNIV_DEBUG_PRINT || UNIV_DEBUG || UNIV_BUF_DEBUG */

20
buf/buf0rea.c
View file

@ -222,11 +222,11 @@ buf_read_ahead_random(
LRU_recent_limit = buf_LRU_get_recent_limit();
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
if (buf_pool->n_pend_reads
> buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) {
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(0);
}
@ -245,13 +245,13 @@ buf_read_ahead_random(
if (recent_blocks >= BUF_READ_AHEAD_RANDOM_THRESHOLD) {
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
goto read_ahead;
}
}
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
/* Do nothing */
return(0);
@ -436,10 +436,10 @@ buf_read_ahead_linear(
tablespace_version = fil_space_get_version(space);
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
if (high > fil_space_get_size(space)) {
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
/* The area is not whole, return */
return(0);
@ -447,7 +447,7 @@ buf_read_ahead_linear(
if (buf_pool->n_pend_reads
> buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) {
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(0);
}
@ -487,7 +487,7 @@ buf_read_ahead_linear(
- BUF_READ_AHEAD_LINEAR_THRESHOLD) {
/* Too many failures: return */
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(0);
}
@ -498,7 +498,7 @@ buf_read_ahead_linear(
bpage = buf_page_hash_get(space, offset);
if (bpage == NULL) {
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(0);
}
@ -524,7 +524,7 @@ buf_read_ahead_linear(
pred_offset = fil_page_get_prev(frame);
succ_offset = fil_page_get_next(frame);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
if ((offset == low) && (succ_offset == offset + 1)) {

6
handler/i_s.cc
View file

@ -1064,13 +1064,13 @@ i_s_zip_fill_low(
/* Determine log2(PAGE_ZIP_MIN_SIZE / 2 / BUF_BUDDY_LOW). */
for (uint r = PAGE_ZIP_MIN_SIZE / 2 / BUF_BUDDY_LOW; r >>= 1; y++);
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
for (uint x = 0; x <= BUF_BUDDY_SIZES; x++) {
table->field[0]->store(BUF_BUDDY_LOW << x);
table->field[1]->store(buf_buddy_relocated[x]);
if (reset) {
/* This is protected by buf_pool->mutex. */
/* This is protected by buf_pool_mutex. */
buf_buddy_relocated[x] = 0;
}
@ -1103,7 +1103,7 @@ i_s_zip_fill_low(
}
}
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
DBUG_RETURN(status);
}

18
include/buf0buddy.h
View file

@ -19,13 +19,13 @@ 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 == BUF_BUDDY_USE_LRU. 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. */
UNIV_INLINE
void*
buf_buddy_alloc(
@ -35,7 +35,7 @@ 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,
and buf_pool_mutex was temporarily released,
or NULL if the LRU list should not be used */
__attribute__((malloc));
@ -51,23 +51,23 @@ buf_buddy_free(
__attribute__((nonnull));
/** Number of frames allocated from the buffer pool to the buddy system.
Protected by buf_pool->mutex. */
Protected by buf_pool_mutex. */
extern ulint buf_buddy_n_frames;
/** Preferred minimum number of frames allocated from the buffer pool
to the buddy system. Unless this number is exceeded or the buffer
pool is scarce, the LRU algorithm will not free compressed-only pages
in order to satisfy an allocation request. Protected by buf_pool->mutex. */
in order to satisfy an allocation request. Protected by buf_pool_mutex. */
extern ulint buf_buddy_min_n_frames;
/** Preferred maximum number of frames allocated from the buffer pool
to the buddy system. Unless this number is exceeded, the buddy allocator
will not try to free clean compressed-only pages before falling back
to the LRU algorithm. Protected by buf_pool->mutex. */
to the LRU algorithm. Protected by buf_pool_mutex. */
extern ulint buf_buddy_max_n_frames;
/** Counts of blocks allocated from the buddy system.
Protected by buf_pool->mutex. */
Protected by buf_pool_mutex. */
extern ulint buf_buddy_used[BUF_BUDDY_SIZES + 1];
/** Counts of blocks relocated by the buddy system.
Protected by buf_pool->mutex. */
Protected by buf_pool_mutex. */
extern ib_uint64_t buf_buddy_relocated[BUF_BUDDY_SIZES + 1];
#ifndef UNIV_NONINL

18
include/buf0buddy.ic
View file

@ -18,8 +18,8 @@ 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
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 == BUF_BUDDY_USE_LRU. */
void*
@ -31,7 +31,7 @@ buf_buddy_alloc_low(
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));
@ -68,13 +68,13 @@ 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 == BUF_BUDDY_USE_LRU. 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. */
UNIV_INLINE
void*
buf_buddy_alloc(
@ -84,10 +84,10 @@ 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,
and buf_pool_mutex was temporarily released,
or NULL if the LRU list should not be used */
{
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
return(buf_buddy_alloc_low(buf_buddy_get_slot(size), lru));
}
@ -102,7 +102,7 @@ buf_buddy_free(
pointed to by the buffer pool */
ulint size) /* in: block size, up to UNIV_PAGE_SIZE */
{
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
buf_buddy_free_low(buf, buf_buddy_get_slot(size));
}

44
include/buf0buf.h
View file

@ -947,16 +947,16 @@ for compressed and uncompressed frames */
struct buf_page_struct{
/* None of the following bit-fields must be modified without
holding buf_page_get_mutex() [block->mutex or buf_pool->zip_mutex],
holding buf_page_get_mutex() [block->mutex or buf_pool_zip_mutex],
since they can be stored in the same machine word. Some of them are
additionally protected by buf_pool->mutex. */
additionally protected by buf_pool_mutex. */
unsigned space:32; /* tablespace id */
unsigned offset:32; /* page number */
unsigned state:3; /* state of the control block
(@see enum buf_page_state); 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
@ -972,13 +972,13 @@ struct buf_page_struct{
without holding any mutex or latch */
unsigned io_fix:2; /* type of pending I/O operation
(@see enum buf_io_fix); also
protected by buf_pool->mutex */
protected by buf_pool_mutex */
unsigned buf_fix_count:24;/* count of how manyfold this block
is currently bufferfixed */
page_zip_des_t zip; /* compressed page; zip.data
(but not the data it points to) is
also protected by buf_pool->mutex */
also protected by buf_pool_mutex */
buf_page_t* hash; /* node used in chaining to
buf_pool->page_hash or
buf_pool->zip_hash */
@ -987,7 +987,7 @@ struct buf_page_struct{
ibool in_zip_hash; /* TRUE if in buf_pool->zip_hash */
#endif /* UNIV_DEBUG */
/* 2. Page flushing fields; protected by buf_pool->mutex */
/* 2. Page flushing fields; protected by buf_pool_mutex */
UT_LIST_NODE_T(buf_page_t) list;
/* based on state, this is a list
@ -1001,12 +1001,12 @@ struct buf_page_struct{
BUF_BLOCK_ZIP_FREE: zip_free[] */
#ifdef UNIV_DEBUG
ibool in_flush_list; /* TRUE if in buf_pool->flush_list;
when buf_pool->mutex is free, the
when buf_pool_mutex is free, the
following should hold: in_flush_list
== (state == BUF_BLOCK_FILE_PAGE
|| state == BUF_BLOCK_ZIP_DIRTY) */
ibool in_free_list; /* TRUE if in buf_pool->free; when
buf_pool->mutex is free, the following
buf_pool_mutex is free, the following
should hold: in_free_list
== (state == BUF_BLOCK_NOT_USED) */
#endif /* UNIV_DEBUG */
@ -1021,7 +1021,7 @@ struct buf_page_struct{
not yet been flushed on disk; zero if
all modifications are on disk */
/* 3. LRU replacement algorithm fields; protected by buf_pool->mutex */
/* 3. LRU replacement algorithm fields; protected by buf_pool_mutex */
UT_LIST_NODE_T(buf_page_t) LRU;
/* node of the LRU list */
@ -1166,12 +1166,6 @@ struct buf_pool_struct{
/* 1. General fields */
mutex_t mutex; /* mutex protecting the buffer pool
struct and control blocks, except the
read-write lock in them */
mutex_t zip_mutex; /* mutex protecting the control blocks
of compressed-only pages (of type
buf_page_t, not buf_block_t) */
ulint n_chunks; /* number of buffer pool chunks */
buf_chunk_t* chunks; /* buffer pool chunks */
ulint curr_size; /* current pool size in pages */
@ -1266,6 +1260,26 @@ struct buf_pool_struct{
#endif
};
/* mutex protecting the buffer pool struct and control blocks, except the
read-write lock in them */
extern mutex_t buf_pool_mutex;
/* mutex protecting the control blocks of compressed-only pages
(of type buf_page_t, not buf_block_t) */
extern mutex_t buf_pool_zip_mutex;
/* Accessors for buf_pool_mutex. 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)
/* Acquire the buffer pool mutex. */
#define buf_pool_mutex_enter() do { \
ut_ad(!mutex_own(&buf_pool_zip_mutex)); \
mutex_enter(&buf_pool_mutex); \
} while (0)
/* Release the buffer pool mutex. */
#define buf_pool_mutex_exit() mutex_exit(&buf_pool_mutex)
/************************************************************************
Let us list the consistency conditions for different control block states.

46
include/buf0buf.ic
View file

@ -76,7 +76,7 @@ buf_pool_get_oldest_modification(void)
buf_page_t* bpage;
ib_uint64_t lsn;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
@ -87,7 +87,7 @@ buf_pool_get_oldest_modification(void)
lsn = bpage->oldest_modification;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(lsn);
}
@ -101,7 +101,7 @@ buf_pool_clock_tic(void)
/*====================*/
/* out: new clock value */
{
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
buf_pool->ulint_clock++;
@ -265,7 +265,7 @@ buf_page_get_mutex(
break;
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);
}
@ -366,7 +366,7 @@ 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(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(buf_page_get_mutex(bpage)));
bpage->io_fix = io_fix;
@ -394,7 +394,7 @@ buf_page_can_relocate(
/*==================*/
const buf_page_t* bpage) /* control block being relocated */
{
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
ut_ad(mutex_own(buf_page_get_mutex(bpage)));
ut_ad(buf_page_in_file(bpage));
ut_ad(bpage->in_LRU_list);
@ -427,7 +427,7 @@ buf_page_set_old(
ibool old) /* in: old */
{
ut_a(buf_page_in_file(bpage));
ut_ad(mutex_own(&buf_pool->mutex));
ut_ad(buf_pool_mutex_own());
bpage->old = old;
}
@ -634,9 +634,9 @@ buf_frame_get_page_zip(
const byte* ptr) /* in: pointer to the page */
{
const page_zip_des_t* page_zip;
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
page_zip = buf_block_get_page_zip(buf_block_align(ptr));
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
return(page_zip);
}
#endif /* UNIV_DEBUG || UNIV_ZIP_DEBUG */
@ -701,7 +701,7 @@ buf_block_free(
/*===========*/
buf_block_t* block) /* in, own: block to be freed */
{
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
mutex_enter(&block->mutex);
@ -711,7 +711,7 @@ buf_block_free(
mutex_exit(&block->mutex);
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
}
/*************************************************************************
@ -757,13 +757,13 @@ buf_page_io_query(
{
ibool io_fixed;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
ut_ad(buf_page_in_file(bpage));
ut_ad(bpage->buf_fix_count > 0);
io_fixed = buf_page_get_io_fix(bpage) != BUF_IO_NONE;
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(io_fixed);
}
@ -781,7 +781,7 @@ buf_page_get_newest_modification(
{
ib_uint64_t lsn;
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
if (buf_page_in_file(bpage)) {
lsn = bpage->newest_modification;
@ -789,7 +789,7 @@ buf_page_get_newest_modification(
lsn = 0;
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
return(lsn);
}
@ -805,7 +805,7 @@ buf_block_modify_clock_inc(
buf_block_t* block) /* in: block */
{
#ifdef UNIV_SYNC_DEBUG
ut_ad((mutex_own(&(buf_pool->mutex))
ut_ad((buf_pool_mutex_own()
&& (block->page.buf_fix_count == 0))
|| rw_lock_own(&(block->lock), RW_LOCK_EXCLUSIVE));
#endif /* UNIV_SYNC_DEBUG */
@ -889,7 +889,7 @@ buf_page_hash_get(
ulint fold;
ut_ad(buf_pool);
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
/* Look for the page in the hash table */
@ -936,11 +936,11 @@ buf_page_peek(
{
const buf_page_t* bpage;
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
bpage = buf_page_hash_get(space, offset);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
return(bpage != NULL);
}
@ -961,9 +961,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;
@ -1003,9 +1003,9 @@ buf_page_release(
ut_a(block->page.buf_fix_count > 0);
if (rw_latch == RW_X_LATCH && mtr->modifications) {
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
buf_flush_note_modification(block, mtr);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
}
mutex_enter(&block->mutex);

6
include/buf0flu.ic
View file

@ -36,7 +36,7 @@ buf_flush_note_modification(
#ifdef UNIV_SYNC_DEBUG
ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
#endif /* UNIV_SYNC_DEBUG */
ut_ad(mutex_own(&(buf_pool->mutex)));
ut_ad(buf_pool_mutex_own());
ut_ad(mtr->start_lsn != 0);
ut_ad(mtr->modifications);
@ -76,7 +76,7 @@ buf_flush_recv_note_modification(
ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX));
#endif /* UNIV_SYNC_DEBUG */
mutex_enter(&(buf_pool->mutex));
buf_pool_mutex_enter();
ut_ad(block->page.newest_modification <= end_lsn);
@ -93,5 +93,5 @@ buf_flush_recv_note_modification(
ut_ad(block->page.oldest_modification <= start_lsn);
}
mutex_exit(&(buf_pool->mutex));
buf_pool_mutex_exit();
}

4
include/buf0lru.h
View file

@ -83,13 +83,13 @@ buf_LRU_free_block(
the descriptor object will be freed
as well. If this function returns FALSE,
it will not temporarily release
buf_pool->mutex. */
buf_pool_mutex. */
buf_page_t* block, /* in: block to be freed */
ibool zip, /* in: TRUE if should remove also the
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 */
/**********************************************************************
Look for a replaceable block from the end of the LRU list and put it to

4
include/mtr0log.ic
View file

@ -191,10 +191,10 @@ mlog_write_initial_log_record_fast(
#endif
#ifdef UNIV_DEBUG
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
/* We now assume that all x-latched pages have been modified! */
block = (buf_block_t*) buf_block_align(ptr);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
if (!mtr_memo_contains(mtr, block, MTR_MEMO_MODIFY)) {

4
include/row0upd.ic
View file

@ -115,9 +115,9 @@ row_upd_rec_sys_fields(
ut_ad(rec_offs_validate(rec, index, offsets));
#ifdef UNIV_SYNC_DEBUG
if (!rw_lock_own(&btr_search_latch, RW_LOCK_EX)) {
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
ut_ad(!buf_block_align(rec)->is_hashed);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
}
#endif /* UNIV_SYNC_DEBUG */

4
mtr/mtr0mtr.c
View file

@ -314,9 +314,9 @@ mtr_memo_contains_page(
{
ibool ret;
mutex_enter(&buf_pool->mutex);
buf_pool_mutex_enter();
ret = mtr_memo_contains(mtr, buf_block_align(ptr), type);
mutex_exit(&buf_pool->mutex);
buf_pool_mutex_exit();
return(ret);
}