60 #define BUF_LRU_OLD_TOLERANCE 20
65 #define BUF_LRU_NON_OLD_MIN_LEN 5
66 #if BUF_LRU_NON_OLD_MIN_LEN >= BUF_LRU_OLD_MIN_LEN
67 # error "BUF_LRU_NON_OLD_MIN_LEN >= BUF_LRU_OLD_MIN_LEN"
73 #define BUF_LRU_DROP_SEARCH_HASH_SIZE 1024
77 static ibool buf_lru_switched_on_innodb_mon = FALSE;
93 #define BUF_LRU_STAT_N_INTERVAL 50
97 #define BUF_LRU_IO_TO_UNZIP_FACTOR 50
104 static ulint buf_LRU_stat_arr_ind;
119 UNIV_INTERN uint buf_LRU_old_threshold_ms;
134 buf_LRU_block_remove_hashed_page(
145 buf_LRU_block_free_hashed_page(
156 buf_LRU_evict_from_unzip_LRU(
186 io_avg = buf_LRU_stat_sum.
io / BUF_LRU_STAT_N_INTERVAL
187 + buf_LRU_stat_cur.
io;
188 unzip_avg = buf_LRU_stat_sum.
unzip / BUF_LRU_STAT_N_INTERVAL
189 + buf_LRU_stat_cur.
unzip;
195 return(unzip_avg <= io_avg * BUF_LRU_IO_TO_UNZIP_FACTOR);
203 buf_LRU_drop_page_hash_batch(
214 ut_ad(count <= BUF_LRU_DROP_SEARCH_HASH_SIZE);
216 for (i = 0; i < count; ++i) {
217 btr_search_drop_page_hash_when_freed(space_id, zip_size,
229 buf_LRU_drop_page_hash_for_tablespace(
239 zip_size = fil_space_get_zip_size(
id);
241 if (UNIV_UNLIKELY(zip_size == ULINT_UNDEFINED)) {
247 page_arr =
static_cast<unsigned long *
>(
ut_malloc(
248 sizeof(ulint) * BUF_LRU_DROP_SEARCH_HASH_SIZE));
256 while (bpage != NULL) {
260 mutex_enter(block_mutex);
266 || bpage->
space !=
id
271 mutex_exit(block_mutex);
280 page_arr[num_entries] = bpage->
offset;
281 mutex_exit(block_mutex);
282 ut_a(num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE);
285 if (num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE) {
293 buf_LRU_drop_page_hash_batch(
294 id, zip_size, page_arr, num_entries);
300 mutex_exit(block_mutex);
318 ut_a(num_entries == 0);
326 buf_LRU_drop_page_hash_batch(
id, zip_size, page_arr, num_entries);
336 buf_LRU_invalidate_tablespace_buf_pool_instance(
351 while (bpage != NULL) {
353 ibool prev_bpage_buf_fix = FALSE;
374 mutex_enter(block_mutex);
389 if (buf_debug_prints) {
391 "Dropping space %lu page %lu\n",
400 if (UNIV_LIKELY(prev_bpage != NULL)) {
421 ut_ad(mutex_own(block_mutex));
422 prev_bpage_buf_fix = TRUE;
438 mutex_exit(block_mutex);
443 btr_search_drop_page_hash_when_freed(
444 id, zip_size, page_no);
450 buf_flush_remove(bpage);
455 if (buf_LRU_block_remove_hashed_page(bpage, TRUE)
464 ut_ad(!mutex_own(block_mutex));
466 if (prev_bpage_buf_fix) {
474 mutex_enter(block_mutex);
477 mutex_exit(block_mutex);
480 goto next_page_no_mutex;
483 mutex_exit(block_mutex);
504 buf_LRU_invalidate_tablespace(
520 buf_LRU_drop_page_hash_for_tablespace(buf_pool,
id);
521 buf_LRU_invalidate_tablespace_buf_pool_instance(buf_pool,
id);
529 buf_LRU_insert_zip_clean(
564 buf_LRU_free_from_unzip_LRU_list(
587 if (UNIV_UNLIKELY(n_iterations >= 5)
588 || !buf_LRU_evict_from_unzip_LRU(buf_pool)) {
593 distance = 100 + (n_iterations
597 UNIV_LIKELY(block != NULL) && UNIV_LIKELY(distance > 0);
603 ut_ad(block->in_unzip_LRU_list);
606 mutex_enter(&block->
mutex);
607 freed = buf_LRU_free_block(&block->
page, FALSE, NULL);
608 mutex_exit(&block->
mutex);
638 buf_LRU_free_from_common_LRU_list(
654 distance = 100 + (n_iterations * buf_pool->
curr_size) / 10;
657 UNIV_LIKELY(bpage != NULL) && UNIV_LIKELY(distance > 0);
666 ut_ad(bpage->in_LRU_list);
668 mutex_enter(block_mutex);
670 freed = buf_LRU_free_block(bpage, TRUE, NULL);
671 mutex_exit(block_mutex);
707 buf_LRU_search_and_free_block(
725 freed = buf_LRU_free_from_unzip_LRU_list(buf_pool, n_iterations);
728 freed = buf_LRU_free_from_common_LRU_list(
729 buf_pool, n_iterations);
753 buf_LRU_try_free_flushed_blocks(
758 if (buf_pool == NULL) {
763 buf_LRU_try_free_flushed_blocks(buf_pool);
772 buf_LRU_search_and_free_block(buf_pool, 1);
788 buf_LRU_buf_pool_running_out(
void)
821 buf_LRU_get_free_only(
834 ut_d(block->
page.in_free_list = FALSE);
840 mutex_enter(&block->
mutex);
843 UNIV_MEM_ALLOC(block->
frame, UNIV_PAGE_SIZE);
847 mutex_exit(&block->
mutex);
860 buf_LRU_get_free_block(
868 ulint n_iterations = 1;
869 ibool mon_value_was = FALSE;
870 ibool started_monitor = FALSE;
879 " InnoDB: ERROR: over 95 percent of the buffer pool"
881 "InnoDB: lock heaps or the adaptive hash index!"
883 "InnoDB: transactions do not set too many row locks.\n"
884 "InnoDB: Your buffer pool size is %lu MB."
885 " Maybe you should make\n"
886 "InnoDB: the buffer pool bigger?\n"
887 "InnoDB: We intentionally generate a seg fault"
888 " to print a stack trace\n"
889 "InnoDB: on Linux!\n",
891 / (1024 * 1024 / UNIV_PAGE_SIZE)));
900 if (!buf_lru_switched_on_innodb_mon) {
908 " InnoDB: WARNING: over 67 percent of"
909 " the buffer pool is occupied by\n"
910 "InnoDB: lock heaps or the adaptive"
911 " hash index! Check that your\n"
912 "InnoDB: transactions do not set too many"
914 "InnoDB: Your buffer pool size is %lu MB."
915 " Maybe you should make\n"
916 "InnoDB: the buffer pool bigger?\n"
917 "InnoDB: Starting the InnoDB Monitor to print"
918 " diagnostics, including\n"
919 "InnoDB: lock heap and hash index sizes.\n",
921 / (1024 * 1024 / UNIV_PAGE_SIZE)));
923 buf_lru_switched_on_innodb_mon = TRUE;
924 srv_print_innodb_monitor = TRUE;
927 }
else if (buf_lru_switched_on_innodb_mon) {
934 buf_lru_switched_on_innodb_mon = FALSE;
935 srv_print_innodb_monitor = FALSE;
939 block = buf_LRU_get_free_only(buf_pool);
951 if (UNIV_UNLIKELY(zip_size)) {
956 buf_pool, zip_size, &lru));
958 UNIV_MEM_DESC(block->
page.
zip.
data, zip_size, block);
966 if (started_monitor) {
967 srv_print_innodb_monitor = mon_value_was;
978 freed = buf_LRU_search_and_free_block(buf_pool, n_iterations);
984 if (n_iterations > 30) {
987 " InnoDB: Warning: difficult to find free blocks in\n"
988 "InnoDB: the buffer pool (%lu search iterations)!"
990 "InnoDB: increasing the buffer pool size.\n"
991 "InnoDB: It is also possible that"
992 " in your Unix version\n"
993 "InnoDB: fsync is very slow, or"
994 " completely frozen inside\n"
995 "InnoDB: the OS kernel. Then upgrading to"
997 "InnoDB: of your operating system may help."
999 "InnoDB: number of fsyncs in diagnostic info below.\n"
1000 "InnoDB: Pending flushes (fsync) log: %lu;"
1001 " buffer pool: %lu\n"
1002 "InnoDB: %lu OS file reads, %lu OS file writes,"
1004 "InnoDB: Starting InnoDB Monitor to print further\n"
1005 "InnoDB: diagnostics to the standard output.\n",
1006 (ulong) n_iterations,
1007 (ulong) fil_n_pending_log_flushes,
1008 (ulong) fil_n_pending_tablespace_flushes,
1009 (ulong) os_n_file_reads, (ulong) os_n_file_writes,
1010 (ulong) os_n_fsyncs);
1012 mon_value_was = srv_print_innodb_monitor;
1013 started_monitor = TRUE;
1014 srv_print_innodb_monitor = TRUE;
1020 buf_flush_free_margin(buf_pool);
1021 ++srv_buf_pool_wait_free;
1034 buf_LRU_try_free_flushed_blocks(buf_pool);
1039 if (n_iterations > 10) {
1054 buf_LRU_old_adjust_len(
1065 #if BUF_LRU_OLD_RATIO_MIN * BUF_LRU_OLD_MIN_LEN <= BUF_LRU_OLD_RATIO_DIV * (BUF_LRU_OLD_TOLERANCE + 5)
1066 # error "BUF_LRU_OLD_RATIO_MIN * BUF_LRU_OLD_MIN_LEN <= BUF_LRU_OLD_RATIO_DIV * (BUF_LRU_OLD_TOLERANCE + 5)"
1068 #ifdef UNIV_LRU_DEBUG
1082 - (BUF_LRU_OLD_TOLERANCE
1083 + BUF_LRU_NON_OLD_MIN_LEN));
1089 ut_ad(LRU_old->in_LRU_list);
1090 #ifdef UNIV_LRU_DEBUG
1096 if (old_len + BUF_LRU_OLD_TOLERANCE < new_len) {
1100 #ifdef UNIV_LRU_DEBUG
1106 }
else if (old_len > new_len + BUF_LRU_OLD_TOLERANCE) {
1137 ut_ad(bpage->in_LRU_list);
1147 buf_LRU_old_adjust_len(buf_pool);
1154 buf_unzip_LRU_remove_block_if_needed(
1168 ut_ad(block->in_unzip_LRU_list);
1169 ut_d(block->in_unzip_LRU_list = FALSE);
1179 buf_LRU_remove_block(
1191 ut_ad(bpage->in_LRU_list);
1196 if (UNIV_UNLIKELY(bpage == buf_pool->
LRU_old)) {
1206 #ifdef UNIV_LRU_DEBUG
1209 buf_pool->
LRU_old = prev_bpage;
1217 ut_d(bpage->in_LRU_list = FALSE);
1219 buf_unzip_LRU_remove_block_if_needed(bpage);
1247 buf_LRU_old_adjust_len(buf_pool);
1254 buf_unzip_LRU_add_block(
1268 ut_ad(!block->in_unzip_LRU_list);
1269 ut_d(block->in_unzip_LRU_list = TRUE);
1282 buf_LRU_add_block_to_end_low(
1294 ut_ad(!bpage->in_LRU_list);
1296 ut_d(bpage->in_LRU_list = TRUE);
1306 buf_LRU_old_adjust_len(buf_pool);
1313 buf_LRU_old_init(buf_pool);
1321 buf_unzip_LRU_add_block((
buf_block_t*) bpage, TRUE);
1329 buf_LRU_add_block_low(
1344 ut_ad(!bpage->in_LRU_list);
1352 #ifdef UNIV_LRU_DEBUG
1366 ut_d(bpage->in_LRU_list = TRUE);
1375 buf_LRU_old_adjust_len(buf_pool);
1382 buf_LRU_old_init(buf_pool);
1390 buf_unzip_LRU_add_block((
buf_block_t*) bpage, old);
1407 buf_LRU_add_block_low(bpage, old);
1414 buf_LRU_make_block_young(
1426 buf_LRU_remove_block(bpage);
1427 buf_LRU_add_block_low(bpage, FALSE);
1434 buf_LRU_make_block_old(
1438 buf_LRU_remove_block(bpage);
1439 buf_LRU_add_block_to_end_low(bpage);
1462 ibool* buf_pool_mutex_released)
1472 ut_ad(mutex_own(block_mutex));
1474 ut_ad(bpage->in_LRU_list);
1476 #if UNIV_WORD_SIZE == 4
1480 UNIV_MEM_ASSERT_RW(bpage,
sizeof *bpage);
1489 #ifdef UNIV_IBUF_COUNT_DEBUG
1493 if (zip || !bpage->
zip.
data) {
1519 if (UNIV_UNLIKELY(!b)) {
1523 memcpy(b, bpage,
sizeof *b);
1527 if (buf_debug_prints) {
1528 fprintf(stderr,
"Putting space %lu page %lu to free list\n",
1534 if (buf_LRU_block_remove_hashed_page(bpage, zip)
1561 ut_ad(!bpage->in_page_hash);
1562 ut_ad(!bpage->in_LRU_list);
1569 ut_ad(!b->in_zip_hash);
1570 ut_ad(b->in_page_hash);
1571 ut_ad(b->in_LRU_list);
1577 if (UNIV_LIKELY(prev_b != NULL)) {
1580 ut_ad(prev_b->in_LRU_list);
1582 #if UNIV_WORD_SIZE == 4
1587 UNIV_MEM_ASSERT_RW(prev_b,
sizeof *prev_b);
1608 buf_LRU_old_adjust_len(buf_pool);
1613 buf_LRU_old_init(buf_pool);
1615 #ifdef UNIV_LRU_DEBUG
1621 ut_d(b->in_LRU_list = FALSE);
1626 buf_LRU_insert_zip_clean(b);
1629 buf_flush_relocate_on_flush_list(bpage, b);
1642 if (buf_pool_mutex_released) {
1643 *buf_pool_mutex_released = TRUE;
1647 mutex_exit(block_mutex);
1657 btr_search_drop_page_hash_index((
buf_block_t*) bpage);
1671 UNIV_LIKELY(srv_use_checksums)
1679 mutex_enter(block_mutex);
1688 buf_LRU_block_free_hashed_page((
buf_block_t*) bpage);
1694 mutex_enter(block_mutex);
1704 buf_LRU_block_free_non_file_page(
1723 #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
1724 ut_a(block->n_pointers == 0);
1732 UNIV_MEM_ALLOC(block->
frame, UNIV_PAGE_SIZE);
1735 memset(block->
frame,
'\0', UNIV_PAGE_SIZE);
1745 mutex_exit(&block->
mutex);
1752 mutex_enter(&block->
mutex);
1757 ut_d(block->
page.in_free_list = TRUE);
1759 UNIV_MEM_ASSERT_AND_FREE(block->
frame, UNIV_PAGE_SIZE);
1774 buf_LRU_block_remove_hashed_page(
1793 #if UNIV_WORD_SIZE == 4
1797 UNIV_MEM_ASSERT_RW(bpage,
sizeof *bpage);
1800 buf_LRU_remove_block(bpage);
1812 const ulint zip_size
1817 switch (UNIV_EXPECT(fil_page_get_type(page),
1838 #ifdef UNIV_ZIP_DEBUG
1839 ut_a(page_zip_validate(&bpage->
zip, page));
1844 fputs(
" InnoDB: ERROR: The compressed page"
1845 " to be evicted seems corrupt:", stderr);
1847 fputs(
"\nInnoDB: Possibly older version"
1848 " of the page:", stderr);
1860 UNIV_MEM_ASSERT_W(bpage->
zip.
data,
1877 if (UNIV_UNLIKELY(bpage != hashed_bpage)) {
1879 "InnoDB: Error: page %lu %lu not found"
1880 " in the hash table\n",
1881 (ulong) bpage->
space,
1885 "InnoDB: In hash table we find block"
1886 " %p of %lu %lu which is not %p\n",
1887 (
const void*) hashed_bpage,
1888 (ulong) hashed_bpage->
space,
1889 (ulong) hashed_bpage->
offset,
1890 (
const void*) bpage);
1893 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
1904 ut_ad(!bpage->in_zip_hash);
1905 ut_ad(bpage->in_page_hash);
1906 ut_d(bpage->in_page_hash = FALSE);
1910 ut_ad(!bpage->in_free_list);
1911 ut_ad(!bpage->in_flush_list);
1912 ut_ad(!bpage->in_LRU_list);
1928 UNIV_MEM_UNDESC(bpage);
1945 ut_ad(!bpage->in_free_list);
1946 ut_ad(!bpage->in_flush_list);
1947 ut_ad(!bpage->in_LRU_list);
1979 buf_LRU_block_free_hashed_page(
1992 buf_LRU_block_free_non_file_page(block);
2000 buf_LRU_old_ratio_update_instance(
2027 buf_LRU_old_adjust_len(buf_pool);
2045 buf_LRU_old_ratio_update(
2054 ulint new_ratio = 0;
2061 new_ratio = buf_LRU_old_ratio_update_instance(
2062 buf_pool, old_pct, adjust);
2073 buf_LRU_stat_update(
void)
2079 ibool evict_started = FALSE;
2087 evict_started = TRUE;
2092 if (!evict_started) {
2097 item = &buf_LRU_stat_arr[buf_LRU_stat_arr_ind];
2098 buf_LRU_stat_arr_ind++;
2099 buf_LRU_stat_arr_ind %= BUF_LRU_STAT_N_INTERVAL;
2102 buf_LRU_stat_sum.
io += buf_LRU_stat_cur.
io - item->
io;
2106 memcpy(item, &buf_LRU_stat_cur,
sizeof *item);
2110 memset(&buf_LRU_stat_cur, 0,
sizeof buf_LRU_stat_cur);
2115 #define LRU_DUMP_FILE "ib_lru_dump"
2119 buf_LRU_file_dump(
void)
2124 byte* buffer_base = NULL;
2125 byte* buffer = NULL;
2132 for (i = 0; i < srv_n_data_files; i++) {
2133 if (strstr(srv_data_file_names[i], LRU_DUMP_FILE) != NULL) {
2135 " InnoDB: The name '%s' seems to be used for"
2136 " innodb_data_file_path. For safety, dumping of the LRU list"
2137 " is not being done.\n", LRU_DUMP_FILE);
2142 buffer_base =
static_cast<byte *
>(
ut_malloc(2 * UNIV_PAGE_SIZE));
2143 buffer =
static_cast<byte *
>(
ut_align(buffer_base, UNIV_PAGE_SIZE));
2144 if (buffer == NULL) {
2146 " InnoDB: cannot allocate buffer.\n");
2150 dump_file = os_file_create(innodb_file_temp_key, LRU_DUMP_FILE, OS_FILE_OVERWRITE,
2152 if (success == FALSE) {
2155 " InnoDB: cannot open %s\n", LRU_DUMP_FILE);
2159 buffers = offset = 0;
2169 while (bpage != NULL) {
2171 memset(buffer, 0, UNIV_PAGE_SIZE);
2179 if (offset == UNIV_PAGE_SIZE/4) {
2180 success = os_file_write(LRU_DUMP_FILE, dump_file, buffer,
2181 (buffers << UNIV_PAGE_SIZE_SHIFT) & 0xFFFFFFFFUL,
2182 (buffers >> (32 - UNIV_PAGE_SIZE_SHIFT)),
2184 if (success == FALSE) {
2187 " InnoDB: cannot write page %lu of %s\n",
2188 buffers, LRU_DUMP_FILE);
2201 memset(buffer, 0, UNIV_PAGE_SIZE);
2209 success = os_file_write(LRU_DUMP_FILE, dump_file, buffer,
2210 (buffers << UNIV_PAGE_SIZE_SHIFT) & 0xFFFFFFFFUL,
2211 (buffers >> (32 - UNIV_PAGE_SIZE_SHIFT)),
2213 if (success == FALSE) {
2219 if (dump_file != -1)
2220 os_file_close(dump_file);
2228 ib_uint32_t space_id;
2229 ib_uint32_t page_no;
2232 static int dump_record_cmp(
const void *a,
const void *b)
2237 if (rec1->space_id < rec2->space_id)
2239 if (rec1->space_id > rec2->space_id)
2241 if (rec1->page_no < rec2->page_no)
2243 return rec1->page_no > rec2->page_no;
2250 buf_LRU_file_restore(
void)
2255 byte* buffer_base = NULL;
2256 byte* buffer = NULL;
2261 bool terminated =
false;
2268 dump_file = os_file_create_simple_no_error_handling(innodb_file_temp_key,
2269 LRU_DUMP_FILE,
OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
2273 " InnoDB: cannot open %s\n", LRU_DUMP_FILE);
2276 if (size == 0 || size_high > 0 || size % 8) {
2277 fprintf(stderr,
" InnoDB: broken LRU dump file\n");
2280 buffer_base =
static_cast<byte *
>(
ut_malloc(2 * UNIV_PAGE_SIZE));
2281 buffer =
static_cast<byte *
>(
ut_align(buffer_base, UNIV_PAGE_SIZE));
2283 if (buffer == NULL || records == NULL) {
2285 " InnoDB: cannot allocate buffer.\n");
2291 while (!terminated) {
2292 success = os_file_read(dump_file, buffer,
2293 (buffers << UNIV_PAGE_SIZE_SHIFT) & 0xFFFFFFFFUL,
2294 (buffers >> (32 - UNIV_PAGE_SIZE_SHIFT)),
2296 if (success == FALSE) {
2298 " InnoDB: either could not read page %lu of %s,"
2299 " or terminated unexpectedly.\n",
2300 buffers, LRU_DUMP_FILE);
2304 for (offset = 0; offset < UNIV_PAGE_SIZE/4; offset += 2) {
2310 if (space_id == 0xFFFFFFFFUL
2311 || page_no == 0xFFFFFFFFUL) {
2316 records[length].space_id = space_id;
2317 records[length].page_no = page_no;
2319 if (length * 8 >= size) {
2321 " InnoDB: could not find the "
2322 "end-of-file marker after reading "
2323 "the expected %lu bytes from the "
2325 " InnoDB: this could be caused by a "
2326 "broken or incomplete file.\n"
2327 " InnoDB: trying to process what has "
2328 "been read so far.\n",
2337 qsort(records, length,
sizeof(
dump_record_t), dump_record_cmp);
2339 for (offset = 0; offset < length; offset++) {
2344 int64_t tablespace_version;
2346 space_id = records[offset].space_id;
2347 page_no = records[offset].page_no;
2349 if (offset % 16 == 15) {
2351 buf_flush_free_margins();
2354 zip_size = fil_space_get_zip_size(space_id);
2355 if (UNIV_UNLIKELY(zip_size == ULINT_UNDEFINED)) {
2359 if (fil_is_exist(space_id, page_no)) {
2361 tablespace_version = fil_space_get_version(space_id);
2366 space_id, zip_size, TRUE,
2367 tablespace_version, page_no);
2373 buf_flush_free_margins();
2377 " InnoDB: reading pages based on the dumped LRU list was done."
2378 " (requested: %lu, read: %lu)\n", req, reads);
2381 if (dump_file != -1)
2382 os_file_close(dump_file);
2391 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2396 buf_LRU_validate_instance(
2416 - (BUF_LRU_OLD_TOLERANCE
2417 + BUF_LRU_NON_OLD_MIN_LEN));
2418 ut_a(old_len >= new_len - BUF_LRU_OLD_TOLERANCE);
2419 ut_a(old_len <= new_len + BUF_LRU_OLD_TOLERANCE);
2423 ut_ad(ut_list_node_313->in_LRU_list));
2429 while (bpage != NULL) {
2468 ut_ad(ut_list_node_313->in_free_list));
2478 ut_ad(ut_list_node_313->in_unzip_LRU_list
2479 && ut_list_node_313->page.in_LRU_list));
2485 ut_ad(block->in_unzip_LRU_list);
2498 buf_LRU_validate(
void)
2507 buf_LRU_validate_instance(buf_pool);
2514 #if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2519 buf_LRU_print_instance(
2530 while (bpage != NULL) {
2533 fprintf(stderr,
"BLOCK space %lu page %lu ",
2538 fputs(
"old ", stderr);
2542 fprintf(stderr,
"buffix count %lu ",
2547 fprintf(stderr,
"io_fix %lu ",
2552 fputs(
"modif. ", stderr);
2558 frame = buf_block_get_frame((
buf_block_t*) bpage);
2559 fprintf(stderr,
"\ntype %lu"
2561 (ulong) fil_page_get_type(frame),
2566 fprintf(stderr,
"\ntype %lu size %lu"
2568 (ulong) fil_page_get_type(frame),
2574 fprintf(stderr,
"\n!state %lu!\n",
2596 for (i = 0; i < srv_buf_pool_instances; i++) {
2598 buf_LRU_print_instance(buf_pool);