[Maria-developers] bzr commit into MariaDB 5.1, with Maria 1.5:maria branch (knielsen:2703)

#At lp:maria 2703 knielsen@knielsen-hq.org 2009-06-10 [merge] test merging latest XtraDB. Some conflicts as expected, seems to be ok. modified: storage/xtradb/btr/btr0cur.c storage/xtradb/btr/btr0sea.c storage/xtradb/buf/buf0buddy.c storage/xtradb/buf/buf0buf.c storage/xtradb/buf/buf0flu.c storage/xtradb/buf/buf0lru.c storage/xtradb/buf/buf0rea.c storage/xtradb/handler/ha_innodb.cc storage/xtradb/handler/i_s.cc storage/xtradb/handler/innodb_patch_info.h storage/xtradb/include/buf0buddy.h storage/xtradb/include/buf0buddy.ic storage/xtradb/include/buf0buf.h storage/xtradb/include/buf0buf.ic storage/xtradb/include/buf0flu.ic storage/xtradb/include/buf0lru.h storage/xtradb/include/sync0rw.h storage/xtradb/include/sync0rw.ic storage/xtradb/include/trx0sys.h storage/xtradb/include/trx0trx.h storage/xtradb/include/univ.i storage/xtradb/include/ut0auxconf.h storage/xtradb/sync/sync0arr.c storage/xtradb/sync/sync0rw.c storage/xtradb/trx/trx0sys.c storage/xtradb/trx/trx0trx.c === modified file 'storage/xtradb/btr/btr0cur.c' --- a/storage/xtradb/btr/btr0cur.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/btr/btr0cur.c 2009-05-04 02:45:47 +0000 @@ -3733,8 +3733,7 @@ btr_blob_free( mtr_commit(mtr); - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); mutex_enter(&block->mutex); /* Only free the block if it is still allocated to @@ -3745,22 +3744,17 @@ btr_blob_free( && buf_block_get_space(block) == space && buf_block_get_page_no(block) == page_no) { - if (buf_LRU_free_block(&block->page, all, NULL, TRUE) + if (buf_LRU_free_block(&block->page, all, NULL) != BUF_LRU_FREED - && all && block->page.zip.data - /* Now, buf_LRU_free_block() may release mutex temporarily */ - && buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE - && buf_block_get_space(block) == space - && buf_block_get_page_no(block) == page_no) { + && all && block->page.zip.data) { /* Attempt to deallocate the uncompressed page if the whole block cannot be deallocted. */ - buf_LRU_free_block(&block->page, FALSE, NULL, TRUE); + buf_LRU_free_block(&block->page, FALSE, NULL); } } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); mutex_exit(&block->mutex); } === modified file 'storage/xtradb/btr/btr0sea.c' --- a/storage/xtradb/btr/btr0sea.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/btr/btr0sea.c 2009-05-04 02:45:47 +0000 @@ -1731,8 +1731,7 @@ btr_search_validate(void) rec_offs_init(offsets_); rw_lock_x_lock(&btr_search_latch); - //buf_pool_mutex_enter(); - rw_lock_x_lock(&page_hash_latch); + buf_pool_mutex_enter(); cell_count = hash_get_n_cells(btr_search_sys->hash_index); @@ -1740,13 +1739,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(); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); rw_lock_x_unlock(&btr_search_latch); os_thread_yield(); rw_lock_x_lock(&btr_search_latch); - //buf_pool_mutex_enter(); - rw_lock_x_lock(&page_hash_latch); + buf_pool_mutex_enter(); } node = hash_get_nth_cell(btr_search_sys->hash_index, i)->node; @@ -1853,13 +1850,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(); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); rw_lock_x_unlock(&btr_search_latch); os_thread_yield(); rw_lock_x_lock(&btr_search_latch); - //buf_pool_mutex_enter(); - rw_lock_x_lock(&page_hash_latch); + buf_pool_mutex_enter(); } if (!ha_validate(btr_search_sys->hash_index, i, end_index)) { @@ -1867,8 +1862,7 @@ btr_search_validate(void) } } - //buf_pool_mutex_exit(); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); rw_lock_x_unlock(&btr_search_latch); if (UNIV_LIKELY_NULL(heap)) { mem_heap_free(heap); === modified file 'storage/xtradb/buf/buf0buddy.c' --- a/storage/xtradb/buf/buf0buddy.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/buf/buf0buddy.c 2009-05-04 04:32:30 +0000 @@ -131,8 +131,7 @@ buf_buddy_alloc_zip( { buf_page_t* bpage; - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&zip_free_mutex)); + ut_ad(buf_pool_mutex_own()); ut_a(i < BUF_BUDDY_SIZES); #if defined UNIV_DEBUG && !defined UNIV_DEBUG_VALGRIND @@ -178,19 +177,16 @@ static void buf_buddy_block_free( /*=================*/ - void* buf, /* in: buffer frame to deallocate */ - ibool have_page_hash_mutex) + 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(buf_pool_mutex_own()); ut_ad(!mutex_own(&buf_pool_zip_mutex)); ut_a(!ut_align_offset(buf, UNIV_PAGE_SIZE)); - mutex_enter(&zip_hash_mutex); - HASH_SEARCH(hash, buf_pool->zip_hash, fold, buf_page_t*, bpage, ut_ad(buf_page_get_state(bpage) == BUF_BLOCK_MEMORY && bpage->in_zip_hash && !bpage->in_page_hash), @@ -202,14 +198,12 @@ buf_buddy_block_free( ut_d(bpage->in_zip_hash = FALSE); HASH_DELETE(buf_page_t, hash, buf_pool->zip_hash, fold, bpage); - mutex_exit(&zip_hash_mutex); - ut_d(memset(buf, 0, UNIV_PAGE_SIZE)); UNIV_MEM_INVALID(buf, UNIV_PAGE_SIZE); block = (buf_block_t*) bpage; mutex_enter(&block->mutex); - buf_LRU_block_free_non_file_page(block, have_page_hash_mutex); + buf_LRU_block_free_non_file_page(block); mutex_exit(&block->mutex); ut_ad(buf_buddy_n_frames > 0); @@ -225,7 +219,7 @@ buf_buddy_block_register( buf_block_t* block) /* in: buffer frame to allocate */ { const ulint fold = BUF_POOL_ZIP_FOLD(block); - //ut_ad(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); ut_ad(!mutex_own(&buf_pool_zip_mutex)); buf_block_set_state(block, BUF_BLOCK_MEMORY); @@ -236,10 +230,7 @@ buf_buddy_block_register( ut_ad(!block->page.in_page_hash); ut_ad(!block->page.in_zip_hash); ut_d(block->page.in_zip_hash = TRUE); - - mutex_enter(&zip_hash_mutex); HASH_INSERT(buf_page_t, hash, buf_pool->zip_hash, fold, &block->page); - mutex_exit(&zip_hash_mutex); ut_d(buf_buddy_n_frames++); } @@ -293,28 +284,24 @@ buf_buddy_alloc_low( possibly NULL if lru==NULL */ ulint i, /* in: index of buf_pool->zip_free[], or BUF_BUDDY_SIZES */ - ibool* lru, /* in: pointer to a variable that will be assigned + 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 */ - ibool have_page_hash_mutex) { buf_block_t* block; - //ut_ad(buf_pool_mutex_own()); + 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. */ - mutex_enter(&zip_free_mutex); block = buf_buddy_alloc_zip(i); if (block) { goto func_exit; } - - mutex_exit(&zip_free_mutex); } /* Try allocating from the buf_pool->free list. */ @@ -331,31 +318,18 @@ buf_buddy_alloc_low( } /* Try replacing an uncompressed page in the buffer pool. */ - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); - if (have_page_hash_mutex) { - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - } + buf_pool_mutex_exit(); block = buf_LRU_get_free_block(0); *lru = TRUE; - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - if (have_page_hash_mutex) { - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); - } + buf_pool_mutex_enter(); alloc_big: buf_buddy_block_register(block); - mutex_enter(&zip_free_mutex); block = buf_buddy_alloc_from(block->frame, i, BUF_BUDDY_SIZES); func_exit: buf_buddy_stat[i].used++; - mutex_exit(&zip_free_mutex); - return(block); } @@ -371,8 +345,7 @@ buf_buddy_relocate_block( { buf_page_t* b; - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&flush_list_mutex)); + ut_ad(buf_pool_mutex_own()); switch (buf_page_get_state(bpage)) { case BUF_BLOCK_ZIP_FREE: @@ -381,7 +354,7 @@ buf_buddy_relocate_block( case BUF_BLOCK_FILE_PAGE: case BUF_BLOCK_MEMORY: case BUF_BLOCK_REMOVE_HASH: - /* ut_error; */ /* optimistic */ + ut_error; case BUF_BLOCK_ZIP_DIRTY: /* Cannot relocate dirty pages. */ return(FALSE); @@ -391,17 +364,9 @@ buf_buddy_relocate_block( } mutex_enter(&buf_pool_zip_mutex); - mutex_enter(&zip_free_mutex); if (!buf_page_can_relocate(bpage)) { mutex_exit(&buf_pool_zip_mutex); - mutex_exit(&zip_free_mutex); - return(FALSE); - } - - if (bpage != buf_page_hash_get(bpage->space, bpage->offset)) { - mutex_exit(&buf_pool_zip_mutex); - mutex_exit(&zip_free_mutex); return(FALSE); } @@ -419,7 +384,6 @@ buf_buddy_relocate_block( } mutex_exit(&buf_pool_zip_mutex); - mutex_exit(&zip_free_mutex); return(TRUE); } @@ -432,15 +396,13 @@ buf_buddy_relocate( /* out: TRUE if relocated */ void* src, /* in: block to relocate */ void* dst, /* in: free block to relocate to */ - ulint i, /* in: index of buf_pool->zip_free[] */ - ibool have_page_hash_mutex) + 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(&zip_free_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)); @@ -459,17 +421,9 @@ buf_buddy_relocate( actually is a properly initialized buf_page_t object. */ if (size >= PAGE_ZIP_MIN_SIZE) { - if (!have_page_hash_mutex) - mutex_exit(&zip_free_mutex); - /* This is a compressed page. */ mutex_t* mutex; - if (!have_page_hash_mutex) { - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); - } /* The src block may be split into smaller blocks, some of which may be free. Thus, the mach_read_from_4() calls below may attempt to read @@ -490,12 +444,6 @@ buf_buddy_relocate( added to buf_pool->page_hash yet. Obviously, it cannot be relocated. */ - if (!have_page_hash_mutex) { - mutex_enter(&zip_free_mutex); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - } return(FALSE); } @@ -505,19 +453,9 @@ buf_buddy_relocate( For the sake of simplicity, give up. */ ut_ad(page_zip_get_size(&bpage->zip) < size); - if (!have_page_hash_mutex) { - mutex_enter(&zip_free_mutex); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - } return(FALSE); } - /* To keep latch order */ - if (have_page_hash_mutex) - mutex_exit(&zip_free_mutex); - /* The block must have been allocated, but it may contain uninitialized data. */ UNIV_MEM_ASSERT_W(src, size); @@ -525,7 +463,6 @@ buf_buddy_relocate( mutex = buf_page_get_mutex(bpage); mutex_enter(mutex); - mutex_enter(&zip_free_mutex); if (buf_page_can_relocate(bpage)) { /* Relocate the compressed page. */ @@ -542,53 +479,17 @@ success: buddy_stat->relocated_usec += ut_time_us(NULL) - usec; } - - if (!have_page_hash_mutex) { - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - } return(TRUE); } - if (!have_page_hash_mutex) { - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - } - mutex_exit(mutex); } else if (i == buf_buddy_get_slot(sizeof(buf_page_t))) { /* This must be a buf_page_t object. */ UNIV_MEM_ASSERT_RW(src, size); - - mutex_exit(&zip_free_mutex); - - if (!have_page_hash_mutex) { - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); - } - if (buf_buddy_relocate_block(src, dst)) { - mutex_enter(&zip_free_mutex); - - if (!have_page_hash_mutex) { - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - } goto success; } - - mutex_enter(&zip_free_mutex); - - if (!have_page_hash_mutex) { - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - } } return(FALSE); @@ -602,14 +503,12 @@ 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[] */ - ibool have_page_hash_mutex) + ulint i) /* in: index of buf_pool->zip_free[] */ { buf_page_t* bpage; buf_page_t* buddy; - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&zip_free_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_stat[i].used > 0); @@ -620,7 +519,7 @@ recombine: ut_d(((buf_page_t*) buf)->state = BUF_BLOCK_ZIP_FREE); if (i == BUF_BUDDY_SIZES) { - buf_buddy_block_free(buf, have_page_hash_mutex); + buf_buddy_block_free(buf); return; } @@ -678,7 +577,7 @@ buddy_nonfree: #endif /* UNIV_DEBUG_VALGRIND */ /* The buddy is not free. Is there a free block of this size? */ - bpage = UT_LIST_GET_LAST(buf_pool->zip_free[i]); + bpage = UT_LIST_GET_FIRST(buf_pool->zip_free[i]); if (bpage) { /* Remove the block from the free list, because a successful @@ -688,7 +587,7 @@ buddy_nonfree: buf_buddy_remove_from_free(bpage, i); /* Try to relocate the buddy of buf to the free block. */ - if (buf_buddy_relocate(buddy, bpage, i, have_page_hash_mutex)) { + if (buf_buddy_relocate(buddy, bpage, i)) { ut_d(buddy->state = BUF_BLOCK_ZIP_FREE); goto buddy_free2; @@ -716,7 +615,7 @@ buddy_nonfree: } #endif /* UNIV_DEBUG && !UNIV_DEBUG_VALGRIND */ - if (buf_buddy_relocate(buddy, buf, i, have_page_hash_mutex)) { + if (buf_buddy_relocate(buddy, buf, i)) { buf = bpage; UNIV_MEM_VALID(bpage, BUF_BUDDY_LOW << i); === modified file 'storage/xtradb/buf/buf0buf.c' --- a/storage/xtradb/buf/buf0buf.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/buf/buf0buf.c 2009-05-04 04:32:30 +0000 @@ -244,12 +244,6 @@ 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; -UNIV_INTERN mutex_t LRU_list_mutex; -UNIV_INTERN mutex_t flush_list_mutex; -UNIV_INTERN rw_lock_t page_hash_latch; -UNIV_INTERN mutex_t free_list_mutex; -UNIV_INTERN mutex_t zip_free_mutex; -UNIV_INTERN mutex_t zip_hash_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; @@ -670,9 +664,9 @@ buf_block_init( block->page.in_zip_hash = FALSE; block->page.in_flush_list = FALSE; block->page.in_free_list = FALSE; + block->in_unzip_LRU_list = FALSE; #endif /* UNIV_DEBUG */ block->page.in_LRU_list = FALSE; - block->in_unzip_LRU_list = FALSE; #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG block->n_pointers = 0; #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */ @@ -757,10 +751,8 @@ buf_chunk_init( memset(block->frame, '\0', UNIV_PAGE_SIZE); #endif /* Add the block to the free list */ - mutex_enter(&free_list_mutex); UT_LIST_ADD_LAST(list, buf_pool->free, (&block->page)); ut_d(block->page.in_free_list = TRUE); - mutex_exit(&free_list_mutex); block++; frame += UNIV_PAGE_SIZE; @@ -786,7 +778,7 @@ buf_chunk_contains_zip( ulint i; ut_ad(buf_pool); - //ut_ad(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); block = chunk->blocks; @@ -840,7 +832,7 @@ buf_chunk_not_freed( ulint i; ut_ad(buf_pool); - //ut_ad(buf_pool_mutex_own()); /*optimistic...*/ + ut_ad(buf_pool_mutex_own()); block = chunk->blocks; @@ -873,7 +865,7 @@ buf_chunk_all_free( ulint i; ut_ad(buf_pool); - ut_ad(buf_pool_mutex_own()); /* but we need all mutex here */ + ut_ad(buf_pool_mutex_own()); block = chunk->blocks; @@ -899,7 +891,7 @@ buf_chunk_free( buf_block_t* block; const buf_block_t* block_end; - ut_ad(buf_pool_mutex_own()); /* but we need all mutex here */ + ut_ad(buf_pool_mutex_own()); block_end = chunk->blocks + chunk->size; @@ -911,10 +903,8 @@ buf_chunk_free( ut_ad(!block->in_unzip_LRU_list); ut_ad(!block->page.in_flush_list); /* Remove the block from the free list. */ - mutex_enter(&free_list_mutex); ut_ad(block->page.in_free_list); UT_LIST_REMOVE(list, buf_pool->free, (&block->page)); - mutex_exit(&free_list_mutex); /* Free the latches. */ mutex_free(&block->mutex); @@ -945,18 +935,8 @@ buf_pool_init(void) /* 1. Initialize general fields ------------------------------- */ mutex_create(&buf_pool_mutex, SYNC_BUF_POOL); - mutex_create(&LRU_list_mutex, SYNC_NO_ORDER_CHECK); - mutex_create(&flush_list_mutex, SYNC_NO_ORDER_CHECK); - rw_lock_create(&page_hash_latch, SYNC_NO_ORDER_CHECK); - mutex_create(&free_list_mutex, SYNC_NO_ORDER_CHECK); - mutex_create(&zip_free_mutex, SYNC_NO_ORDER_CHECK); - mutex_create(&zip_hash_mutex, SYNC_NO_ORDER_CHECK); - mutex_create(&buf_pool_zip_mutex, SYNC_BUF_BLOCK); - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); buf_pool_mutex_enter(); buf_pool->n_chunks = 1; @@ -993,9 +973,6 @@ buf_pool_init(void) --------------------------- */ /* All fields are initialized by mem_zalloc(). */ - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); buf_pool_mutex_exit(); btr_search_sys_create(buf_pool->curr_size @@ -1128,11 +1105,7 @@ buf_relocate( buf_page_t* b; ulint fold; - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); -#ifdef UNIV_SYNC_DEBUG - ut_ad(rw_lock_own(&page_hash_latch, RW_LOCK_EX)); -#endif + 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); @@ -1213,8 +1186,7 @@ buf_pool_shrink( try_again: btr_search_disable(); /* Empty the adaptive hash index again */ - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); shrink_again: if (buf_pool->n_chunks <= 1) { @@ -1285,7 +1257,7 @@ shrink_again: buf_LRU_make_block_old(&block->page); dirty++; - } else if (buf_LRU_free_block(&block->page, TRUE, NULL, FALSE) + } else if (buf_LRU_free_block(&block->page, TRUE, NULL) != BUF_LRU_FREED) { nonfree++; } @@ -1293,8 +1265,7 @@ shrink_again: mutex_exit(&block->mutex); } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_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 @@ -1343,8 +1314,7 @@ shrink_again: func_done: srv_buf_pool_old_size = srv_buf_pool_size; func_exit: - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); btr_search_enable(); } @@ -1362,11 +1332,7 @@ buf_pool_page_hash_rebuild(void) hash_table_t* zip_hash; buf_page_t* b; - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); - + buf_pool_mutex_enter(); /* Free, create, and populate the hash table. */ hash_table_free(buf_pool->page_hash); @@ -1446,10 +1412,7 @@ buf_pool_page_hash_rebuild(void) } } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); } /************************************************************************ @@ -1459,20 +1422,17 @@ void buf_pool_resize(void) /*=================*/ { - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); if (srv_buf_pool_old_size == srv_buf_pool_size) { - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); return; } if (srv_buf_pool_curr_size + 1048576 > srv_buf_pool_size) { - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); /* Disable adaptive hash indexes and empty the index in order to free up memory in the buffer pool chunks. */ @@ -1506,8 +1466,7 @@ buf_pool_resize(void) } srv_buf_pool_old_size = srv_buf_pool_size; - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); } buf_pool_page_hash_rebuild(); @@ -1529,14 +1488,12 @@ buf_block_make_young( if (buf_page_peek_if_too_old(bpage)) { - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_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); - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); } } @@ -1550,15 +1507,13 @@ buf_page_make_young( /*================*/ buf_page_t* bpage) /* in: buffer block of a file page */ { - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); ut_a(buf_page_in_file(bpage)); buf_LRU_make_block_young(bpage); - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); } /************************************************************************ @@ -1573,8 +1528,7 @@ buf_reset_check_index_page_at_flush( { buf_block_t* block; - //buf_pool_mutex_enter(); - rw_lock_s_lock(&page_hash_latch); + buf_pool_mutex_enter(); block = (buf_block_t*) buf_page_hash_get(space, offset); @@ -1582,8 +1536,7 @@ buf_reset_check_index_page_at_flush( block->check_index_page_at_flush = FALSE; } - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); } /************************************************************************ @@ -1602,8 +1555,7 @@ buf_page_peek_if_search_hashed( buf_block_t* block; ibool is_hashed; - //buf_pool_mutex_enter(); - rw_lock_s_lock(&page_hash_latch); + buf_pool_mutex_enter(); block = (buf_block_t*) buf_page_hash_get(space, offset); @@ -1613,8 +1565,7 @@ buf_page_peek_if_search_hashed( is_hashed = block->is_hashed; } - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); return(is_hashed); } @@ -1636,8 +1587,7 @@ buf_page_set_file_page_was_freed( { buf_page_t* bpage; - //buf_pool_mutex_enter(); - rw_lock_s_lock(&page_hash_latch); + buf_pool_mutex_enter(); bpage = buf_page_hash_get(space, offset); @@ -1645,8 +1595,7 @@ buf_page_set_file_page_was_freed( bpage->file_page_was_freed = TRUE; } - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); return(bpage); } @@ -1667,8 +1616,7 @@ buf_page_reset_file_page_was_freed( { buf_page_t* bpage; - //buf_pool_mutex_enter(); - rw_lock_s_lock(&page_hash_latch); + buf_pool_mutex_enter(); bpage = buf_page_hash_get(space, offset); @@ -1676,8 +1624,7 @@ buf_page_reset_file_page_was_freed( bpage->file_page_was_freed = FALSE; } - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); return(bpage); } @@ -1710,9 +1657,8 @@ buf_page_get_zip( buf_pool->n_page_gets++; for (;;) { - //buf_pool_mutex_enter(); + buf_pool_mutex_enter(); lookup: - rw_lock_s_lock(&page_hash_latch); bpage = buf_page_hash_get(space, offset); if (bpage) { break; @@ -1720,8 +1666,7 @@ lookup: /* Page not in buf_pool: needs to be read from file */ - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); buf_read_page(space, zip_size, offset); @@ -1732,16 +1677,13 @@ lookup: if (UNIV_UNLIKELY(!bpage->zip.data)) { /* There is no compressed page. */ - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); return(NULL); } block_mutex = buf_page_get_mutex(bpage); mutex_enter(block_mutex); - rw_lock_s_unlock(&page_hash_latch); - switch (buf_page_get_state(bpage)) { case BUF_BLOCK_NOT_USED: case BUF_BLOCK_READY_FOR_USE: @@ -1756,7 +1698,7 @@ lookup: break; case BUF_BLOCK_FILE_PAGE: /* Discard the uncompressed page frame if possible. */ - if (buf_LRU_free_block(bpage, FALSE, NULL, FALSE) + if (buf_LRU_free_block(bpage, FALSE, NULL) == BUF_LRU_FREED) { mutex_exit(block_mutex); @@ -1770,7 +1712,7 @@ lookup: must_read = buf_page_get_io_fix(bpage) == BUF_IO_READ; - //buf_pool_mutex_exit(); + buf_pool_mutex_exit(); buf_page_set_accessed(bpage, TRUE); @@ -2001,7 +1943,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(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); if (UNIV_UNLIKELY((((ulint) block) % sizeof *block) != 0)) { /* The pointer should be aligned. */ @@ -2044,7 +1986,6 @@ buf_page_get_gen( ibool accessed; ulint fix_type; ibool must_read; - mutex_t* block_mutex; ut_ad(mtr); ut_ad((rw_latch == RW_S_LATCH) @@ -2060,12 +2001,9 @@ buf_page_get_gen( buf_pool->n_page_gets++; loop: block = guess; - //buf_pool_mutex_enter(); + buf_pool_mutex_enter(); if (block) { - block_mutex = buf_page_get_mutex((buf_page_t*)block); - mutex_enter(block_mutex); - /* If the guess is a compressed page descriptor that has been allocated by buf_buddy_alloc(), it may have been invalidated by buf_buddy_relocate(). In that @@ -2079,8 +2017,6 @@ loop: || space != block->page.space || buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE) { - mutex_exit(block_mutex); - block = guess = NULL; } else { ut_ad(!block->page.in_zip_hash); @@ -2089,20 +2025,14 @@ loop: } if (block == NULL) { - rw_lock_s_lock(&page_hash_latch); block = (buf_block_t*) buf_page_hash_get(space, offset); - if (block) { - block_mutex = buf_page_get_mutex((buf_page_t*)block); - mutex_enter(block_mutex); - } - rw_lock_s_unlock(&page_hash_latch); } loop2: if (block == NULL) { /* Page not in buf_pool: needs to be read from file */ - //buf_pool_mutex_exit(); + buf_pool_mutex_exit(); if (mode == BUF_GET_IF_IN_POOL) { @@ -2123,8 +2053,7 @@ loop2: if (must_read && mode == BUF_GET_IF_IN_POOL) { /* The page is only being read to buffer */ - //buf_pool_mutex_exit(); - mutex_exit(block_mutex); + buf_pool_mutex_exit(); return(NULL); } @@ -2134,16 +2063,10 @@ loop2: ibool success; case BUF_BLOCK_FILE_PAGE: - if (block_mutex == &buf_pool_zip_mutex) { - /* it is wrong mutex... */ - mutex_exit(block_mutex); - goto loop; - } break; case BUF_BLOCK_ZIP_PAGE: case BUF_BLOCK_ZIP_DIRTY: - ut_ad(block_mutex == &buf_pool_zip_mutex); bpage = &block->page; if (bpage->buf_fix_count @@ -2154,26 +2077,20 @@ loop2: wait_until_unfixed: /* The block is buffer-fixed or I/O-fixed. Try again later. */ - //buf_pool_mutex_exit(); - mutex_exit(block_mutex); + buf_pool_mutex_exit(); os_thread_sleep(WAIT_FOR_READ); goto loop; } /* Allocate an uncompressed page. */ - //buf_pool_mutex_exit(); - mutex_exit(block_mutex); + buf_pool_mutex_exit(); block = buf_LRU_get_free_block(0); ut_a(block); - block_mutex = &block->mutex; - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); - mutex_enter(block_mutex); + buf_pool_mutex_enter(); + mutex_enter(&block->mutex); { buf_page_t* hash_bpage @@ -2184,17 +2101,10 @@ wait_until_unfixed: while buf_pool_mutex was released. Free the block that was allocated. */ - buf_LRU_block_free_non_file_page(block, TRUE); - mutex_exit(block_mutex); + buf_LRU_block_free_non_file_page(block); + mutex_exit(&block->mutex); block = (buf_block_t*) hash_bpage; - if (block) { - block_mutex = buf_page_get_mutex((buf_page_t*)block); - mutex_enter(block_mutex); - } - rw_lock_x_unlock(&page_hash_latch); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); goto loop2; } } @@ -2208,12 +2118,9 @@ wait_until_unfixed: Free the block that was allocated and try again. This should be extremely unlikely. */ - buf_LRU_block_free_non_file_page(block, TRUE); - //mutex_exit(&block->mutex); + buf_LRU_block_free_non_file_page(block); + mutex_exit(&block->mutex); - rw_lock_x_unlock(&page_hash_latch); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); goto wait_until_unfixed; } @@ -2223,9 +2130,6 @@ wait_until_unfixed: mutex_enter(&buf_pool_zip_mutex); buf_relocate(bpage, &block->page); - - rw_lock_x_unlock(&page_hash_latch); - buf_block_init_low(block); block->lock_hash_val = lock_rec_hash(space, offset); @@ -2257,8 +2161,6 @@ wait_until_unfixed: } } - mutex_exit(&flush_list_mutex); - /* Buffer-fix, I/O-fix, and X-latch the block for the duration of the decompression. Also add the block to the unzip_LRU list. */ @@ -2267,22 +2169,16 @@ wait_until_unfixed: /* Insert at the front of unzip_LRU list */ buf_unzip_LRU_add_block(block, FALSE); - mutex_exit(&LRU_list_mutex); - block->page.buf_fix_count = 1; buf_block_set_io_fix(block, BUF_IO_READ); - - mutex_enter(&buf_pool_mutex); buf_pool->n_pend_unzip++; - mutex_exit(&buf_pool_mutex); - rw_lock_x_lock(&block->lock); - mutex_exit(block_mutex); + mutex_exit(&block->mutex); mutex_exit(&buf_pool_zip_mutex); - buf_buddy_free(bpage, sizeof *bpage, FALSE); + buf_buddy_free(bpage, sizeof *bpage); - //buf_pool_mutex_exit(); + buf_pool_mutex_exit(); /* Decompress the page and apply buffered operations while not holding buf_pool_mutex or block->mutex. */ @@ -2294,21 +2190,17 @@ wait_until_unfixed: } /* Unfix and unlatch the block. */ - //buf_pool_mutex_enter(); - block_mutex = &block->mutex; - mutex_enter(block_mutex); - mutex_enter(&buf_pool_mutex); + buf_pool_mutex_enter(); + mutex_enter(&block->mutex); buf_pool->n_pend_unzip--; - mutex_exit(&buf_pool_mutex); block->page.buf_fix_count--; buf_block_set_io_fix(block, BUF_IO_NONE); - //mutex_exit(&block->mutex); + mutex_exit(&block->mutex); rw_lock_x_unlock(&block->lock); if (UNIV_UNLIKELY(!success)) { - //buf_pool_mutex_exit(); - mutex_exit(block_mutex); + buf_pool_mutex_exit(); return(NULL); } @@ -2325,11 +2217,11 @@ wait_until_unfixed: ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE); - //mutex_enter(&block->mutex); + mutex_enter(&block->mutex); UNIV_MEM_ASSERT_RW(&block->page, sizeof block->page); buf_block_buf_fix_inc(block, file, line); - //buf_pool_mutex_exit(); + buf_pool_mutex_exit(); /* Check if this is the first access to the page */ @@ -2337,7 +2229,7 @@ wait_until_unfixed: buf_page_set_accessed(&block->page, TRUE); - mutex_exit(block_mutex); + mutex_exit(&block->mutex); buf_block_make_young(&block->page); @@ -2623,19 +2515,16 @@ buf_page_try_get_func( ibool success; ulint fix_type; - //buf_pool_mutex_enter(); - rw_lock_s_lock(&page_hash_latch); + buf_pool_mutex_enter(); block = buf_block_hash_get(space_id, page_no); if (!block) { - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); return(NULL); } mutex_enter(&block->mutex); - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG ut_a(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE); @@ -2755,10 +2644,7 @@ buf_page_init( { buf_page_t* hash_page; - //ut_ad(buf_pool_mutex_own()); -#ifdef UNIV_SYNC_DEBUG - ut_ad(rw_lock_own(&page_hash_latch, RW_LOCK_EX)); -#endif + ut_ad(buf_pool_mutex_own()); ut_ad(mutex_own(&(block->mutex))); ut_a(buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE); @@ -2791,8 +2677,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(); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); buf_print(); buf_LRU_print(); buf_validate(); @@ -2871,28 +2756,16 @@ buf_page_init_for_read( ut_ad(block); } - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - if(!block) { - mutex_enter(&flush_list_mutex); - } - rw_lock_x_lock(&page_hash_latch); + buf_pool_mutex_enter(); if (buf_page_hash_get(space, offset)) { /* The page is already in the buffer pool. */ err_exit: if (block) { mutex_enter(&block->mutex); - mutex_exit(&LRU_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - buf_LRU_block_free_non_file_page(block, FALSE); + buf_LRU_block_free_non_file_page(block); mutex_exit(&block->mutex); } - else { - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - } bpage = NULL; goto func_exit; @@ -2912,8 +2785,6 @@ err_exit: mutex_enter(&block->mutex); buf_page_init(space, offset, block); - rw_lock_x_unlock(&page_hash_latch); - /* The block must be put to the LRU list, to the old blocks */ buf_LRU_add_block(bpage, TRUE/* to old blocks */); @@ -2941,7 +2812,7 @@ err_exit: been added to buf_pool->LRU and buf_pool->page_hash. */ mutex_exit(&block->mutex); - data = buf_buddy_alloc(zip_size, &lru, FALSE); + data = buf_buddy_alloc(zip_size, &lru); mutex_enter(&block->mutex); block->page.zip.data = data; @@ -2954,7 +2825,6 @@ err_exit: buf_unzip_LRU_add_block(block, TRUE); } - mutex_exit(&LRU_list_mutex); mutex_exit(&block->mutex); } else { /* Defer buf_buddy_alloc() until after the block has @@ -2966,8 +2836,8 @@ 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, TRUE); - bpage = buf_buddy_alloc(sizeof *bpage, &lru, TRUE); + data = buf_buddy_alloc(zip_size, &lru); + 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 @@ -2976,12 +2846,8 @@ err_exit: && UNIV_LIKELY_NULL(buf_page_hash_get(space, offset))) { /* The block was added by some other thread. */ - buf_buddy_free(bpage, sizeof *bpage, TRUE); - buf_buddy_free(data, zip_size, TRUE); - - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); + buf_buddy_free(bpage, sizeof *bpage); + buf_buddy_free(data, zip_size); bpage = NULL; goto func_exit; @@ -3011,25 +2877,18 @@ err_exit: HASH_INSERT(buf_page_t, hash, buf_pool->page_hash, buf_page_address_fold(space, offset), bpage); - rw_lock_x_unlock(&page_hash_latch); - /* The block must be put to the LRU list, to the old blocks */ buf_LRU_add_block(bpage, TRUE/* to old blocks */); buf_LRU_insert_zip_clean(bpage); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - buf_page_set_io_fix(bpage, BUF_IO_READ); mutex_exit(&buf_pool_zip_mutex); } - mutex_enter(&buf_pool_mutex); buf_pool->n_pend_reads++; - mutex_exit(&buf_pool_mutex); func_exit: - //buf_pool_mutex_exit(); + buf_pool_mutex_exit(); if (mode == BUF_READ_IBUF_PAGES_ONLY) { @@ -3065,9 +2924,7 @@ buf_page_create( free_block = buf_LRU_get_free_block(0); - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - rw_lock_x_lock(&page_hash_latch); + buf_pool_mutex_enter(); block = (buf_block_t*) buf_page_hash_get(space, offset); @@ -3080,9 +2937,7 @@ buf_page_create( #endif /* UNIV_DEBUG_FILE_ACCESSES */ /* Page can be found in buf_pool */ - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); buf_block_free(free_block); @@ -3104,7 +2959,6 @@ buf_page_create( mutex_enter(&block->mutex); buf_page_init(space, offset, block); - rw_lock_x_unlock(&page_hash_latch); /* The block must be put to the LRU list */ buf_LRU_add_block(&block->page, FALSE); @@ -3131,7 +2985,7 @@ buf_page_create( 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, FALSE); + data = buf_buddy_alloc(zip_size, &lru); mutex_enter(&block->mutex); block->page.zip.data = data; @@ -3147,8 +3001,7 @@ buf_page_create( rw_lock_x_unlock(&block->lock); } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); mtr_memo_push(mtr, block, MTR_MEMO_BUF_FIX); @@ -3200,7 +3053,6 @@ buf_page_io_complete( enum buf_io_fix io_type; const ibool uncompressed = (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE); - enum buf_flush flush_type; ut_a(buf_page_in_file(bpage)); @@ -3335,17 +3187,8 @@ corrupt: } } - //buf_pool_mutex_enter(); - if (io_type == BUF_IO_WRITE) { - flush_type = buf_page_get_flush_type(bpage); - /* to keep consistency at buf_LRU_insert_zip_clean() */ - //if (flush_type == BUF_FLUSH_LRU) { /* optimistic! */ - mutex_enter(&LRU_list_mutex); - //} - mutex_enter(&flush_list_mutex); - } + buf_pool_mutex_enter(); mutex_enter(buf_page_get_mutex(bpage)); - mutex_enter(&buf_pool_mutex); #ifdef UNIV_IBUF_COUNT_DEBUG if (io_type == BUF_IO_WRITE || uncompressed) { @@ -3385,12 +3228,6 @@ corrupt: buf_flush_write_complete(bpage); - mutex_exit(&flush_list_mutex); - /* to keep consistency at buf_LRU_insert_zip_clean() */ - //if (flush_type == BUF_FLUSH_LRU) { /* optimistic! */ - mutex_exit(&LRU_list_mutex); - //} - if (uncompressed) { rw_lock_s_unlock_gen(&((buf_block_t*) bpage)->lock, BUF_IO_WRITE); @@ -3413,9 +3250,8 @@ corrupt: } #endif /* UNIV_DEBUG */ - mutex_exit(&buf_pool_mutex); mutex_exit(buf_page_get_mutex(bpage)); - //buf_pool_mutex_exit(); + buf_pool_mutex_exit(); } /************************************************************************* @@ -3437,14 +3273,12 @@ buf_pool_invalidate(void) freed = buf_LRU_search_and_free_block(100); } - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); ut_ad(UT_LIST_GET_LEN(buf_pool->LRU) == 0); ut_ad(UT_LIST_GET_LEN(buf_pool->unzip_LRU) == 0); - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); } #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG @@ -3468,11 +3302,7 @@ buf_validate(void) ut_ad(buf_pool); - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); - /* for keep the new latch order, it cannot validate correctly... */ + buf_pool_mutex_enter(); chunk = buf_pool->chunks; @@ -3653,25 +3483,19 @@ buf_validate(void) } ut_a(UT_LIST_GET_LEN(buf_pool->LRU) == n_lru); - /* because of latching order, we cannot get free_list_mutex here. */ -/* if (UT_LIST_GET_LEN(buf_pool->free) != n_free) { fprintf(stderr, "Free list len %lu, free blocks %lu\n", (ulong) UT_LIST_GET_LEN(buf_pool->free), (ulong) n_free); ut_error; } -*/ ut_a(UT_LIST_GET_LEN(buf_pool->flush_list) == n_flush); ut_a(buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE] == n_single_flush); 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(); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); ut_a(buf_LRU_validate()); ut_a(buf_flush_validate()); @@ -3705,10 +3529,7 @@ buf_print(void) index_ids = mem_alloc(sizeof(dulint) * size); counts = mem_alloc(sizeof(ulint) * size); - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - mutex_enter(&free_list_mutex); + buf_pool_mutex_enter(); fprintf(stderr, "buf_pool size %lu\n" @@ -3771,10 +3592,7 @@ buf_print(void) } } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - mutex_exit(&free_list_mutex); + buf_pool_mutex_exit(); for (i = 0; i < n_found; i++) { index = dict_index_get_if_in_cache(index_ids[i]); @@ -3812,7 +3630,7 @@ buf_get_latched_pages_number(void) ulint i; ulint fixed_pages_number = 0; - //buf_pool_mutex_enter(); + buf_pool_mutex_enter(); chunk = buf_pool->chunks; @@ -3882,7 +3700,7 @@ buf_get_latched_pages_number(void) } mutex_exit(&buf_pool_zip_mutex); - //buf_pool_mutex_exit(); + buf_pool_mutex_exit(); return(fixed_pages_number); } @@ -3939,11 +3757,7 @@ buf_print_io( ut_ad(buf_pool); size = buf_pool->curr_size; - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - mutex_enter(&free_list_mutex); - mutex_enter(&buf_pool_mutex); + buf_pool_mutex_enter(); fprintf(file, "Buffer pool size %lu\n" @@ -4010,11 +3824,7 @@ buf_print_io( buf_LRU_stat_sum.io, buf_LRU_stat_cur.io, buf_LRU_stat_sum.unzip, buf_LRU_stat_cur.unzip); - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - mutex_exit(&free_list_mutex); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); } /************************************************************************** @@ -4043,7 +3853,7 @@ buf_all_freed(void) ut_ad(buf_pool); - //buf_pool_mutex_enter(); /* optimistic */ + buf_pool_mutex_enter(); chunk = buf_pool->chunks; @@ -4060,7 +3870,7 @@ buf_all_freed(void) } } - //buf_pool_mutex_exit(); /* optimistic */ + buf_pool_mutex_exit(); return(TRUE); } @@ -4076,8 +3886,7 @@ buf_pool_check_no_pending_io(void) { ibool ret; - //buf_pool_mutex_enter(); - 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] @@ -4087,8 +3896,7 @@ buf_pool_check_no_pending_io(void) ret = TRUE; } - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); return(ret); } @@ -4102,13 +3910,11 @@ buf_get_free_list_len(void) { ulint len; - //buf_pool_mutex_enter(); - mutex_enter(&free_list_mutex); + buf_pool_mutex_enter(); len = UT_LIST_GET_LEN(buf_pool->free); - //buf_pool_mutex_exit(); - mutex_exit(&free_list_mutex); + buf_pool_mutex_exit(); return(len); } === modified file 'storage/xtradb/buf/buf0flu.c' --- a/storage/xtradb/buf/buf0flu.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/buf/buf0flu.c 2009-05-04 04:32:30 +0000 @@ -61,8 +61,7 @@ buf_flush_insert_into_flush_list( /*=============================*/ buf_block_t* block) /* in/out: block which is modified */ { - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&flush_list_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 <= block->page.oldest_modification)); @@ -93,8 +92,7 @@ buf_flush_insert_sorted_into_flush_list( buf_page_t* prev_b; buf_page_t* b; - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&flush_list_mutex)); + ut_ad(buf_pool_mutex_own()); ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE); ut_ad(block->page.in_LRU_list); @@ -137,7 +135,7 @@ buf_flush_ready_for_replace( { //ut_ad(buf_pool_mutex_own()); //ut_ad(mutex_own(buf_page_get_mutex(bpage))); - //ut_ad(bpage->in_LRU_list); + //ut_ad(bpage->in_LRU_list); /* optimistic use */ if (UNIV_LIKELY(bpage->in_LRU_list && buf_page_in_file(bpage))) { @@ -172,7 +170,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(buf_pool_mutex_own()); /*optimistic...*/ + 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); @@ -205,8 +203,7 @@ buf_flush_remove( /*=============*/ buf_page_t* bpage) /* in: pointer to the block in question */ { - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&flush_list_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); @@ -765,19 +762,12 @@ buf_flush_page( ibool is_uncompressed; ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST); - //ut_ad(buf_pool_mutex_own()); -#ifdef UNIV_SYNC_DEBUG - ut_ad(rw_lock_own(&page_hash_latch, RW_LOCK_EX) - || rw_lock_own(&page_hash_latch, RW_LOCK_SHARED)); -#endif + ut_ad(buf_pool_mutex_own()); ut_ad(buf_page_in_file(bpage)); block_mutex = buf_page_get_mutex(bpage); ut_ad(mutex_own(block_mutex)); - mutex_enter(&buf_pool_mutex); - rw_lock_s_unlock(&page_hash_latch); - ut_ad(buf_flush_ready_for_flush(bpage, flush_type)); buf_page_set_io_fix(bpage, BUF_IO_WRITE); @@ -808,8 +798,7 @@ buf_flush_page( } mutex_exit(block_mutex); - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); /* Even though bpage is not protected by any mutex at this point, it is safe to access bpage, because it is @@ -846,8 +835,7 @@ buf_flush_page( immediately. */ mutex_exit(block_mutex); - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); break; default: @@ -911,8 +899,7 @@ buf_flush_try_neighbors( high = fil_space_get_size(space); } - //buf_pool_mutex_enter(); - rw_lock_s_lock(&page_hash_latch); + buf_pool_mutex_enter(); for (i = low; i < high; i++) { @@ -949,16 +936,14 @@ buf_flush_try_neighbors( ut_ad(!mutex_own(block_mutex)); count++; - //buf_pool_mutex_enter(); - rw_lock_s_lock(&page_hash_latch); + buf_pool_mutex_enter(); } else { mutex_exit(block_mutex); } } } - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); return(count); } @@ -1002,29 +987,20 @@ buf_flush_batch( ut_ad((flush_type != BUF_FLUSH_LIST) || sync_thread_levels_empty_gen(TRUE)); #endif /* UNIV_SYNC_DEBUG */ - //buf_pool_mutex_enter(); - 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 */ - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); return(ULINT_UNDEFINED); } buf_pool->init_flush[flush_type] = TRUE; - mutex_exit(&buf_pool_mutex); - - if (flush_type == BUF_FLUSH_LRU) { - mutex_enter(&LRU_list_mutex); - } - mutex_enter(&flush_list_mutex); - for (;;) { flush_next: /* If we have flushed enough, leave the loop */ @@ -1071,11 +1047,7 @@ flush_next: space = buf_page_get_space(bpage); offset = buf_page_get_page_no(bpage); - //buf_pool_mutex_exit(); - if (flush_type == BUF_FLUSH_LRU) { - mutex_exit(&LRU_list_mutex); - } - mutex_exit(&flush_list_mutex); + buf_pool_mutex_exit(); old_page_count = page_count; @@ -1085,8 +1057,7 @@ flush_next: space, offset, flush_type); } else { /* Try to flush the page only */ - //buf_pool_mutex_enter(); - rw_lock_s_lock(&page_hash_latch); + buf_pool_mutex_enter(); mutex_t* block_mutex = buf_page_get_mutex(bpage); mutex_enter(block_mutex); @@ -1102,11 +1073,7 @@ flush_next: flush_type, offset, page_count - old_page_count); */ - //buf_pool_mutex_enter(); - if (flush_type == BUF_FLUSH_LRU) { - mutex_enter(&LRU_list_mutex); - } - mutex_enter(&flush_list_mutex); + buf_pool_mutex_enter(); goto flush_next; } else if (flush_type == BUF_FLUSH_LRU) { @@ -1124,13 +1091,6 @@ flush_next: break; } - if (flush_type == BUF_FLUSH_LRU) { - mutex_exit(&LRU_list_mutex); - } - mutex_exit(&flush_list_mutex); - - mutex_enter(&buf_pool_mutex); - buf_pool->init_flush[flush_type] = FALSE; if (buf_pool->n_flush[flush_type] == 0) { @@ -1140,8 +1100,7 @@ flush_next: os_event_set(buf_pool->no_flush[flush_type]); } - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); buf_flush_buffered_writes(); @@ -1195,7 +1154,7 @@ buf_flush_LRU_recommendation(void) //buf_pool_mutex_enter(); if (have_LRU_mutex) - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); n_replaceable = UT_LIST_GET_LEN(buf_pool->free); @@ -1229,7 +1188,7 @@ buf_flush_LRU_recommendation(void) //buf_pool_mutex_exit(); if (have_LRU_mutex) - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); if (n_replaceable >= BUF_FLUSH_FREE_BLOCK_MARGIN) { @@ -1307,13 +1266,11 @@ buf_flush_validate(void) { ibool ret; - //buf_pool_mutex_enter(); - mutex_enter(&flush_list_mutex); + buf_pool_mutex_enter(); ret = buf_flush_validate_low(); - //buf_pool_mutex_exit(); - mutex_exit(&flush_list_mutex); + buf_pool_mutex_exit(); return(ret); } === modified file 'storage/xtradb/buf/buf0lru.c' --- a/storage/xtradb/buf/buf0lru.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/buf/buf0lru.c 2009-05-04 04:32:30 +0000 @@ -129,31 +129,25 @@ static void buf_LRU_block_free_hashed_page( /*===========================*/ - buf_block_t* block, /* in: block, must contain a file page and + buf_block_t* block); /* in: block, must contain a file page and be in a state where it can be freed */ - ibool have_page_hash_mutex); /********************************************************************** Determines if the unzip_LRU list should be used for evicting a victim instead of the general LRU list. */ UNIV_INLINE ibool -buf_LRU_evict_from_unzip_LRU( - ibool have_LRU_mutex) +buf_LRU_evict_from_unzip_LRU(void) /*==============================*/ /* out: TRUE if should use unzip_LRU */ { ulint io_avg; ulint unzip_avg; - //ut_ad(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); - if (!have_LRU_mutex) - mutex_enter(&LRU_list_mutex); /* If the unzip_LRU list is empty, we can only use the LRU. */ if (UT_LIST_GET_LEN(buf_pool->unzip_LRU) == 0) { - if (!have_LRU_mutex) - mutex_exit(&LRU_list_mutex); return(FALSE); } @@ -162,20 +156,14 @@ buf_LRU_evict_from_unzip_LRU( decompressed pages in the buffer pool. */ if (UT_LIST_GET_LEN(buf_pool->unzip_LRU) <= UT_LIST_GET_LEN(buf_pool->LRU) / 10) { - if (!have_LRU_mutex) - mutex_exit(&LRU_list_mutex); 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) { - if (!have_LRU_mutex) - mutex_exit(&LRU_list_mutex); return(TRUE); } - if (!have_LRU_mutex) - mutex_exit(&LRU_list_mutex); /* Calculate the average over past intervals, and add the values of the current interval. */ @@ -241,8 +229,7 @@ buf_LRU_drop_page_hash_for_tablespace( page_arr = ut_malloc(sizeof(ulint) * BUF_LRU_DROP_SEARCH_HASH_SIZE); - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); scan_again: num_entries = 0; @@ -282,14 +269,12 @@ scan_again: } /* Array full. We release the buf_pool_mutex to obey the latching order. */ - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); buf_LRU_drop_page_hash_batch(id, zip_size, page_arr, num_entries); num_entries = 0; - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); } else { mutex_exit(block_mutex); } @@ -314,8 +299,7 @@ next_page: } } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); /* Drop any remaining batch of search hashed pages. */ buf_LRU_drop_page_hash_batch(id, zip_size, page_arr, num_entries); @@ -343,10 +327,7 @@ buf_LRU_invalidate_tablespace( buf_LRU_drop_page_hash_for_tablespace(id); scan_again: - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); + buf_pool_mutex_enter(); all_freed = TRUE; @@ -388,10 +369,7 @@ scan_again: ulint page_no; ulint zip_size; - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); zip_size = buf_page_get_zip_size(bpage); page_no = buf_page_get_page_no(bpage); @@ -415,7 +393,7 @@ scan_again: if (buf_LRU_block_remove_hashed_page(bpage, TRUE) != BUF_BLOCK_ZIP_FREE) { buf_LRU_block_free_hashed_page((buf_block_t*) - bpage, TRUE); + bpage); } else { /* The block_mutex should have been released by buf_LRU_block_remove_hashed_page() @@ -438,10 +416,7 @@ next_page: bpage = prev_bpage; } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); if (!all_freed) { os_thread_sleep(20000); @@ -464,16 +439,14 @@ buf_LRU_get_recent_limit(void) ulint len; ulint limit; - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_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 */ - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); return(0); } @@ -482,8 +455,7 @@ buf_LRU_get_recent_limit(void) limit = buf_page_get_LRU_position(bpage) - len / BUF_LRU_INITIAL_RATIO; - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); return(limit); } @@ -498,8 +470,7 @@ buf_LRU_insert_zip_clean( { buf_page_t* b; - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&flush_list_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 @@ -507,7 +478,7 @@ buf_LRU_insert_zip_clean( b = bpage; do { b = UT_LIST_GET_NEXT(LRU, b); - } while (b && (buf_page_get_state(b) != BUF_BLOCK_ZIP_PAGE || !b->in_LRU_list)); + } while (b && buf_page_get_state(b) != BUF_BLOCK_ZIP_PAGE); /* Insert bpage before b, i.e., after the predecessor of b. */ if (b) { @@ -529,17 +500,16 @@ ibool buf_LRU_free_from_unzip_LRU_list( /*=============================*/ /* out: TRUE if freed */ - ulint n_iterations, /* in: how many times this has been called + 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 */ - ibool have_LRU_mutex) { buf_block_t* block; ulint distance; - //ut_ad(buf_pool_mutex_own()); /* optimistic */ + ut_ad(buf_pool_mutex_own()); /* Theoratically it should be much easier to find a victim from unzip_LRU as we can choose even a dirty block (as we'll @@ -549,7 +519,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(have_LRU_mutex)) { + || !buf_LRU_evict_from_unzip_LRU()) { return(FALSE); } @@ -557,23 +527,18 @@ buf_LRU_free_from_unzip_LRU_list( distance = 100 + (n_iterations * UT_LIST_GET_LEN(buf_pool->unzip_LRU)) / 5; -restart: 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--) { - if (!block->in_unzip_LRU_list || !block->page.in_LRU_list - || buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE) - goto restart; enum buf_lru_free_block_status freed; - /* optimistic */ - //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); + 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, have_LRU_mutex); + freed = buf_LRU_free_block(&block->page, FALSE, NULL); mutex_exit(&block->mutex); switch (freed) { @@ -606,39 +571,33 @@ ibool buf_LRU_free_from_common_LRU_list( /*==============================*/ /* out: TRUE if freed */ - ulint n_iterations, /* in: how many times this has been called + 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 */ - ibool have_LRU_mutex) { buf_page_t* bpage; ulint distance; - //ut_ad(buf_pool_mutex_own()); /* optimistic */ + ut_ad(buf_pool_mutex_own()); distance = 100 + (n_iterations * buf_pool->curr_size) / 10; -restart: 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--) { - if (!bpage->in_LRU_list - || buf_page_get_state(bpage) == BUF_BLOCK_ZIP_FREE) - goto restart; enum buf_lru_free_block_status freed; mutex_t* block_mutex = buf_page_get_mutex(bpage); - /* optimistic */ - //ut_ad(buf_page_in_file(bpage)); - //ut_ad(bpage->in_LRU_list); + ut_ad(buf_page_in_file(bpage)); + ut_ad(bpage->in_LRU_list); mutex_enter(block_mutex); - freed = buf_LRU_free_block(bpage, TRUE, NULL, have_LRU_mutex); + freed = buf_LRU_free_block(bpage, TRUE, NULL); mutex_exit(block_mutex); switch (freed) { @@ -681,33 +640,22 @@ buf_LRU_search_and_free_block( n_iterations / 5 of the unzip_LRU list. */ { ibool freed = FALSE; - ibool have_LRU_mutex = FALSE; - - if (UT_LIST_GET_LEN(buf_pool->unzip_LRU)) - have_LRU_mutex = TRUE; - /* optimistic search... */ - //buf_pool_mutex_enter(); - if (have_LRU_mutex) - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); - freed = buf_LRU_free_from_unzip_LRU_list(n_iterations, have_LRU_mutex); + freed = buf_LRU_free_from_unzip_LRU_list(n_iterations); if (!freed) { - freed = buf_LRU_free_from_common_LRU_list(n_iterations, have_LRU_mutex); + freed = buf_LRU_free_from_common_LRU_list(n_iterations); } - mutex_enter(&buf_pool_mutex); if (!freed) { buf_pool->LRU_flush_ended = 0; } else if (buf_pool->LRU_flush_ended > 0) { buf_pool->LRU_flush_ended--; } - mutex_exit(&buf_pool_mutex); - //buf_pool_mutex_exit(); - if (have_LRU_mutex) - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); return(freed); } @@ -725,22 +673,18 @@ void buf_LRU_try_free_flushed_blocks(void) /*=================================*/ { - //buf_pool_mutex_enter(); - mutex_enter(&buf_pool_mutex); + buf_pool_mutex_enter(); while (buf_pool->LRU_flush_ended > 0) { - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); buf_LRU_search_and_free_block(1); - //buf_pool_mutex_enter(); - mutex_enter(&buf_pool_mutex); + buf_pool_mutex_enter(); } - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); } /********************************************************************** @@ -756,9 +700,7 @@ buf_LRU_buf_pool_running_out(void) { ibool ret = FALSE; - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); - mutex_enter(&free_list_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) { @@ -766,9 +708,7 @@ buf_LRU_buf_pool_running_out(void) ret = TRUE; } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); - mutex_exit(&free_list_mutex); + buf_pool_mutex_exit(); return(ret); } @@ -785,10 +725,9 @@ buf_LRU_get_free_only(void) { buf_block_t* block; - //ut_ad(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); - mutex_enter(&free_list_mutex); - block = (buf_block_t*) UT_LIST_GET_LAST(buf_pool->free); + block = (buf_block_t*) UT_LIST_GET_FIRST(buf_pool->free); if (block) { ut_ad(block->page.in_free_list); @@ -798,16 +737,12 @@ buf_LRU_get_free_only(void) ut_a(!buf_page_in_file(&block->page)); UT_LIST_REMOVE(list, buf_pool->free, (&block->page)); - mutex_exit(&free_list_mutex); - mutex_enter(&block->mutex); buf_block_set_state(block, BUF_BLOCK_READY_FOR_USE); UNIV_MEM_ALLOC(block->frame, UNIV_PAGE_SIZE); mutex_exit(&block->mutex); - } else { - mutex_exit(&free_list_mutex); } return(block); @@ -832,7 +767,7 @@ buf_LRU_get_free_block( ibool mon_value_was = FALSE; ibool started_monitor = FALSE; loop: - //buf_pool_mutex_enter(); + 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) { @@ -912,16 +847,14 @@ loop: if (UNIV_UNLIKELY(zip_size)) { ibool lru; page_zip_set_size(&block->page.zip, zip_size); - mutex_enter(&LRU_list_mutex); - block->page.zip.data = buf_buddy_alloc(zip_size, &lru, FALSE); - mutex_exit(&LRU_list_mutex); + block->page.zip.data = buf_buddy_alloc(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(); if (started_monitor) { srv_print_innodb_monitor = mon_value_was; @@ -933,7 +866,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 */ - //buf_pool_mutex_exit(); + buf_pool_mutex_exit(); freed = buf_LRU_search_and_free_block(n_iterations); @@ -982,21 +915,18 @@ loop: os_aio_simulated_wake_handler_threads(); - //buf_pool_mutex_enter(); - 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. */ - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); buf_LRU_try_free_flushed_blocks(); } else { - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); } if (n_iterations > 10) { @@ -1021,8 +951,7 @@ buf_LRU_old_adjust_len(void) ulint new_len; ut_a(buf_pool->LRU_old); - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); + ut_ad(buf_pool_mutex_own()); #if 3 * (BUF_LRU_OLD_MIN_LEN / 8) <= BUF_LRU_OLD_TOLERANCE + 5 # error "3 * (BUF_LRU_OLD_MIN_LEN / 8) <= BUF_LRU_OLD_TOLERANCE + 5" #endif @@ -1080,8 +1009,7 @@ buf_LRU_old_init(void) { buf_page_t* bpage; - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_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 @@ -1113,14 +1041,13 @@ buf_unzip_LRU_remove_block_if_needed( ut_ad(buf_pool); ut_ad(bpage); ut_ad(buf_page_in_file(bpage)); - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); + ut_ad(buf_pool_mutex_own()); if (buf_page_belongs_to_unzip_LRU(bpage)) { buf_block_t* block = (buf_block_t*) bpage; ut_ad(block->in_unzip_LRU_list); - block->in_unzip_LRU_list = FALSE; + ut_d(block->in_unzip_LRU_list = FALSE); UT_LIST_REMOVE(unzip_LRU, buf_pool->unzip_LRU, block); } @@ -1136,8 +1063,7 @@ buf_LRU_remove_block( { ut_ad(buf_pool); ut_ad(bpage); - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); + ut_ad(buf_pool_mutex_own()); ut_a(buf_page_in_file(bpage)); @@ -1200,13 +1126,12 @@ buf_unzip_LRU_add_block( { ut_ad(buf_pool); ut_ad(block); - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); + ut_ad(buf_pool_mutex_own()); ut_a(buf_page_belongs_to_unzip_LRU(&block->page)); ut_ad(!block->in_unzip_LRU_list); - block->in_unzip_LRU_list = TRUE; + ut_d(block->in_unzip_LRU_list = TRUE); if (old) { UT_LIST_ADD_LAST(unzip_LRU, buf_pool->unzip_LRU, block); @@ -1227,8 +1152,7 @@ buf_LRU_add_block_to_end_low( ut_ad(buf_pool); ut_ad(bpage); - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); + ut_ad(buf_pool_mutex_own()); ut_a(buf_page_in_file(bpage)); @@ -1288,8 +1212,7 @@ buf_LRU_add_block_low( { ut_ad(buf_pool); ut_ad(bpage); - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); + ut_ad(buf_pool_mutex_own()); ut_a(buf_page_in_file(bpage)); ut_ad(!bpage->in_LRU_list); @@ -1408,24 +1331,22 @@ buf_LRU_free_block( 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, + ibool* buf_pool_mutex_released) /* in: pointer to a variable that will be assigned TRUE if buf_pool_mutex was temporarily released, or NULL */ - ibool have_LRU_mutex) { buf_page_t* b = NULL; mutex_t* block_mutex = buf_page_get_mutex(bpage); - //ut_ad(buf_pool_mutex_own()); - /* optimistic */ - //ut_ad(mutex_own(block_mutex)); - //ut_ad(buf_page_in_file(bpage)); - //ut_ad(bpage->in_LRU_list); - //ut_ad(!bpage->in_flush_list == !bpage->oldest_modification); + 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); + ut_ad(!bpage->in_flush_list == !bpage->oldest_modification); UNIV_MEM_ASSERT_RW(bpage, sizeof *bpage); - if (!bpage->in_LRU_list || !block_mutex || !buf_page_can_relocate(bpage)) { + if (!buf_page_can_relocate(bpage)) { /* Do not free buffer-fixed or I/O-fixed blocks. */ return(BUF_LRU_NOT_FREED); @@ -1457,15 +1378,15 @@ 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, FALSE); - //buf_pool_mutex_exit_allow(); + buf_pool_mutex_exit_forbid(); + b = buf_buddy_alloc(sizeof *b, NULL); + buf_pool_mutex_exit_allow(); if (UNIV_UNLIKELY(!b)) { return(BUF_LRU_CANNOT_RELOCATE); } - //memcpy(b, bpage, sizeof *b); + memcpy(b, bpage, sizeof *b); } #ifdef UNIV_DEBUG @@ -1476,41 +1397,6 @@ alloc: } #endif /* UNIV_DEBUG */ - /* not to break latch order, must re-enter block_mutex */ - mutex_exit(block_mutex); - - if (!have_LRU_mutex) - mutex_enter(&LRU_list_mutex); /* optimistic */ - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); - mutex_enter(block_mutex); - - /* recheck states of block */ - if (!bpage->in_LRU_list || block_mutex != buf_page_get_mutex(bpage) - || !buf_page_can_relocate(bpage)) { -not_freed: - if (b) { - buf_buddy_free(b, sizeof *b, TRUE); - } - if (!have_LRU_mutex) - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - return(BUF_LRU_NOT_FREED); - } else if (zip || !bpage->zip.data) { - if (bpage->oldest_modification) - goto not_freed; - } else if (bpage->oldest_modification) { - if (buf_page_get_state(bpage) != BUF_BLOCK_FILE_PAGE) { - ut_ad(buf_page_get_state(bpage) == BUF_BLOCK_ZIP_DIRTY); - goto not_freed; - } - } - - if (b) { - memcpy(b, bpage, sizeof *b); - } - if (buf_LRU_block_remove_hashed_page(bpage, zip) != BUF_BLOCK_ZIP_FREE) { ut_a(bpage->buf_fix_count == 0); @@ -1522,10 +1408,6 @@ not_freed: ut_a(!buf_page_hash_get(bpage->space, bpage->offset)); - while (prev_b && !prev_b->in_LRU_list) { - prev_b = UT_LIST_GET_PREV(LRU, prev_b); - } - b->state = b->oldest_modification ? BUF_BLOCK_ZIP_DIRTY : BUF_BLOCK_ZIP_PAGE; @@ -1639,10 +1521,7 @@ not_freed: *buf_pool_mutex_released = TRUE; } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); mutex_exit(block_mutex); /* Remove possible adaptive hash index on the page. @@ -1674,9 +1553,7 @@ not_freed: : BUF_NO_CHECKSUM_MAGIC); } - //buf_pool_mutex_enter(); - if (have_LRU_mutex) - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); mutex_enter(block_mutex); if (b) { @@ -1686,18 +1563,13 @@ not_freed: mutex_exit(&buf_pool_zip_mutex); } - buf_LRU_block_free_hashed_page((buf_block_t*) bpage, FALSE); + 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); mutex_enter(block_mutex); - - if (!have_LRU_mutex) - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); } return(BUF_LRU_FREED); @@ -1709,13 +1581,12 @@ UNIV_INTERN void buf_LRU_block_free_non_file_page( /*=============================*/ - buf_block_t* block, /* in: block, must not contain a file page */ - ibool have_page_hash_mutex) + buf_block_t* block) /* in: block, must not contain a file page */ { void* data; ut_ad(block); - //ut_ad(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); ut_ad(mutex_own(&block->mutex)); switch (buf_block_get_state(block)) { @@ -1749,17 +1620,15 @@ 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), have_page_hash_mutex); - //buf_pool_mutex_exit_allow(); + buf_pool_mutex_exit_forbid(); + buf_buddy_free(data, page_zip_get_size(&block->page.zip)); + buf_pool_mutex_exit_allow(); mutex_enter(&block->mutex); page_zip_set_size(&block->page.zip, 0); } - mutex_enter(&free_list_mutex); UT_LIST_ADD_FIRST(list, buf_pool->free, (&block->page)); ut_d(block->page.in_free_list = TRUE); - mutex_exit(&free_list_mutex); UNIV_MEM_ASSERT_AND_FREE(block->frame, UNIV_PAGE_SIZE); } @@ -1788,11 +1657,7 @@ buf_LRU_block_remove_hashed_page( { const buf_page_t* hashed_bpage; ut_ad(bpage); - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); -#ifdef UNIV_SYNC_DEBUG - ut_ad(rw_lock_own(&page_hash_latch, RW_LOCK_EX)); -#endif + 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); @@ -1893,9 +1758,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(); - mutex_exit(&LRU_list_mutex); - rw_lock_x_unlock(&page_hash_latch); + buf_pool_mutex_exit(); buf_print(); buf_LRU_print(); buf_validate(); @@ -1921,11 +1784,11 @@ 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_pool_mutex_exit_forbid(); buf_buddy_free(bpage->zip.data, - page_zip_get_size(&bpage->zip), TRUE); - buf_buddy_free(bpage, sizeof(*bpage), TRUE); - //buf_pool_mutex_exit_allow(); + page_zip_get_size(&bpage->zip)); + buf_buddy_free(bpage, sizeof(*bpage)); + buf_pool_mutex_exit_allow(); UNIV_MEM_UNDESC(bpage); return(BUF_BLOCK_ZIP_FREE); @@ -1944,9 +1807,9 @@ buf_LRU_block_remove_hashed_page( bpage->zip.data = NULL; mutex_exit(&((buf_block_t*) bpage)->mutex); - //buf_pool_mutex_exit_forbid(); - buf_buddy_free(data, page_zip_get_size(&bpage->zip), TRUE); - //buf_pool_mutex_exit_allow(); + buf_pool_mutex_exit_forbid(); + buf_buddy_free(data, page_zip_get_size(&bpage->zip)); + buf_pool_mutex_exit_allow(); mutex_enter(&((buf_block_t*) bpage)->mutex); page_zip_set_size(&bpage->zip, 0); } @@ -1972,16 +1835,15 @@ static void buf_LRU_block_free_hashed_page( /*===========================*/ - buf_block_t* block, /* in: block, must contain a file page and + buf_block_t* block) /* in: block, must contain a file page and be in a state where it can be freed */ - ibool have_page_hash_mutex) { - //ut_ad(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); ut_ad(mutex_own(&block->mutex)); buf_block_set_state(block, BUF_BLOCK_MEMORY); - buf_LRU_block_free_non_file_page(block, have_page_hash_mutex); + buf_LRU_block_free_non_file_page(block); } /************************************************************************ @@ -1999,8 +1861,7 @@ buf_LRU_stat_update(void) goto func_exit; } - //buf_pool_mutex_enter(); - mutex_enter(&buf_pool_mutex); + buf_pool_mutex_enter(); /* Update the index. */ item = &buf_LRU_stat_arr[buf_LRU_stat_arr_ind]; @@ -2014,8 +1875,7 @@ buf_LRU_stat_update(void) /* Put current entry in the array. */ memcpy(item, &buf_LRU_stat_cur, sizeof *item); - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); func_exit: /* Clear the current entry. */ @@ -2037,8 +1897,7 @@ buf_LRU_validate(void) ulint LRU_pos; ut_ad(buf_pool); - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); if (UT_LIST_GET_LEN(buf_pool->LRU) >= BUF_LRU_OLD_MIN_LEN) { @@ -2097,9 +1956,6 @@ buf_LRU_validate(void) ut_a(buf_pool->LRU_old_len == old_len); } - mutex_exit(&LRU_list_mutex); - mutex_enter(&free_list_mutex); - UT_LIST_VALIDATE(list, buf_page_t, buf_pool->free); for (bpage = UT_LIST_GET_FIRST(buf_pool->free); @@ -2109,9 +1965,6 @@ buf_LRU_validate(void) ut_a(buf_page_get_state(bpage) == BUF_BLOCK_NOT_USED); } - mutex_exit(&free_list_mutex); - mutex_enter(&LRU_list_mutex); - UT_LIST_VALIDATE(unzip_LRU, buf_block_t, buf_pool->unzip_LRU); for (block = UT_LIST_GET_FIRST(buf_pool->unzip_LRU); @@ -2123,8 +1976,7 @@ buf_LRU_validate(void) ut_a(buf_page_belongs_to_unzip_LRU(&block->page)); } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); return(TRUE); } #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */ @@ -2140,8 +1992,7 @@ buf_LRU_print(void) const buf_page_t* bpage; ut_ad(buf_pool); - //buf_pool_mutex_enter(); - mutex_enter(&LRU_list_mutex); + buf_pool_mutex_enter(); fprintf(stderr, "Pool ulint clock %lu\n", (ulong) buf_pool->ulint_clock); @@ -2204,7 +2055,6 @@ buf_LRU_print(void) bpage = UT_LIST_GET_NEXT(LRU, bpage); } - //buf_pool_mutex_exit(); - mutex_exit(&LRU_list_mutex); + buf_pool_mutex_exit(); } #endif /* UNIV_DEBUG_PRINT || UNIV_DEBUG || UNIV_BUF_DEBUG */ === modified file 'storage/xtradb/buf/buf0rea.c' --- a/storage/xtradb/buf/buf0rea.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/buf/buf0rea.c 2009-05-04 02:45:47 +0000 @@ -246,22 +246,18 @@ buf_read_ahead_random( LRU_recent_limit = buf_LRU_get_recent_limit(); - //buf_pool_mutex_enter(); - mutex_enter(&buf_pool_mutex); + buf_pool_mutex_enter(); if (buf_pool->n_pend_reads > buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) { - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); return(0); } - mutex_exit(&buf_pool_mutex); /* Count how many blocks in the area have been recently accessed, that is, reside near the start of the LRU list. */ - rw_lock_s_lock(&page_hash_latch); for (i = low; i < high; i++) { const buf_page_t* bpage = buf_page_hash_get(space, i); @@ -273,15 +269,13 @@ buf_read_ahead_random( if (recent_blocks >= BUF_READ_AHEAD_RANDOM_THRESHOLD) { - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); goto read_ahead; } } } - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); /* Do nothing */ return(0); @@ -475,12 +469,10 @@ buf_read_ahead_linear( tablespace_version = fil_space_get_version(space); - //buf_pool_mutex_enter(); - mutex_enter(&buf_pool_mutex); + buf_pool_mutex_enter(); if (high > fil_space_get_size(space)) { - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); /* The area is not whole, return */ return(0); @@ -488,12 +480,10 @@ buf_read_ahead_linear( if (buf_pool->n_pend_reads > buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) { - //buf_pool_mutex_exit(); - mutex_exit(&buf_pool_mutex); + buf_pool_mutex_exit(); return(0); } - mutex_exit(&buf_pool_mutex); /* Check that almost all pages in the area have been accessed; if offset == low, the accesses must be in a descending order, otherwise, @@ -507,7 +497,6 @@ buf_read_ahead_linear( fail_count = 0; - rw_lock_s_lock(&page_hash_latch); for (i = low; i < high; i++) { bpage = buf_page_hash_get(space, i); @@ -531,8 +520,7 @@ buf_read_ahead_linear( * LINEAR_AREA_THRESHOLD_COEF) { /* Too many failures: return */ - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); return(0); } @@ -543,8 +531,7 @@ buf_read_ahead_linear( bpage = buf_page_hash_get(space, offset); if (bpage == NULL) { - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); return(0); } @@ -570,8 +557,7 @@ buf_read_ahead_linear( pred_offset = fil_page_get_prev(frame); succ_offset = fil_page_get_next(frame); - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); if ((offset == low) && (succ_offset == offset + 1)) { === modified file 'storage/xtradb/handler/ha_innodb.cc' --- a/storage/xtradb/handler/ha_innodb.cc 2009-06-09 12:21:26 +0000 +++ b/storage/xtradb/handler/ha_innodb.cc 2009-06-10 06:51:03 +0000 @@ -35,7 +35,17 @@ Place, Suite 330, Boston, MA 02111-1307 #pragma implementation // gcc: Class implementation #endif +#define MYSQL_SERVER + #include <mysql_priv.h> +#ifdef MYSQL_SERVER +#include <rpl_mi.h> +#include <slave.h> +// Defined in slave.cc +int init_intvar_from_file(int* var, IO_CACHE* f, int default_val); +int init_strvar_from_file(char *var, int max_size, IO_CACHE *f, + const char *default_val); +#endif /* MYSQL_SERVER */ #include <m_ctype.h> #include <mysys_err.h> @@ -78,6 +88,14 @@ extern "C" { #include "i_s.h" #include "handler0vars.h" +#ifdef MYSQL_SERVER +// Defined in trx0sys.c +extern char trx_sys_mysql_master_log_name[]; +extern ib_int64_t trx_sys_mysql_master_log_pos; +extern char trx_sys_mysql_relay_log_name[]; +extern ib_int64_t trx_sys_mysql_relay_log_pos; +#endif /* MYSQL_SERVER */ + #ifndef MYSQL_SERVER /* This is needed because of Bug #3596. Let us hope that pthread_mutex_t is defined the same in both builds: the MySQL server and the InnoDB plugin. */ @@ -176,6 +194,7 @@ static my_bool innobase_use_doublewrite static my_bool innobase_use_checksums = TRUE; static my_bool innobase_extra_undoslots = FALSE; static my_bool innobase_locks_unsafe_for_binlog = FALSE; +static my_bool innobase_overwrite_relay_log_info = FALSE; static my_bool innobase_rollback_on_timeout = FALSE; static my_bool innobase_create_status_file = FALSE; static my_bool innobase_stats_on_metadata = TRUE; @@ -1920,6 +1939,89 @@ innobase_init( } #endif /* UNIV_DEBUG */ +#ifndef MYSQL_SERVER + innodb_overwrite_relay_log_info = FALSE; +#endif + +#ifdef HAVE_REPLICATION +#ifdef MYSQL_SERVER + /* read master log position from relay-log.info if exists */ + char fname[FN_REFLEN+128]; + int pos; + int info_fd; + IO_CACHE info_file; + + fname[0] = '\0'; + + if(innobase_overwrite_relay_log_info) { + + fprintf(stderr, + "InnoDB: Warning: innodb_overwrite_relay_log_info is enabled." + " Updates in other storage engines may have problem with consistency.\n"); + + bzero((char*) &info_file, sizeof(info_file)); + fn_format(fname, relay_log_info_file, mysql_data_home, "", 4+32); + + int error=0; + + if (!access(fname,F_OK)) { + /* exist */ + if ((info_fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0) { + error=1; + } else if (init_io_cache(&info_file, info_fd, IO_SIZE*2, + READ_CACHE, 0L, 0, MYF(MY_WME))) { + error=1; + } + + if (error) { +relay_info_error: + if (info_fd >= 0) + my_close(info_fd, MYF(0)); + fname[0] = '\0'; + goto skip_relay; + } + } else { + fname[0] = '\0'; + goto skip_relay; + } + + if (init_strvar_from_file(fname, sizeof(fname), &info_file, "") || /* dummy (it is relay-log) */ + init_intvar_from_file(&pos, &info_file, BIN_LOG_HEADER_SIZE)) { + end_io_cache(&info_file); + error=1; + goto relay_info_error; + } + + fprintf(stderr, + "InnoDB: relay-log.info is detected.\n" + "InnoDB: relay log: position %u, file name %s\n", + pos, fname); + + strncpy(trx_sys_mysql_relay_log_name, fname, TRX_SYS_MYSQL_MASTER_LOG_NAME_LEN); + trx_sys_mysql_relay_log_pos = (ib_int64_t) pos; + + if (init_strvar_from_file(fname, sizeof(fname), &info_file, "") || + init_intvar_from_file(&pos, &info_file, 0)) { + end_io_cache(&info_file); + error=1; + goto relay_info_error; + } + + fprintf(stderr, + "InnoDB: master log: position %u, file name %s\n", + pos, fname); + + strncpy(trx_sys_mysql_master_log_name, fname, TRX_SYS_MYSQL_MASTER_LOG_NAME_LEN); + trx_sys_mysql_master_log_pos = (ib_int64_t) pos; + + end_io_cache(&info_file); + if (info_fd >= 0) + my_close(info_fd, MYF(0)); + } +skip_relay: +#endif /* MYSQL_SERVER */ +#endif /* HAVE_REPLICATION */ + /* Check that values don't overflow on 32-bit systems. */ if (sizeof(ulint) == 4) { if (innobase_buffer_pool_size > UINT_MAX32) { @@ -2003,6 +2105,77 @@ mem_free_and_error: goto error; } +#ifdef HAVE_REPLICATION +#ifdef MYSQL_SERVER + if(innobase_overwrite_relay_log_info) { + /* If InnoDB progressed from relay-log.info, overwrite it */ + if (fname[0] == '\0') { + fprintf(stderr, + "InnoDB: something wrong with relay-info.log. InnoDB will not overwrite it.\n"); + } else if (0 != strcmp(fname, trx_sys_mysql_master_log_name) + || pos != trx_sys_mysql_master_log_pos) { + /* Overwrite relay-log.info */ + bzero((char*) &info_file, sizeof(info_file)); + fn_format(fname, relay_log_info_file, mysql_data_home, "", 4+32); + + int error = 0; + + if (!access(fname,F_OK)) { + /* exist */ + if ((info_fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0) { + error = 1; + } else if (init_io_cache(&info_file, info_fd, IO_SIZE*2, + WRITE_CACHE, 0L, 0, MYF(MY_WME))) { + error = 1; + } + + if (error) { + if (info_fd >= 0) + my_close(info_fd, MYF(0)); + goto skip_overwrite; + } + } else { + error = 1; + goto skip_overwrite; + } + + char buff[FN_REFLEN*2+22*2+4], *pos; + + my_b_seek(&info_file, 0L); + pos=strmov(buff, trx_sys_mysql_relay_log_name); + *pos++='\n'; + pos=longlong2str(trx_sys_mysql_relay_log_pos, pos, 10); + *pos++='\n'; + pos=strmov(pos, trx_sys_mysql_master_log_name); + *pos++='\n'; + pos=longlong2str(trx_sys_mysql_master_log_pos, pos, 10); + *pos='\n'; + + if (my_b_write(&info_file, (uchar*) buff, (size_t) (pos-buff)+1)) + error = 1; + if (flush_io_cache(&info_file)) + error = 1; + + end_io_cache(&info_file); + if (info_fd >= 0) + my_close(info_fd, MYF(0)); +skip_overwrite: + if (error) { + fprintf(stderr, + "InnoDB: ERROR: error occured during overwriting relay-log.info.\n"); + } else { + fprintf(stderr, + "InnoDB: relay-log.info was overwritten.\n"); + } + } else { + fprintf(stderr, + "InnoDB: InnoDB and relay-log.info are synchronized. InnoDB will not overwrite it.\n"); + } + } +#endif /* MYSQL_SERVER */ +#endif /* HAVE_REPLICATION */ + + srv_extra_undoslots = (ibool) innobase_extra_undoslots; /* -------------- Log files ---------------------------*/ @@ -2270,6 +2443,26 @@ innobase_commit_low( return; } +#ifdef HAVE_REPLICATION +#ifdef MYSQL_SERVER + THD *thd=current_thd; + + if (thd && thd->slave_thread) { + /* Update the replication position info inside InnoDB */ + trx->mysql_master_log_file_name + = active_mi->rli.group_master_log_name; + trx->mysql_master_log_pos + = ((ib_int64_t)active_mi->rli.group_master_log_pos + + ((ib_int64_t)active_mi->rli.future_event_relay_log_pos - + (ib_int64_t)active_mi->rli.group_relay_log_pos)); + trx->mysql_relay_log_file_name + = active_mi->rli.group_relay_log_name; + trx->mysql_relay_log_pos + = (ib_int64_t)active_mi->rli.future_event_relay_log_pos; + } +#endif /* MYSQL_SERVER */ +#endif /* HAVE_REPLICATION */ + trx_commit_for_mysql(trx); } @@ -9509,6 +9702,12 @@ static MYSQL_SYSVAR_BOOL(extra_undoslots "don't use the datafile for normal mysqld or ibbackup! ####", NULL, NULL, FALSE); +static MYSQL_SYSVAR_BOOL(overwrite_relay_log_info, innobase_overwrite_relay_log_info, + PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY, + "During InnoDB crash recovery on slave overwrite relay-log.info " + "to align master log file position if information in InnoDB and relay-log.info is different.", + NULL, NULL, FALSE); + static MYSQL_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite, PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY, "Enable InnoDB doublewrite buffer (enabled by default). " @@ -9851,6 +10050,7 @@ static struct st_mysql_sys_var* innobase MYSQL_SYSVAR(max_purge_lag), MYSQL_SYSVAR(mirrored_log_groups), MYSQL_SYSVAR(open_files), + MYSQL_SYSVAR(overwrite_relay_log_info), MYSQL_SYSVAR(rollback_on_timeout), MYSQL_SYSVAR(stats_on_metadata), MYSQL_SYSVAR(stats_sample_pages), === modified file 'storage/xtradb/handler/i_s.cc' --- a/storage/xtradb/handler/i_s.cc 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/handler/i_s.cc 2009-05-04 02:45:47 +0000 @@ -2282,8 +2282,7 @@ i_s_cmpmem_fill_low( RETURN_IF_INNODB_NOT_STARTED(tables->schema_table_name); - //buf_pool_mutex_enter(); - mutex_enter(&zip_free_mutex); + buf_pool_mutex_enter(); for (uint x = 0; x <= BUF_BUDDY_SIZES; x++) { buf_buddy_stat_t* buddy_stat = &buf_buddy_stat[x]; @@ -2309,8 +2308,7 @@ i_s_cmpmem_fill_low( } } - //buf_pool_mutex_exit(); - mutex_exit(&zip_free_mutex); + buf_pool_mutex_exit(); DBUG_RETURN(status); } === modified file 'storage/xtradb/handler/innodb_patch_info.h' --- a/storage/xtradb/handler/innodb_patch_info.h 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/handler/innodb_patch_info.h 2009-05-04 02:45:47 +0000 @@ -26,11 +26,10 @@ struct innodb_enhancement { {"xtradb_show_enhancements","I_S.XTRADB_ENHANCEMENTS","","http://www.percona.com/docs/wiki/percona-xtradb"}, {"innodb_show_status","Improvements to SHOW INNODB STATUS","Memory information and lock info fixes","http://www.percona.com/docs/wiki/percona-xtradb"}, {"innodb_io","Improvements to InnoDB IO","","http://www.percona.com/docs/wiki/percona-xtradb"}, -{"innodb_rw_lock","InnoDB RW-lock fixes","Useful for 8+ cores SMP systems","http://www.percona.com/docs/wiki/percona-xtradb"}, {"innodb_opt_lru_count","Fix of buffer_pool mutex","Decreases contention on buffer_pool mutex on LRU operations","http://www.percona.com/docs/wiki/percona-xtradb"}, {"innodb_buffer_pool_pages","Information of buffer pool content","","http://www.percona.com/docs/wiki/percona-xtradb"}, -{"innodb_split_buf_pool_mutex","More fix of buffer_pool mutex","Spliting buf_pool_mutex and optimizing based on innodb_opt_lru_count","http://www.percona.com/docs/wiki/percona-xtradb"}, {"innodb_expand_undo_slots","expandable maximum number of undo slots","from 1024 (default) to about 4000","http://www.percona.com/docs/wiki/percona-xtradb"}, {"innodb_extra_rseg","allow to create extra rollback segments","When create new db, the new parameter allows to create more rollback segments","http://www.percona.com/docs/wiki/percona-xtradb"}, +{"innodb_overwrite_relay_log_info","overwrite relay-log.info when slave recovery","Building as plugin, it is not used.","http://www.percona.com/docs/wiki/percona-xtradb:innodb_overwrite_relay_log_info"}, {NULL, NULL, NULL, NULL} }; === modified file 'storage/xtradb/include/buf0buddy.h' --- a/storage/xtradb/include/buf0buddy.h 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/include/buf0buddy.h 2009-05-04 02:45:47 +0000 @@ -49,11 +49,10 @@ buf_buddy_alloc( /* out: allocated block, possibly NULL if lru == NULL */ ulint size, /* in: block size, up to UNIV_PAGE_SIZE */ - ibool* lru, /* in: pointer to a variable that will be assigned + 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 */ - ibool have_page_hash_mutex) __attribute__((malloc)); /************************************************************************** @@ -64,8 +63,7 @@ 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 */ - ibool have_page_hash_mutex) + ulint size) /* in: block size, up to UNIV_PAGE_SIZE */ __attribute__((nonnull)); /** Statistics of buddy blocks of a given size. */ === modified file 'storage/xtradb/include/buf0buddy.ic' --- a/storage/xtradb/include/buf0buddy.ic 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/include/buf0buddy.ic 2009-05-04 02:45:47 +0000 @@ -44,11 +44,10 @@ buf_buddy_alloc_low( possibly NULL if lru==NULL */ ulint i, /* in: index of buf_pool->zip_free[], or BUF_BUDDY_SIZES */ - ibool* lru, /* in: pointer to a variable that will be assigned + 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 */ - ibool have_page_hash_mutex) __attribute__((malloc)); /************************************************************************** @@ -59,9 +58,8 @@ 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[], + ulint i) /* in: index of buf_pool->zip_free[], or BUF_BUDDY_SIZES */ - ibool have_page_hash_mutex) __attribute__((nonnull)); /************************************************************************** @@ -100,15 +98,14 @@ buf_buddy_alloc( /* out: allocated block, possibly NULL if lru == NULL */ ulint size, /* in: block size, up to UNIV_PAGE_SIZE */ - ibool* lru, /* in: pointer to a variable that will be assigned + 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 */ - ibool have_page_hash_mutex) { - //ut_ad(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); - return(buf_buddy_alloc_low(buf_buddy_get_slot(size), lru, have_page_hash_mutex)); + return(buf_buddy_alloc_low(buf_buddy_get_slot(size), lru)); } /************************************************************************** @@ -119,26 +116,11 @@ 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 */ - ibool have_page_hash_mutex) + ulint size) /* in: block size, up to UNIV_PAGE_SIZE */ { - //ut_ad(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); - if (!have_page_hash_mutex) { - mutex_enter(&LRU_list_mutex); - mutex_enter(&flush_list_mutex); - rw_lock_x_lock(&page_hash_latch); - } - - mutex_enter(&zip_free_mutex); - buf_buddy_free_low(buf, buf_buddy_get_slot(size), TRUE); - mutex_exit(&zip_free_mutex); - - if (!have_page_hash_mutex) { - mutex_exit(&LRU_list_mutex); - mutex_exit(&flush_list_mutex); - rw_lock_x_unlock(&page_hash_latch); - } + buf_buddy_free_low(buf, buf_buddy_get_slot(size)); } #ifdef UNIV_MATERIALIZE === modified file 'storage/xtradb/include/buf0buf.h' --- a/storage/xtradb/include/buf0buf.h 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/include/buf0buf.h 2009-05-04 04:32:30 +0000 @@ -1104,11 +1104,11 @@ struct buf_block_struct{ a block is in the unzip_LRU list if page.state == BUF_BLOCK_FILE_PAGE and page.zip.data != NULL */ -//#ifdef UNIV_DEBUG +#ifdef UNIV_DEBUG ibool in_unzip_LRU_list;/* TRUE if the page is in the decompressed LRU list; used in debugging */ -//#endif /* UNIV_DEBUG */ +#endif /* UNIV_DEBUG */ byte* frame; /* pointer to buffer frame which is of size UNIV_PAGE_SIZE, and aligned to an address divisible by @@ -1316,12 +1316,6 @@ struct buf_pool_struct{ /* mutex protecting the buffer pool struct and control blocks, except the read-write lock in them */ extern mutex_t buf_pool_mutex; -extern mutex_t LRU_list_mutex; -extern mutex_t flush_list_mutex; -extern rw_lock_t page_hash_latch; -extern mutex_t free_list_mutex; -extern mutex_t zip_free_mutex; -extern mutex_t zip_hash_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; === modified file 'storage/xtradb/include/buf0buf.ic' --- a/storage/xtradb/include/buf0buf.ic 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/include/buf0buf.ic 2009-05-04 02:45:47 +0000 @@ -100,8 +100,7 @@ buf_pool_get_oldest_modification(void) buf_page_t* bpage; ib_uint64_t lsn; - //buf_pool_mutex_enter(); - mutex_enter(&flush_list_mutex); + buf_pool_mutex_enter(); bpage = UT_LIST_GET_LAST(buf_pool->flush_list); @@ -112,8 +111,7 @@ buf_pool_get_oldest_modification(void) lsn = bpage->oldest_modification; } - //buf_pool_mutex_exit(); - mutex_exit(&flush_list_mutex); + buf_pool_mutex_exit(); /* The returned answer may be out of date: the flush_list can change after the mutex has been released. */ @@ -130,8 +128,7 @@ buf_pool_clock_tic(void) /*====================*/ /* out: new clock value */ { - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); + ut_ad(buf_pool_mutex_own()); buf_pool->ulint_clock++; @@ -249,7 +246,7 @@ buf_page_in_file( case BUF_BLOCK_ZIP_FREE: /* This is a free page in buf_pool->zip_free[]. Such pages should only be accessed by the buddy allocator. */ - /* ut_error; */ /* optimistic */ + ut_error; break; case BUF_BLOCK_ZIP_PAGE: case BUF_BLOCK_ZIP_DIRTY: @@ -308,7 +305,7 @@ buf_page_get_mutex( { switch (buf_page_get_state(bpage)) { case BUF_BLOCK_ZIP_FREE: - /* ut_error; */ /* optimistic */ + ut_error; return(NULL); case BUF_BLOCK_ZIP_PAGE: case BUF_BLOCK_ZIP_DIRTY: @@ -413,7 +410,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(buf_pool_mutex_own()); + ut_ad(buf_pool_mutex_own()); ut_ad(mutex_own(buf_page_get_mutex(bpage))); bpage->io_fix = io_fix; @@ -441,13 +438,12 @@ buf_page_can_relocate( /*==================*/ const buf_page_t* bpage) /* control block being relocated */ { - //ut_ad(buf_pool_mutex_own()); - /* optimistic */ - //ut_ad(mutex_own(buf_page_get_mutex(bpage))); - //ut_ad(buf_page_in_file(bpage)); - //ut_ad(bpage->in_LRU_list); + 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); - return(bpage->in_LRU_list && bpage->io_fix == BUF_IO_NONE + return(buf_page_get_io_fix(bpage) == BUF_IO_NONE && bpage->buf_fix_count == 0); } @@ -476,8 +472,7 @@ buf_page_set_old( ibool old) /* in: old */ { ut_a(buf_page_in_file(bpage)); - //ut_ad(buf_pool_mutex_own()); - ut_ad(mutex_own(&LRU_list_mutex)); + ut_ad(buf_pool_mutex_own()); ut_ad(bpage->in_LRU_list); #ifdef UNIV_LRU_DEBUG @@ -733,17 +728,17 @@ buf_block_free( /*===========*/ buf_block_t* block) /* in, own: block to be freed */ { - //buf_pool_mutex_enter(); + buf_pool_mutex_enter(); mutex_enter(&block->mutex); ut_a(buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE); - buf_LRU_block_free_non_file_page(block, FALSE); + buf_LRU_block_free_non_file_page(block); mutex_exit(&block->mutex); - //buf_pool_mutex_exit(); + buf_pool_mutex_exit(); } /************************************************************************* @@ -788,17 +783,14 @@ buf_page_io_query( buf_page_t* bpage) /* in: buf_pool block, must be bufferfixed */ { ibool io_fixed; - mutex_t* block_mutex = buf_page_get_mutex(bpage); - //buf_pool_mutex_enter(); - mutex_enter(block_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; - //buf_pool_mutex_exit(); - mutex_exit(block_mutex); + buf_pool_mutex_exit(); return(io_fixed); } @@ -925,11 +917,7 @@ buf_page_hash_get( ulint fold; ut_ad(buf_pool); - //ut_ad(buf_pool_mutex_own()); -#ifdef UNIV_SYNC_DEBUG - ut_ad(rw_lock_own(&page_hash_latch, RW_LOCK_EX) - || rw_lock_own(&page_hash_latch, RW_LOCK_SHARED)); -#endif + ut_ad(buf_pool_mutex_own()); /* Look for the page in the hash table */ @@ -978,13 +966,11 @@ buf_page_peek( { const buf_page_t* bpage; - //buf_pool_mutex_enter(); - rw_lock_s_lock(&page_hash_latch); + buf_pool_mutex_enter(); bpage = buf_page_hash_get(space, offset); - //buf_pool_mutex_exit(); - rw_lock_s_unlock(&page_hash_latch); + buf_pool_mutex_exit(); return(bpage != NULL); } @@ -1047,17 +1033,12 @@ buf_page_release( ut_a(block->page.buf_fix_count > 0); if (rw_latch == RW_X_LATCH && mtr->modifications) { - //buf_pool_mutex_enter(); - mutex_enter(&flush_list_mutex); - mutex_enter(&block->mutex); - ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE); + buf_pool_mutex_enter(); buf_flush_note_modification(block, mtr); - //buf_pool_mutex_exit(); - mutex_exit(&flush_list_mutex); + buf_pool_mutex_exit(); } - else { + mutex_enter(&block->mutex); - } #ifdef UNIV_SYNC_DEBUG rw_lock_s_unlock(&(block->debug_latch)); === modified file 'storage/xtradb/include/buf0flu.ic' --- a/storage/xtradb/include/buf0flu.ic 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/include/buf0flu.ic 2009-05-04 02:45:47 +0000 @@ -59,8 +59,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(buf_pool_mutex_own()); - ut_ad(mutex_own(&flush_list_mutex)); + ut_ad(buf_pool_mutex_own()); ut_ad(mtr->start_lsn != 0); ut_ad(mtr->modifications); @@ -100,8 +99,7 @@ buf_flush_recv_note_modification( ut_ad(rw_lock_own(&(block->lock), RW_LOCK_EX)); #endif /* UNIV_SYNC_DEBUG */ - //buf_pool_mutex_enter(); - mutex_enter(&flush_list_mutex); + buf_pool_mutex_enter(); ut_ad(block->page.newest_modification <= end_lsn); @@ -118,6 +116,5 @@ buf_flush_recv_note_modification( ut_ad(block->page.oldest_modification <= start_lsn); } - //buf_pool_mutex_exit(); - mutex_exit(&flush_list_mutex); + buf_pool_mutex_exit(); } === modified file 'storage/xtradb/include/buf0lru.h' --- a/storage/xtradb/include/buf0lru.h 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/include/buf0lru.h 2009-05-04 02:45:47 +0000 @@ -122,11 +122,10 @@ buf_LRU_free_block( 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, + ibool* buf_pool_mutex_released); /* in: pointer to a variable that will be assigned TRUE if buf_pool_mutex was temporarily released, or NULL */ - ibool have_LRU_mutex); /********************************************************************** Try to free a replaceable block. */ UNIV_INTERN @@ -170,8 +169,7 @@ UNIV_INTERN void buf_LRU_block_free_non_file_page( /*=============================*/ - buf_block_t* block, /* in: block, must not contain a file page */ - ibool have_page_hash_mutex); + buf_block_t* block); /* in: block, must not contain a file page */ /********************************************************************** Adds a block to the LRU list. */ UNIV_INTERN === modified file 'storage/xtradb/include/sync0rw.h' --- a/storage/xtradb/include/sync0rw.h 2009-06-09 15:08:46 +0000 +++ b/storage/xtradb/include/sync0rw.h 2009-06-10 06:51:03 +0000 @@ -361,17 +361,7 @@ Accessor functions for rw lock. */ #ifdef INNODB_RW_LOCKS_USE_ATOMICS UNIV_INLINE ulint -rw_lock_get_s_waiters( -/*==================*/ - rw_lock_t* lock); -UNIV_INLINE -ulint -rw_lock_get_x_waiters( -/*==================*/ - rw_lock_t* lock); -UNIV_INLINE -ulint -rw_lock_get_wx_waiters( +rw_lock_get_waiters( /*================*/ rw_lock_t* lock); #else /* !INNODB_RW_LOCKS_USE_ATOMICS */ @@ -498,16 +488,6 @@ rw_lock_debug_print( rw_lock_debug_t* info); /* in: debug struct */ #endif /* UNIV_SYNC_DEBUG */ -/* -#ifndef INNODB_RW_LOCKS_USE_ATOMICS -#error INNODB_RW_LOCKS_USE_ATOMICS is not defined. Do you use enough new GCC or compatibles? -#error Or do you use exact options for CFLAGS? -#error e.g. (for x86_32): "-m32 -march=i586 -mtune=i686" -#error e.g. (for Sparc_64): "-m64 -mcpu=v9" -#error Otherwise, this build may be slower than normal version. -#endif -*/ - /* NOTE! The structure appears here only for the compiler to know its size. Do not use its fields directly! The structure used in the spin lock implementation of a read-write lock. Several threads may have a shared lock @@ -519,16 +499,7 @@ no new readers will be let in while the struct rw_lock_struct { volatile lint lock_word; /* Holds the state of the lock. */ -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - volatile ulint s_waiters; /* 1: there are waiters (s_lock) */ - volatile ulint x_waiters; /* 1: there are waiters (x_lock) */ - volatile ulint wait_ex_waiters; /* 1: there are waiters (wait_ex) */ - volatile ulint reader_count; /* Number of readers who have locked this - lock in the shared mode */ - volatile ulint writer; -#else volatile ulint waiters;/* 1: there are waiters */ -#endif volatile ibool recursive;/* Default value FALSE which means the lock is non-recursive. The value is typically set to TRUE making normal rw_locks recursive. In @@ -545,16 +516,7 @@ struct rw_lock_struct { /* Thread id of writer thread. Is only guaranteed to have sane and non-stale value iff recursive flag is set. */ -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - volatile ulint writer_count; /* Number of times the same thread has - recursively locked the lock in the exclusive - mode */ - /* Used by sync0arr.c for thread queueing */ - os_event_t s_event; /* Used for s_lock */ - os_event_t x_event; /* Used for x_lock */ -#else os_event_t event; /* Used by sync0arr.c for thread queueing */ -#endif os_event_t wait_ex_event; /* Event for next-writer to wait on. A thread must decrement lock_word before waiting. */ @@ -576,7 +538,7 @@ struct rw_lock_struct { /* last s-lock file/line is not guaranteed to be correct */ const char* last_s_file_name;/* File name where last s-locked */ const char* last_x_file_name;/* File name where last x-locked */ - volatile ibool writer_is_wait_ex; + ibool writer_is_wait_ex; /* This is TRUE if the writer field is RW_LOCK_WAIT_EX; this field is located far from the memory update hotspot fields which === modified file 'storage/xtradb/include/sync0rw.ic' --- a/storage/xtradb/include/sync0rw.ic 2009-06-09 15:08:46 +0000 +++ b/storage/xtradb/include/sync0rw.ic 2009-06-10 06:51:03 +0000 @@ -68,34 +68,6 @@ rw_lock_remove_debug_info( /************************************************************************ Accessor functions for rw lock. */ - -#ifdef INNODB_RW_LOCKS_USE_ATOMICS -UNIV_INLINE -ulint -rw_lock_get_s_waiters( -/*================*/ - /* out: 1 if waiters, 0 otherwise */ - rw_lock_t* lock) /* in: rw-lock */ -{ - return(lock->s_waiters); -} -UNIV_INLINE -ulint -rw_lock_get_x_waiters( -/*================*/ - rw_lock_t* lock) -{ - return(lock->x_waiters); -} -UNIV_INLINE -ulint -rw_lock_get_wx_waiters( -/*================*/ - rw_lock_t* lock) -{ - return(lock->wait_ex_waiters); -} -#else /* !INNODB_RW_LOCKS_USE_ATOMICS */ UNIV_INLINE ulint rw_lock_get_waiters( @@ -105,95 +77,40 @@ rw_lock_get_waiters( { return(lock->waiters); } -#endif /* INNODB_RW_LOCKS_USE_ATOMICS */ - /************************************************************************ Sets lock->waiters to 1. It is not an error if lock->waiters is already 1. On platforms where ATOMIC builtins are used this function enforces a memory barrier. */ -#ifdef INNODB_RW_LOCKS_USE_ATOMICS -UNIV_INLINE -void -rw_lock_set_s_waiter_flag( -/*====================*/ - rw_lock_t* lock) /* in: rw-lock */ -{ - // os_compare_and_swap(&lock->s_waiters, 0, 1); - __sync_lock_test_and_set(&lock->s_waiters, 1); -} -UNIV_INLINE -void -rw_lock_set_x_waiter_flag( -/*====================*/ - rw_lock_t* lock) /* in: rw-lock */ -{ - // os_compare_and_swap(&lock->x_waiters, 0, 1); - __sync_lock_test_and_set(&lock->x_waiters, 1); -} -UNIV_INLINE -void -rw_lock_set_wx_waiter_flag( -/*====================*/ - rw_lock_t* lock) /* in: rw-lock */ -{ - // os_compare_and_swap(&lock->wait_ex_waiters, 0, 1); - __sync_lock_test_and_set(&lock->wait_ex_waiters, 1); -} -#else /* !INNODB_RW_LOCKS_USE_ATOMICS */ UNIV_INLINE void rw_lock_set_waiter_flag( /*====================*/ rw_lock_t* lock) /* in: rw-lock */ { +#ifdef INNODB_RW_LOCKS_USE_ATOMICS + os_compare_and_swap(&lock->waiters, 0, 1); +#else /* INNODB_RW_LOCKS_USE_ATOMICS */ lock->waiters = 1; -} #endif /* INNODB_RW_LOCKS_USE_ATOMICS */ +} /************************************************************************ Resets lock->waiters to 0. It is not an error if lock->waiters is already 0. On platforms where ATOMIC builtins are used this function enforces a memory barrier. */ -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - -UNIV_INLINE -void -rw_lock_reset_s_waiter_flag( -/*======================*/ - rw_lock_t* lock) /* in: rw-lock */ -{ - // os_compare_and_swap(&lock->s_waiters, 1, 0); - __sync_lock_test_and_set(&lock->s_waiters, 0); -} -UNIV_INLINE -void -rw_lock_reset_x_waiter_flag( -/*======================*/ - rw_lock_t* lock) /* in: rw-lock */ -{ - // os_compare_and_swap(&lock->x_waiters, 1, 0); - __sync_lock_test_and_set(&lock->x_waiters, 0); -} -UNIV_INLINE -void -rw_lock_reset_wx_waiter_flag( -/*======================*/ - rw_lock_t* lock) /* in: rw-lock */ -{ - // os_compare_and_swap(&lock->wait_ex_waiters, 1, 0); - __sync_lock_test_and_set(&lock->wait_ex_waiters, 0); -} -#else /* !INNODB_RW_LOCKS_USE_ATOMICS */ UNIV_INLINE void rw_lock_reset_waiter_flag( /*======================*/ rw_lock_t* lock) /* in: rw-lock */ { +#ifdef INNODB_RW_LOCKS_USE_ATOMICS + os_compare_and_swap(&lock->waiters, 1, 0); +#else /* INNODB_RW_LOCKS_USE_ATOMICS */ lock->waiters = 0; -} #endif /* INNODB_RW_LOCKS_USE_ATOMICS */ +} /********************************************************************** Returns the write-status of the lock - this function made more sense @@ -204,17 +121,6 @@ rw_lock_get_writer( /*===============*/ rw_lock_t* lock) { -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - if (lock->writer == RW_LOCK_NOT_LOCKED) { - return(RW_LOCK_NOT_LOCKED); - } - - if (lock->writer_is_wait_ex) { - return(RW_LOCK_WAIT_EX); - } else { - return(RW_LOCK_EX); - } -#else lint lock_word = lock->lock_word; if(lock_word > 0) { /* return NOT_LOCKED in s-lock state, like the writer @@ -226,7 +132,6 @@ rw_lock_get_writer( ut_ad(lock_word > -X_LOCK_DECR); return(RW_LOCK_WAIT_EX); } -#endif } /********************************************************************** @@ -237,9 +142,6 @@ rw_lock_get_reader_count( /*=====================*/ rw_lock_t* lock) { -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - return(lock->reader_count); -#else lint lock_word = lock->lock_word; if(lock_word > 0) { /* s-locked, no x-waiters */ @@ -249,7 +151,6 @@ rw_lock_get_reader_count( return((ulint)(-lock_word)); } return(0); -#endif } #ifndef INNODB_RW_LOCKS_USE_ATOMICS @@ -273,16 +174,12 @@ rw_lock_get_x_lock_count( /* out: value of writer_count */ rw_lock_t* lock) /* in: rw-lock */ { -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - return(lock->writer_count); -#else lint lock_copy = lock->lock_word; /* If there is a reader, lock_word is not divisible by X_LOCK_DECR */ if(lock_copy > 0 || (-lock_copy) % X_LOCK_DECR != 0) { return(0); } return(((-lock_copy) / X_LOCK_DECR) + 1); -#endif } /********************************************************************** @@ -420,26 +317,11 @@ rw_lock_s_lock_low( const char* file_name, /* in: file name where lock requested */ ulint line) /* in: line where requested */ { -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - if (UNIV_LIKELY(rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED)) { - /* try s-lock */ - if(__sync_sub_and_fetch(&(lock->lock_word),1) <= 0) { - /* fail */ - __sync_fetch_and_add(&(lock->lock_word),1); - return(FALSE); /* locking did not succeed */ - } - /* success */ - __sync_fetch_and_add(&(lock->reader_count),1); - } else { - return(FALSE); /* locking did not succeed */ - } -#else /* TODO: study performance of UNIV_LIKELY branch prediction hints. */ if (!rw_lock_lock_word_decr(lock, 1)) { /* Locking did not succeed */ return(FALSE); } -#endif #ifdef UNIV_SYNC_DEBUG rw_lock_add_debug_info(lock, pass, RW_LOCK_SHARED, file_name, line); @@ -464,17 +346,10 @@ rw_lock_s_lock_direct( const char* file_name, /* in: file name where requested */ ulint line) /* in: line where lock requested */ { -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - ut_ad(rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED); - ut_ad(rw_lock_get_reader_count(lock) == 0); - - __sync_fetch_and_add(&(lock->reader_count),1); -#else ut_ad(lock->lock_word == X_LOCK_DECR); /* Indicate there is a new reader by decrementing lock_word */ lock->lock_word--; -#endif lock->last_s_file_name = file_name; lock->last_s_line = line; @@ -497,17 +372,9 @@ rw_lock_x_lock_direct( ulint line) /* in: line where lock requested */ { ut_ad(rw_lock_validate(lock)); -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - ut_ad(rw_lock_get_reader_count(lock) == 0); - ut_ad(rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED); - - lock->writer = RW_LOCK_EX; - __sync_fetch_and_add(&(lock->writer_count),1); -#else ut_ad(lock->lock_word == X_LOCK_DECR); lock->lock_word -= X_LOCK_DECR; -#endif lock->writer_thread = os_thread_get_curr_id(); lock->recursive = TRUE; @@ -581,56 +448,7 @@ rw_lock_x_lock_func_nowait( ibool success; #ifdef INNODB_RW_LOCKS_USE_ATOMICS - success = FALSE; - if ((lock->reader_count == 0) - && rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) { -retry_x_lock: - /* try x-lock */ - if(__sync_sub_and_fetch(&(lock->lock_word), - X_LOCK_DECR) == 0) { - /* success */ - /* try to lock writer */ - if(__sync_lock_test_and_set(&(lock->writer),RW_LOCK_EX) - == RW_LOCK_NOT_LOCKED) { - /* success */ - lock->writer_thread = curr_thread; - lock->recursive = TRUE; - lock->writer_is_wait_ex = FALSE; - /* next function may work as memory barrier */ - relock: - __sync_fetch_and_add(&(lock->writer_count),1); - -#ifdef UNIV_SYNC_DEBUG - rw_lock_add_debug_info(lock, 0, RW_LOCK_EX, file_name, line); -#endif - - lock->last_x_file_name = file_name; - lock->last_x_line = line; - - ut_ad(rw_lock_validate(lock)); - - return(TRUE); - } else { - /* x-unlock */ - __sync_fetch_and_add(&(lock->lock_word), - X_LOCK_DECR); - } - } else { - /* fail (x-lock) */ - if (__sync_fetch_and_add(&(lock->lock_word),X_LOCK_DECR) - == 0) - goto retry_x_lock; - } - } - - if (lock->recursive - && os_thread_eq(lock->writer_thread, curr_thread)) { - goto relock; - } - - //ut_ad(rw_lock_validate(lock)); - - return(FALSE); + success = os_compare_and_swap(&(lock->lock_word), X_LOCK_DECR, 0); #else success = FALSE; @@ -641,6 +459,7 @@ retry_x_lock: } mutex_exit(&(lock->mutex)); +#endif if (success) { rw_lock_set_writer_id_and_recursion_flag(lock, TRUE); @@ -667,7 +486,6 @@ retry_x_lock: ut_ad(rw_lock_validate(lock)); return(TRUE); -#endif } /********************************************************************** @@ -683,31 +501,6 @@ rw_lock_s_unlock_func( #endif ) { -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - ibool last = FALSE; - - ut_a(lock->reader_count > 0); - - /* unlock lock_word */ - __sync_fetch_and_add(&(lock->lock_word),1); - - if(__sync_sub_and_fetch(&(lock->reader_count),1) == 0) { - last = TRUE; - } - -#ifdef UNIV_SYNC_DEBUG - rw_lock_remove_debug_info(lock, pass, RW_LOCK_SHARED); -#endif - - if (UNIV_UNLIKELY(last && __sync_lock_test_and_set(&lock->wait_ex_waiters, 0))) { - os_event_set(lock->wait_ex_event); - sync_array_object_signalled(sync_primary_wait_array); - } - else if (UNIV_UNLIKELY(last && __sync_lock_test_and_set(&lock->x_waiters, 0))) { - os_event_set(lock->x_event); - sync_array_object_signalled(sync_primary_wait_array); - } -#else ut_ad((lock->lock_word % X_LOCK_DECR) != 0); #ifdef UNIV_SYNC_DEBUG @@ -724,7 +517,6 @@ rw_lock_s_unlock_func( sync_array_object_signalled(sync_primary_wait_array); } -#endif ut_ad(rw_lock_validate(lock)); @@ -742,19 +534,6 @@ rw_lock_s_unlock_direct( /*====================*/ rw_lock_t* lock) /* in: rw-lock */ { -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - ut_ad(lock->reader_count > 0); - - __sync_sub_and_fetch(&(lock->reader_count),1); - -#ifdef UNIV_SYNC_DEBUG - rw_lock_remove_debug_info(lock, 0, RW_LOCK_SHARED); -#endif - - ut_ad(!lock->s_waiters); - ut_ad(!lock->x_waiters); - ut_ad(!lock->wait_ex_waiters); -#else ut_ad(lock->lock_word < X_LOCK_DECR); #ifdef UNIV_SYNC_DEBUG @@ -765,7 +544,6 @@ rw_lock_s_unlock_direct( lock->lock_word++; ut_ad(!lock->waiters); -#endif ut_ad(rw_lock_validate(lock)); #ifdef UNIV_SYNC_PERF_STAT rw_s_exit_count++; @@ -785,49 +563,6 @@ rw_lock_x_unlock_func( #endif ) { -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - ibool last = FALSE; - ibool s_sg = FALSE; - ibool x_sg = FALSE; - - ut_ad(lock->writer_count > 0); - - if(__sync_sub_and_fetch(&(lock->writer_count),1) == 0) { - last = TRUE; - } - - if (last) { - /* unlock lock_word */ - __sync_fetch_and_add(&(lock->lock_word),X_LOCK_DECR); - - lock->recursive = FALSE; - /* FIXME: It is a value of bad manners for pthread. - But we shouldn't keep an ID of not-owner. */ - lock->writer_thread = -1; - __sync_lock_test_and_set(&(lock->writer),RW_LOCK_NOT_LOCKED); - } - -#ifdef UNIV_SYNC_DEBUG - rw_lock_remove_debug_info(lock, pass, RW_LOCK_EX); -#endif - if (last) { - if(__sync_lock_test_and_set(&lock->s_waiters, 0)){ - s_sg = TRUE; - } - if(__sync_lock_test_and_set(&lock->x_waiters, 0)){ - x_sg = TRUE; - } - } - - if (UNIV_UNLIKELY(s_sg)) { - os_event_set(lock->s_event); - sync_array_object_signalled(sync_primary_wait_array); - } - if (UNIV_UNLIKELY(x_sg)) { - os_event_set(lock->x_event); - sync_array_object_signalled(sync_primary_wait_array); - } -#else ut_ad((lock->lock_word % X_LOCK_DECR) == 0); /* lock->recursive flag also indicates if lock->writer_thread is @@ -858,7 +593,6 @@ rw_lock_x_unlock_func( } } -#endif ut_ad(rw_lock_validate(lock)); #ifdef UNIV_SYNC_PERF_STAT @@ -878,19 +612,6 @@ rw_lock_x_unlock_direct( /* Reset the exclusive lock if this thread no longer has an x-mode lock */ -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - if(__sync_sub_and_fetch(&(lock->writer_count),1) == 0) { - lock->writer = RW_LOCK_NOT_LOCKED; - } - -#ifdef UNIV_SYNC_DEBUG - rw_lock_remove_debug_info(lock, 0, RW_LOCK_EX); -#endif - - ut_ad(!lock->s_waiters); - ut_ad(!lock->x_waiters); - ut_ad(!lock->wait_ex_waiters); -#else ut_ad((lock->lock_word % X_LOCK_DECR) == 0); #ifdef UNIV_SYNC_DEBUG @@ -906,7 +627,6 @@ rw_lock_x_unlock_direct( lock->lock_word += X_LOCK_DECR; ut_ad(!lock->waiters); -#endif ut_ad(rw_lock_validate(lock)); #ifdef UNIV_SYNC_PERF_STAT === modified file 'storage/xtradb/include/trx0sys.h' --- a/storage/xtradb/include/trx0sys.h 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/include/trx0sys.h 2009-04-07 20:51:15 +0000 @@ -49,6 +49,9 @@ or there was no master log position info extern char trx_sys_mysql_master_log_name[]; extern ib_int64_t trx_sys_mysql_master_log_pos; +extern char trx_sys_mysql_relay_log_name[]; +extern ib_int64_t trx_sys_mysql_relay_log_pos; + /* If this MySQL server uses binary logging, after InnoDB has been inited and if it has done a crash recovery, we store the binlog file name and position here. If .._pos is -1, it means there was no binlog position info inside @@ -290,7 +293,7 @@ UNIV_INTERN void trx_sys_update_mysql_binlog_offset( /*===============================*/ - const char* file_name,/* in: MySQL log file name */ + const char* file_name_in,/* in: MySQL log file name */ ib_int64_t offset, /* in: position in that log file */ ulint field, /* in: offset of the MySQL log info field in the trx sys header */ @@ -421,6 +424,7 @@ therefore 256; each slot is currently 8 #define TRX_SYS_N_RSEGS 256 #define TRX_SYS_MYSQL_LOG_NAME_LEN 512 +#define TRX_SYS_MYSQL_MASTER_LOG_NAME_LEN 480 /* (500 - 12) is dead line. */ #define TRX_SYS_MYSQL_LOG_MAGIC_N 873422344 #if UNIV_PAGE_SIZE < 4096 @@ -429,6 +433,7 @@ therefore 256; each slot is currently 8 /* The offset of the MySQL replication info in the trx system header; this contains the same fields as TRX_SYS_MYSQL_LOG_INFO below */ #define TRX_SYS_MYSQL_MASTER_LOG_INFO (UNIV_PAGE_SIZE - 2000) +#define TRX_SYS_MYSQL_RELAY_LOG_INFO (UNIV_PAGE_SIZE - 1500) /* The offset of the MySQL binlog offset info in the trx system header */ #define TRX_SYS_MYSQL_LOG_INFO (UNIV_PAGE_SIZE - 1000) === modified file 'storage/xtradb/include/trx0trx.h' --- a/storage/xtradb/include/trx0trx.h 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/include/trx0trx.h 2009-04-07 20:51:15 +0000 @@ -579,6 +579,21 @@ struct trx_struct{ ib_int64_t mysql_log_offset;/* if MySQL binlog is used, this field contains the end offset of the binlog entry */ + const char* mysql_master_log_file_name; + /* if the database server is a MySQL + replication slave, we have here the + master binlog name up to which + replication has processed; otherwise + this is a pointer to a null + character */ + ib_int64_t mysql_master_log_pos; + /* if the database server is a MySQL + replication slave, this is the + position in the log file up to which + replication has processed */ + const char* mysql_relay_log_file_name; + ib_int64_t mysql_relay_log_pos; + os_thread_id_t mysql_thread_id;/* id of the MySQL thread associated with this transaction object */ ulint mysql_process_no;/* since in Linux, 'top' reports === modified file 'storage/xtradb/include/univ.i' --- a/storage/xtradb/include/univ.i 2009-06-09 15:08:46 +0000 +++ b/storage/xtradb/include/univ.i 2009-06-10 06:51:03 +0000 @@ -35,7 +35,7 @@ Created 1/20/1994 Heikki Tuuri #define INNODB_VERSION_MAJOR 1 #define INNODB_VERSION_MINOR 0 #define INNODB_VERSION_BUGFIX 3 -#define PERCONA_INNODB_VERSION 3 +#define PERCONA_INNODB_VERSION 5a /* The following is the InnoDB version as shown in SELECT plugin_version FROM information_schema.plugins; === modified file 'storage/xtradb/include/ut0auxconf.h' --- a/storage/xtradb/include/ut0auxconf.h 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/include/ut0auxconf.h 2009-04-27 04:54:14 +0000 @@ -12,8 +12,3 @@ If by any chance Makefile.in and ./confi the hack from Makefile.in wiped away then the "real" check from plug.in will take over. */ -/* This is temprary fix for http://bugs.mysql.com/43740 */ -/* force to enable */ -#ifdef HAVE_GCC_ATOMIC_BUILTINS -#define HAVE_ATOMIC_PTHREAD_T -#endif === modified file 'storage/xtradb/sync/sync0arr.c' --- a/storage/xtradb/sync/sync0arr.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/sync/sync0arr.c 2009-04-27 04:54:14 +0000 @@ -331,15 +331,8 @@ sync_cell_get_event( return(((mutex_t *) cell->wait_object)->event); } else if (type == RW_LOCK_WAIT_EX) { return(((rw_lock_t *) cell->wait_object)->wait_ex_event); -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - } else if (type == RW_LOCK_SHARED) { - return(((rw_lock_t *) cell->wait_object)->s_event); - } else { /* RW_LOCK_EX */ - return(((rw_lock_t *) cell->wait_object)->x_event); -#else } else { /* RW_LOCK_SHARED and RW_LOCK_EX wait on the same event */ return(((rw_lock_t *) cell->wait_object)->event); -#endif } } @@ -483,7 +476,7 @@ sync_array_cell_print( fprintf(file, "--Thread %lu has waited at %s line %lu" - " for %.2f seconds the semaphore:\n", + " for %#.5g seconds the semaphore:\n", (ulong) os_thread_pf(cell->thread), cell->file, (ulong) cell->line, difftime(time(NULL), cell->reservation_time)); @@ -510,7 +503,7 @@ sync_array_cell_print( || type == RW_LOCK_WAIT_EX || type == RW_LOCK_SHARED) { - fputs(type == RW_LOCK_SHARED ? "S-lock on" : "X-lock on", file); + fputs(type == RW_LOCK_EX ? "X-lock on" : "S-lock on", file); rwlock = cell->old_wait_rw_lock; @@ -530,21 +523,12 @@ sync_array_cell_print( } fprintf(file, -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - "number of readers %lu, s_waiters flag %lu, x_waiters flag %lu, " -#else "number of readers %lu, waiters flag %lu, " -#endif "lock_word: %lx\n" "Last time read locked in file %s line %lu\n" "Last time write locked in file %s line %lu\n", (ulong) rw_lock_get_reader_count(rwlock), -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - (ulong) rwlock->s_waiters, - (ulong) (rwlock->x_waiters || rwlock->wait_ex_waiters), -#else (ulong) rwlock->waiters, -#endif rwlock->lock_word, rwlock->last_s_file_name, (ulong) rwlock->last_s_line, === modified file 'storage/xtradb/sync/sync0rw.c' --- a/storage/xtradb/sync/sync0rw.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/sync/sync0rw.c 2009-04-27 04:54:14 +0000 @@ -250,17 +250,7 @@ rw_lock_create_func( #endif /* INNODB_RW_LOCKS_USE_ATOMICS */ lock->lock_word = X_LOCK_DECR; -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - lock->s_waiters = 0; - lock->x_waiters = 0; - lock->wait_ex_waiters = 0; - lock->writer = RW_LOCK_NOT_LOCKED; - lock->writer_count = 0; - lock->reader_count = 0; - lock->writer_is_wait_ex = FALSE; -#else lock->waiters = 0; -#endif /* We set this value to signify that lock->writer_thread contains garbage at initialization and cannot be used for @@ -283,12 +273,7 @@ rw_lock_create_func( lock->last_x_file_name = "not yet reserved"; lock->last_s_line = 0; lock->last_x_line = 0; -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - lock->s_event = os_event_create(NULL); - lock->x_event = os_event_create(NULL); -#else lock->event = os_event_create(NULL); -#endif lock->wait_ex_event = os_event_create(NULL); mutex_enter(&rw_lock_list_mutex); @@ -314,15 +299,7 @@ rw_lock_free( rw_lock_t* lock) /* in: rw-lock */ { ut_ad(rw_lock_validate(lock)); -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - ut_a(rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED); - ut_a(rw_lock_get_s_waiters(lock) == 0); - ut_a(rw_lock_get_x_waiters(lock) == 0); - ut_a(rw_lock_get_wx_waiters(lock) == 0); - ut_a(rw_lock_get_reader_count(lock) == 0); -#else ut_a(lock->lock_word == X_LOCK_DECR); -#endif lock->magic_n = 0; @@ -331,12 +308,7 @@ rw_lock_free( #endif /* INNODB_RW_LOCKS_USE_ATOMICS */ mutex_enter(&rw_lock_list_mutex); -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - os_event_free(lock->s_event); - os_event_free(lock->x_event); -#else os_event_free(lock->event); -#endif os_event_free(lock->wait_ex_event); @@ -364,23 +336,12 @@ rw_lock_validate( { ut_a(lock); -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - ut_a(lock->magic_n == RW_LOCK_MAGIC_N); - - ulint waiters = rw_lock_get_s_waiters(lock); - ut_a(waiters == 0 || waiters == 1); - waiters = rw_lock_get_x_waiters(lock); - ut_a(waiters == 0 || waiters == 1); - waiters = rw_lock_get_wx_waiters(lock); - ut_a(waiters == 0 || waiters == 1); -#else ulint waiters = rw_lock_get_waiters(lock); lint lock_word = lock->lock_word; ut_a(lock->magic_n == RW_LOCK_MAGIC_N); ut_a(waiters == 0 || waiters == 1); ut_a(lock_word > -X_LOCK_DECR ||(-lock_word) % X_LOCK_DECR == 0); -#endif return(TRUE); } @@ -410,12 +371,7 @@ rw_lock_s_lock_spin( lock_loop: /* Spin waiting for the writer field to become free */ -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - while (i < SYNC_SPIN_ROUNDS - && rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED) { -#else while (i < SYNC_SPIN_ROUNDS && lock->lock_word <= 0) { -#endif if (srv_spin_wait_delay) { ut_delay(ut_rnd_interval(0, srv_spin_wait_delay)); } @@ -456,29 +412,12 @@ lock_loop: /* Set waiters before checking lock_word to ensure wake-up signal is sent. This may lead to some unnecessary signals. */ -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - rw_lock_set_s_waiter_flag(lock); -#else rw_lock_set_waiter_flag(lock); -#endif -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - for (i = 0; i < 4; i++) { -#endif if (TRUE == rw_lock_s_lock_low(lock, pass, file_name, line)) { sync_array_free_cell(sync_primary_wait_array, index); return; /* Success */ } -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - } - - /* If wait_ex_waiter stalls, wakes it. */ - if (lock->reader_count == 0 - && __sync_lock_test_and_set(&lock->wait_ex_waiters, 0)) { - os_event_set(lock->wait_ex_event); - sync_array_object_signalled(sync_primary_wait_array); - } -#endif if (srv_print_latch_waits) { fprintf(stderr, @@ -517,12 +456,7 @@ rw_lock_x_lock_move_ownership( { ut_ad(rw_lock_is_locked(lock, RW_LOCK_EX)); -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - lock->writer_thread = os_thread_get_curr_id(); - lock->recursive = TRUE; -#else rw_lock_set_writer_id_and_recursion_flag(lock, TRUE); -#endif } /********************************************************************** @@ -596,11 +530,7 @@ rw_lock_x_lock_wait( /********************************************************************** Low-level function for acquiring an exclusive lock. */ UNIV_INLINE -#ifdef INNODB_RW_LOCKS_USE_ATOMICS -ulint -#else ibool -#endif rw_lock_x_lock_low( /*===============*/ /* out: RW_LOCK_NOT_LOCKED if did @@ -613,90 +543,6 @@ rw_lock_x_lock_low( { os_thread_id_t curr_thread = os_thread_get_curr_id(); -#ifdef INNODB_RW_LOCKS_USE_ATOMICS -retry_writer: - /* try to lock writer */ - if(__sync_lock_test_and_set(&(lock->writer),RW_LOCK_EX) - == RW_LOCK_NOT_LOCKED) { - /* success */ - /* obtain RW_LOCK_WAIT_EX right */ - lock->writer_thread = curr_thread; - lock->recursive = pass ? FALSE : TRUE; - lock->writer_is_wait_ex = TRUE; - /* atomic operation may be safer about memory order. */ - __sync_synchronize(); -#ifdef UNIV_SYNC_DEBUG - rw_lock_add_debug_info(lock, pass, RW_LOCK_WAIT_EX, - file_name, line); -#endif - } - - if (!os_thread_eq(lock->writer_thread, curr_thread)) { - return(RW_LOCK_NOT_LOCKED); - } - - switch(rw_lock_get_writer(lock)) { - case RW_LOCK_WAIT_EX: - /* have right to try x-lock */ -retry_x_lock: - /* try x-lock */ - if(__sync_sub_and_fetch(&(lock->lock_word), - X_LOCK_DECR) == 0) { - /* success */ - lock->recursive = pass ? FALSE : TRUE; - lock->writer_is_wait_ex = FALSE; - __sync_fetch_and_add(&(lock->writer_count),1); - -#ifdef UNIV_SYNC_DEBUG - rw_lock_remove_debug_info(lock, pass, RW_LOCK_WAIT_EX); - rw_lock_add_debug_info(lock, pass, RW_LOCK_EX, - file_name, line); -#endif - - lock->last_x_file_name = file_name; - lock->last_x_line = line; - - /* Locking succeeded, we may return */ - return(RW_LOCK_EX); - } else if(__sync_fetch_and_add(&(lock->lock_word), - X_LOCK_DECR) == 0) { - /* retry x-lock */ - goto retry_x_lock; - } - - /* There are readers, we have to wait */ - return(RW_LOCK_WAIT_EX); - - break; - - case RW_LOCK_EX: - /* already have x-lock */ - if (lock->recursive && (pass == 0)) { - __sync_fetch_and_add(&(lock->writer_count),1); - -#ifdef UNIV_SYNC_DEBUG - rw_lock_add_debug_info(lock, pass, RW_LOCK_EX, file_name, - line); -#endif - - lock->last_x_file_name = file_name; - lock->last_x_line = line; - - /* Locking succeeded, we may return */ - return(RW_LOCK_EX); - } - - return(RW_LOCK_NOT_LOCKED); - - break; - - default: /* RW_LOCK_NOT_LOCKED? maybe impossible */ - goto retry_writer; - } - - /* Locking did not succeed */ - return(RW_LOCK_NOT_LOCKED); -#else if (rw_lock_lock_word_decr(lock, X_LOCK_DECR)) { /* lock->recursive also tells us if the writer_thread @@ -734,7 +580,6 @@ retry_x_lock: lock->last_x_line = (unsigned int) line; return(TRUE); -#endif } /********************************************************************** @@ -759,55 +604,18 @@ rw_lock_x_lock_func( ulint index; /* index of the reserved wait cell */ ulint i; /* spin round count */ ibool spinning = FALSE; -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - ulint state = RW_LOCK_NOT_LOCKED; /* lock state acquired */ - ulint prev_state = RW_LOCK_NOT_LOCKED; -#endif ut_ad(rw_lock_validate(lock)); i = 0; lock_loop: -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - prev_state = state; - state = rw_lock_x_lock_low(lock, pass, file_name, line); - -lock_loop_2: - if (state != prev_state) i=0; /* if progress, reset counter. */ - if (state == RW_LOCK_EX) { -#else if (rw_lock_x_lock_low(lock, pass, file_name, line)) { -#endif rw_x_spin_round_count += i; return; /* Locking succeeded */ -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - } else if (state == RW_LOCK_WAIT_EX) { - - if (!spinning) { - spinning = TRUE; - rw_x_spin_wait_count++; - } - - /* Spin waiting for the reader count field to become zero */ - while (i < SYNC_SPIN_ROUNDS - && lock->lock_word != X_LOCK_DECR) { - if (srv_spin_wait_delay) { - ut_delay(ut_rnd_interval(0, - srv_spin_wait_delay)); - } - - i++; - } - if (i == SYNC_SPIN_ROUNDS) { - os_thread_yield(); - } else { - goto lock_loop; - } -#endif } else { if (!spinning) { @@ -817,11 +625,7 @@ lock_loop_2: /* Spin waiting for the lock_word to become free */ while (i < SYNC_SPIN_ROUNDS -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - && rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED) { -#else && lock->lock_word <= 0) { -#endif if (srv_spin_wait_delay) { ut_delay(ut_rnd_interval(0, srv_spin_wait_delay)); @@ -848,46 +652,18 @@ lock_loop_2: sync_array_reserve_cell(sync_primary_wait_array, lock, -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - (state == RW_LOCK_WAIT_EX) - ? RW_LOCK_WAIT_EX : RW_LOCK_EX, -#else RW_LOCK_EX, -#endif file_name, line, &index); /* Waiters must be set before checking lock_word, to ensure signal is sent. This could lead to a few unnecessary wake-up signals. */ -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - if (state == RW_LOCK_WAIT_EX) { - rw_lock_set_wx_waiter_flag(lock); - } else { - rw_lock_set_x_waiter_flag(lock); - } -#else rw_lock_set_waiter_flag(lock); -#endif -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - for (i = 0; i < 4; i++) { - prev_state = state; - state = rw_lock_x_lock_low(lock, pass, file_name, line); - if (state == RW_LOCK_EX) { - sync_array_free_cell(sync_primary_wait_array, index); - return; /* Locking succeeded */ - } else if (state != prev_state) { - /* retry! */ - sync_array_free_cell(sync_primary_wait_array, index); - goto lock_loop_2; - } - } -#else if (rw_lock_x_lock_low(lock, pass, file_name, line)) { sync_array_free_cell(sync_primary_wait_array, index); return; /* Locking succeeded */ } -#endif if (srv_print_latch_waits) { fprintf(stderr, @@ -1138,24 +914,11 @@ rw_lock_list_print_info( fprintf(file, "RW-LOCK: %p ", (void*) lock); -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - if (rw_lock_get_s_waiters(lock)) { - fputs(" s_waiters for the lock exist", file); - } - if (rw_lock_get_x_waiters(lock)) { - fputs(" x_waiters for the lock exist", file); - } - if (rw_lock_get_wx_waiters(lock)) { - fputs(" wait_ex_waiters for the lock exist", file); - } - putc('\n', file); -#else if (rw_lock_get_waiters(lock)) { fputs(" Waiters for the lock exist\n", file); } else { putc('\n', file); } -#endif info = UT_LIST_GET_FIRST(lock->debug_list); while (info != NULL) { @@ -1194,24 +957,11 @@ rw_lock_print( #endif if (lock->lock_word != X_LOCK_DECR) { -#ifdef INNODB_RW_LOCKS_USE_ATOMICS - if (rw_lock_get_s_waiters(lock)) { - fputs(" s_waiters for the lock exist", stderr); - } - if (rw_lock_get_x_waiters(lock)) { - fputs(" x_waiters for the lock exist", stderr); - } - if (rw_lock_get_wx_waiters(lock)) { - fputs(" wait_ex_waiters for the lock exist", stderr); - } - putc('\n', stderr); -#else if (rw_lock_get_waiters(lock)) { fputs(" Waiters for the lock exist\n", stderr); } else { putc('\n', stderr); } -#endif info = UT_LIST_GET_FIRST(lock->debug_list); while (info != NULL) { === modified file 'storage/xtradb/trx/trx0sys.c' --- a/storage/xtradb/trx/trx0sys.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/trx/trx0sys.c 2009-04-25 20:23:06 +0000 @@ -69,9 +69,12 @@ file name and position here. We have suc up to this position. If .._pos is -1, it means no crash recovery was needed, or there was no master log position info inside InnoDB. */ -UNIV_INTERN char trx_sys_mysql_master_log_name[TRX_SYS_MYSQL_LOG_NAME_LEN]; +UNIV_INTERN char trx_sys_mysql_master_log_name[TRX_SYS_MYSQL_MASTER_LOG_NAME_LEN]; UNIV_INTERN ib_int64_t trx_sys_mysql_master_log_pos = -1; +UNIV_INTERN char trx_sys_mysql_relay_log_name[TRX_SYS_MYSQL_MASTER_LOG_NAME_LEN]; +UNIV_INTERN ib_int64_t trx_sys_mysql_relay_log_pos = -1; + /* If this MySQL server uses binary logging, after InnoDB has been inited and if it has done a crash recovery, we store the binlog file name and position here. If .._pos is -1, it means there was no binlog position info inside @@ -661,19 +664,24 @@ UNIV_INTERN void trx_sys_update_mysql_binlog_offset( /*===============================*/ - const char* file_name,/* in: MySQL log file name */ + const char* file_name_in,/* in: MySQL log file name */ ib_int64_t offset, /* in: position in that log file */ ulint field, /* in: offset of the MySQL log info field in the trx sys header */ mtr_t* mtr) /* in: mtr */ { trx_sysf_t* sys_header; + const char* file_name; - if (ut_strlen(file_name) >= TRX_SYS_MYSQL_LOG_NAME_LEN) { + if (ut_strlen(file_name_in) >= TRX_SYS_MYSQL_MASTER_LOG_NAME_LEN) { /* We cannot fit the name to the 512 bytes we have reserved */ + /* -> To store relay log file information, file_name must fit to the 480 bytes */ - return; + file_name = ""; + } + else { + file_name = file_name_in; } sys_header = trx_sysf_get(mtr); @@ -834,13 +842,26 @@ trx_sys_print_mysql_master_log_pos(void) + TRX_SYS_MYSQL_LOG_OFFSET_LOW), sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO + TRX_SYS_MYSQL_LOG_NAME); + + fprintf(stderr, + "InnoDB: and relay log file\n" + "InnoDB: position %lu %lu, file name %s\n", + (ulong) mach_read_from_4(sys_header + + TRX_SYS_MYSQL_RELAY_LOG_INFO + + TRX_SYS_MYSQL_LOG_OFFSET_HIGH), + (ulong) mach_read_from_4(sys_header + + TRX_SYS_MYSQL_RELAY_LOG_INFO + + TRX_SYS_MYSQL_LOG_OFFSET_LOW), + sys_header + TRX_SYS_MYSQL_RELAY_LOG_INFO + + TRX_SYS_MYSQL_LOG_NAME); + /* Copy the master log position info to global variables we can use in ha_innobase.cc to initialize glob_mi to right values */ ut_memcpy(trx_sys_mysql_master_log_name, sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO + TRX_SYS_MYSQL_LOG_NAME, - TRX_SYS_MYSQL_LOG_NAME_LEN); + TRX_SYS_MYSQL_MASTER_LOG_NAME_LEN); trx_sys_mysql_master_log_pos = (((ib_int64_t) mach_read_from_4( @@ -849,6 +870,19 @@ trx_sys_print_mysql_master_log_pos(void) + ((ib_int64_t) mach_read_from_4( sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO + TRX_SYS_MYSQL_LOG_OFFSET_LOW)); + + ut_memcpy(trx_sys_mysql_relay_log_name, + sys_header + TRX_SYS_MYSQL_RELAY_LOG_INFO + + TRX_SYS_MYSQL_LOG_NAME, + TRX_SYS_MYSQL_MASTER_LOG_NAME_LEN); + + trx_sys_mysql_relay_log_pos + = (((ib_int64_t) mach_read_from_4( + sys_header + TRX_SYS_MYSQL_RELAY_LOG_INFO + + TRX_SYS_MYSQL_LOG_OFFSET_HIGH)) << 32) + + ((ib_int64_t) mach_read_from_4( + sys_header + TRX_SYS_MYSQL_RELAY_LOG_INFO + + TRX_SYS_MYSQL_LOG_OFFSET_LOW)); mtr_commit(&mtr); } === modified file 'storage/xtradb/trx/trx0trx.c' --- a/storage/xtradb/trx/trx0trx.c 2009-03-26 06:11:11 +0000 +++ b/storage/xtradb/trx/trx0trx.c 2009-04-07 20:51:15 +0000 @@ -127,6 +127,10 @@ trx_create( trx->mysql_log_file_name = NULL; trx->mysql_log_offset = 0; + trx->mysql_master_log_file_name = ""; + trx->mysql_master_log_pos = 0; + trx->mysql_relay_log_file_name = ""; + trx->mysql_relay_log_pos = 0; mutex_create(&trx->undo_mutex, SYNC_TRX_UNDO); @@ -792,6 +796,19 @@ trx_commit_off_kernel( trx->mysql_log_file_name = NULL; } + if (trx->mysql_master_log_file_name[0] != '\0') { + /* This database server is a MySQL replication slave */ + trx_sys_update_mysql_binlog_offset( + trx->mysql_relay_log_file_name, + trx->mysql_relay_log_pos, + TRX_SYS_MYSQL_RELAY_LOG_INFO, &mtr); + trx_sys_update_mysql_binlog_offset( + trx->mysql_master_log_file_name, + trx->mysql_master_log_pos, + TRX_SYS_MYSQL_MASTER_LOG_INFO, &mtr); + trx->mysql_master_log_file_name = ""; + } + /* The following call commits the mini-transaction, making the whole transaction committed in the file-based world, at this log sequence number. The transaction becomes 'durable' when