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) {
265 || bpage->
space !=
id
286 page_arr[num_entries] = bpage->
offset;
287 ut_a(num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE);
290 if (num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE) {
298 buf_LRU_drop_page_hash_batch(
299 id, zip_size, page_arr, num_entries);
330 buf_LRU_drop_page_hash_batch(
id, zip_size, page_arr, num_entries);
340 buf_LRU_invalidate_tablespace_buf_pool_instance(
355 while (bpage != NULL) {
357 ibool prev_bpage_buf_fix = FALSE;
378 mutex_enter(block_mutex);
393 if (buf_debug_prints) {
395 "Dropping space %lu page %lu\n",
404 if (UNIV_LIKELY(prev_bpage != NULL)) {
425 ut_ad(mutex_own(block_mutex));
426 prev_bpage_buf_fix = TRUE;
442 mutex_exit(block_mutex);
447 btr_search_drop_page_hash_when_freed(
448 id, zip_size, page_no);
454 buf_flush_remove(bpage);
459 if (buf_LRU_block_remove_hashed_page(bpage, TRUE)
468 ut_ad(!mutex_own(block_mutex));
470 if (prev_bpage_buf_fix) {
478 mutex_enter(block_mutex);
481 mutex_exit(block_mutex);
484 goto next_page_no_mutex;
487 mutex_exit(block_mutex);
508 buf_LRU_invalidate_tablespace(
524 buf_LRU_drop_page_hash_for_tablespace(buf_pool,
id);
525 buf_LRU_invalidate_tablespace_buf_pool_instance(buf_pool,
id);
533 buf_LRU_insert_zip_clean(
568 buf_LRU_free_from_unzip_LRU_list(
591 if (UNIV_UNLIKELY(n_iterations >= 5)
592 || !buf_LRU_evict_from_unzip_LRU(buf_pool)) {
597 distance = 100 + (n_iterations
601 UNIV_LIKELY(block != NULL) && UNIV_LIKELY(distance > 0);
607 ut_ad(block->in_unzip_LRU_list);
610 mutex_enter(&block->
mutex);
611 freed = buf_LRU_free_block(&block->
page, FALSE);
612 mutex_exit(&block->
mutex);
642 buf_LRU_free_from_common_LRU_list(
658 distance = 100 + (n_iterations * buf_pool->
curr_size) / 10;
661 UNIV_LIKELY(bpage != NULL) && UNIV_LIKELY(distance > 0);
670 ut_ad(bpage->in_LRU_list);
672 mutex_enter(block_mutex);
674 freed = buf_LRU_free_block(bpage, TRUE);
675 mutex_exit(block_mutex);
711 buf_LRU_search_and_free_block(
729 freed = buf_LRU_free_from_unzip_LRU_list(buf_pool, n_iterations);
732 freed = buf_LRU_free_from_common_LRU_list(
733 buf_pool, n_iterations);
757 buf_LRU_try_free_flushed_blocks(
762 if (buf_pool == NULL) {
767 buf_LRU_try_free_flushed_blocks(buf_pool);
776 buf_LRU_search_and_free_block(buf_pool, 1);
792 buf_LRU_buf_pool_running_out(
void)
825 buf_LRU_get_free_only(
838 ut_d(block->
page.in_free_list = FALSE);
844 mutex_enter(&block->
mutex);
847 UNIV_MEM_ALLOC(block->
frame, UNIV_PAGE_SIZE);
851 mutex_exit(&block->
mutex);
870 ulint n_iterations = 1;
871 ibool mon_value_was = FALSE;
872 ibool started_monitor = FALSE;
881 " InnoDB: ERROR: over 95 percent of the buffer pool"
883 "InnoDB: lock heaps or the adaptive hash index!"
885 "InnoDB: transactions do not set too many row locks.\n"
886 "InnoDB: Your buffer pool size is %lu MB."
887 " Maybe you should make\n"
888 "InnoDB: the buffer pool bigger?\n"
889 "InnoDB: We intentionally generate a seg fault"
890 " to print a stack trace\n"
891 "InnoDB: on Linux!\n",
893 / (1024 * 1024 / UNIV_PAGE_SIZE)));
897 }
else if (!recv_recovery_on
902 if (!buf_lru_switched_on_innodb_mon) {
910 " InnoDB: WARNING: over 67 percent of"
911 " the buffer pool is occupied by\n"
912 "InnoDB: lock heaps or the adaptive"
913 " hash index! Check that your\n"
914 "InnoDB: transactions do not set too many"
916 "InnoDB: Your buffer pool size is %lu MB."
917 " Maybe you should make\n"
918 "InnoDB: the buffer pool bigger?\n"
919 "InnoDB: Starting the InnoDB Monitor to print"
920 " diagnostics, including\n"
921 "InnoDB: lock heap and hash index sizes.\n",
923 / (1024 * 1024 / UNIV_PAGE_SIZE)));
925 buf_lru_switched_on_innodb_mon = TRUE;
926 srv_print_innodb_monitor = TRUE;
929 }
else if (buf_lru_switched_on_innodb_mon) {
936 buf_lru_switched_on_innodb_mon = FALSE;
937 srv_print_innodb_monitor = FALSE;
941 block = buf_LRU_get_free_only(buf_pool);
948 if (started_monitor) {
949 srv_print_innodb_monitor = mon_value_was;
958 freed = buf_LRU_search_and_free_block(buf_pool, n_iterations);
964 if (n_iterations > 30) {
967 " InnoDB: Warning: difficult to find free blocks in\n"
968 "InnoDB: the buffer pool (%lu search iterations)!"
970 "InnoDB: increasing the buffer pool size.\n"
971 "InnoDB: It is also possible that"
972 " in your Unix version\n"
973 "InnoDB: fsync is very slow, or"
974 " completely frozen inside\n"
975 "InnoDB: the OS kernel. Then upgrading to"
977 "InnoDB: of your operating system may help."
979 "InnoDB: number of fsyncs in diagnostic info below.\n"
980 "InnoDB: Pending flushes (fsync) log: %lu;"
981 " buffer pool: %lu\n"
982 "InnoDB: %lu OS file reads, %lu OS file writes,"
984 "InnoDB: Starting InnoDB Monitor to print further\n"
985 "InnoDB: diagnostics to the standard output.\n",
986 (ulong) n_iterations,
987 (ulong) fil_n_pending_log_flushes,
988 (ulong) fil_n_pending_tablespace_flushes,
989 (ulong) os_n_file_reads, (ulong) os_n_file_writes,
990 (ulong) os_n_fsyncs);
992 mon_value_was = srv_print_innodb_monitor;
993 started_monitor = TRUE;
994 srv_print_innodb_monitor = TRUE;
1000 buf_flush_free_margin(buf_pool);
1001 ++srv_buf_pool_wait_free;
1014 buf_LRU_try_free_flushed_blocks(buf_pool);
1019 if (n_iterations > 10) {
1034 buf_LRU_old_adjust_len(
1045 #if BUF_LRU_OLD_RATIO_MIN * BUF_LRU_OLD_MIN_LEN <= BUF_LRU_OLD_RATIO_DIV * (BUF_LRU_OLD_TOLERANCE + 5)
1046 # error "BUF_LRU_OLD_RATIO_MIN * BUF_LRU_OLD_MIN_LEN <= BUF_LRU_OLD_RATIO_DIV * (BUF_LRU_OLD_TOLERANCE + 5)"
1048 #ifdef UNIV_LRU_DEBUG
1062 - (BUF_LRU_OLD_TOLERANCE
1063 + BUF_LRU_NON_OLD_MIN_LEN));
1069 ut_ad(LRU_old->in_LRU_list);
1070 #ifdef UNIV_LRU_DEBUG
1076 if (old_len + BUF_LRU_OLD_TOLERANCE < new_len) {
1080 #ifdef UNIV_LRU_DEBUG
1086 }
else if (old_len > new_len + BUF_LRU_OLD_TOLERANCE) {
1117 ut_ad(bpage->in_LRU_list);
1127 buf_LRU_old_adjust_len(buf_pool);
1134 buf_unzip_LRU_remove_block_if_needed(
1148 ut_ad(block->in_unzip_LRU_list);
1149 ut_d(block->in_unzip_LRU_list = FALSE);
1159 buf_LRU_remove_block(
1171 ut_ad(bpage->in_LRU_list);
1176 if (UNIV_UNLIKELY(bpage == buf_pool->
LRU_old)) {
1186 #ifdef UNIV_LRU_DEBUG
1189 buf_pool->
LRU_old = prev_bpage;
1197 ut_d(bpage->in_LRU_list = FALSE);
1199 buf_unzip_LRU_remove_block_if_needed(bpage);
1227 buf_LRU_old_adjust_len(buf_pool);
1234 buf_unzip_LRU_add_block(
1248 ut_ad(!block->in_unzip_LRU_list);
1249 ut_d(block->in_unzip_LRU_list = TRUE);
1262 buf_LRU_add_block_to_end_low(
1274 ut_ad(!bpage->in_LRU_list);
1276 ut_d(bpage->in_LRU_list = TRUE);
1286 buf_LRU_old_adjust_len(buf_pool);
1293 buf_LRU_old_init(buf_pool);
1301 buf_unzip_LRU_add_block((
buf_block_t*) bpage, TRUE);
1309 buf_LRU_add_block_low(
1324 ut_ad(!bpage->in_LRU_list);
1332 #ifdef UNIV_LRU_DEBUG
1346 ut_d(bpage->in_LRU_list = TRUE);
1355 buf_LRU_old_adjust_len(buf_pool);
1362 buf_LRU_old_init(buf_pool);
1370 buf_unzip_LRU_add_block((
buf_block_t*) bpage, old);
1387 buf_LRU_add_block_low(bpage, old);
1394 buf_LRU_make_block_young(
1406 buf_LRU_remove_block(bpage);
1407 buf_LRU_add_block_low(bpage, FALSE);
1414 buf_LRU_make_block_old(
1418 buf_LRU_remove_block(bpage);
1419 buf_LRU_add_block_to_end_low(bpage);
1448 ut_ad(mutex_own(block_mutex));
1450 ut_ad(bpage->in_LRU_list);
1452 #if UNIV_WORD_SIZE == 4
1456 UNIV_MEM_ASSERT_RW(bpage,
sizeof *bpage);
1465 #ifdef UNIV_IBUF_COUNT_DEBUG
1469 if (zip || !bpage->
zip.
data) {
1495 if (UNIV_UNLIKELY(!b)) {
1499 memcpy(b, bpage,
sizeof *b);
1503 if (buf_debug_prints) {
1504 fprintf(stderr,
"Putting space %lu page %lu to free list\n",
1510 if (buf_LRU_block_remove_hashed_page(bpage, zip)
1537 ut_ad(!bpage->in_page_hash);
1538 ut_ad(!bpage->in_LRU_list);
1545 ut_ad(!b->in_zip_hash);
1546 ut_ad(b->in_page_hash);
1547 ut_ad(b->in_LRU_list);
1553 if (UNIV_LIKELY(prev_b != NULL)) {
1556 ut_ad(prev_b->in_LRU_list);
1558 #if UNIV_WORD_SIZE == 4
1563 UNIV_MEM_ASSERT_RW(prev_b,
sizeof *prev_b);
1584 buf_LRU_old_adjust_len(buf_pool);
1589 buf_LRU_old_init(buf_pool);
1591 #ifdef UNIV_LRU_DEBUG
1597 ut_d(b->in_LRU_list = FALSE);
1602 buf_LRU_insert_zip_clean(b);
1605 buf_flush_relocate_on_flush_list(bpage, b);
1619 mutex_exit(block_mutex);
1629 btr_search_drop_page_hash_index((
buf_block_t*) bpage);
1643 UNIV_LIKELY(srv_use_checksums)
1651 mutex_enter(block_mutex);
1660 buf_LRU_block_free_hashed_page((
buf_block_t*) bpage);
1666 mutex_enter(block_mutex);
1676 buf_LRU_block_free_non_file_page(
1695 #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
1696 ut_a(block->n_pointers == 0);
1704 UNIV_MEM_ALLOC(block->
frame, UNIV_PAGE_SIZE);
1707 memset(block->
frame,
'\0', UNIV_PAGE_SIZE);
1717 mutex_exit(&block->
mutex);
1724 mutex_enter(&block->
mutex);
1729 ut_d(block->
page.in_free_list = TRUE);
1731 UNIV_MEM_ASSERT_AND_FREE(block->
frame, UNIV_PAGE_SIZE);
1746 buf_LRU_block_remove_hashed_page(
1765 #if UNIV_WORD_SIZE == 4
1769 UNIV_MEM_ASSERT_RW(bpage,
sizeof *bpage);
1772 buf_LRU_remove_block(bpage);
1784 const ulint zip_size
1789 switch (UNIV_EXPECT(fil_page_get_type(page),
1810 #ifdef UNIV_ZIP_DEBUG
1811 ut_a(page_zip_validate(&bpage->
zip, page));
1816 fputs(
" InnoDB: ERROR: The compressed page"
1817 " to be evicted seems corrupt:", stderr);
1819 fputs(
"\nInnoDB: Possibly older version"
1820 " of the page:", stderr);
1832 UNIV_MEM_ASSERT_W(bpage->
zip.
data,
1849 if (UNIV_UNLIKELY(bpage != hashed_bpage)) {
1851 "InnoDB: Error: page %lu %lu not found"
1852 " in the hash table\n",
1853 (ulong) bpage->
space,
1857 "InnoDB: In hash table we find block"
1858 " %p of %lu %lu which is not %p\n",
1859 (
const void*) hashed_bpage,
1860 (ulong) hashed_bpage->
space,
1861 (ulong) hashed_bpage->
offset,
1862 (
const void*) bpage);
1865 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
1876 ut_ad(!bpage->in_zip_hash);
1877 ut_ad(bpage->in_page_hash);
1878 ut_d(bpage->in_page_hash = FALSE);
1882 ut_ad(!bpage->in_free_list);
1883 ut_ad(!bpage->in_flush_list);
1884 ut_ad(!bpage->in_LRU_list);
1901 UNIV_MEM_UNDESC(bpage);
1918 ut_ad(!bpage->in_free_list);
1919 ut_ad(!bpage->in_flush_list);
1920 ut_ad(!bpage->in_LRU_list);
1952 buf_LRU_block_free_hashed_page(
1965 buf_LRU_block_free_non_file_page(block);
1973 buf_LRU_old_ratio_update_instance(
2000 buf_LRU_old_adjust_len(buf_pool);
2018 buf_LRU_old_ratio_update(
2027 ulint new_ratio = 0;
2034 new_ratio = buf_LRU_old_ratio_update_instance(
2035 buf_pool, old_pct, adjust);
2046 buf_LRU_stat_update(
void)
2052 ibool evict_started = FALSE;
2061 evict_started = TRUE;
2066 if (!evict_started) {
2071 item = &buf_LRU_stat_arr[buf_LRU_stat_arr_ind];
2072 buf_LRU_stat_arr_ind++;
2073 buf_LRU_stat_arr_ind %= BUF_LRU_STAT_N_INTERVAL;
2081 cur_stat = buf_LRU_stat_cur;
2083 buf_LRU_stat_sum.
io += cur_stat.
io - item->
io;
2087 memcpy(item, &cur_stat,
sizeof *item);
2091 memset(&buf_LRU_stat_cur, 0,
sizeof buf_LRU_stat_cur);
2096 #define LRU_DUMP_FILE "ib_lru_dump"
2100 buf_LRU_file_dump(
void)
2105 byte* buffer_base = NULL;
2106 byte* buffer = NULL;
2113 for (i = 0; i < srv_n_data_files; i++) {
2114 if (strstr(srv_data_file_names[i], LRU_DUMP_FILE) != NULL) {
2116 " InnoDB: The name '%s' seems to be used for"
2117 " innodb_data_file_path. For safety, dumping of the LRU list"
2118 " is not being done.\n", LRU_DUMP_FILE);
2123 buffer_base =
static_cast<byte *
>(
ut_malloc(2 * UNIV_PAGE_SIZE));
2124 buffer =
static_cast<byte *
>(
ut_align(buffer_base, UNIV_PAGE_SIZE));
2125 if (buffer == NULL) {
2127 " InnoDB: cannot allocate buffer.\n");
2131 dump_file = os_file_create(innodb_file_temp_key, LRU_DUMP_FILE, OS_FILE_OVERWRITE,
2133 if (success == FALSE) {
2136 " InnoDB: cannot open %s\n", LRU_DUMP_FILE);
2140 buffers = offset = 0;
2150 while (bpage != NULL) {
2152 memset(buffer, 0, UNIV_PAGE_SIZE);
2160 if (offset == UNIV_PAGE_SIZE/4) {
2161 success = os_file_write(LRU_DUMP_FILE, dump_file, buffer,
2162 (buffers << UNIV_PAGE_SIZE_SHIFT) & 0xFFFFFFFFUL,
2163 (buffers >> (32 - UNIV_PAGE_SIZE_SHIFT)),
2165 if (success == FALSE) {
2168 " InnoDB: cannot write page %lu of %s\n",
2169 buffers, LRU_DUMP_FILE);
2182 memset(buffer, 0, UNIV_PAGE_SIZE);
2190 success = os_file_write(LRU_DUMP_FILE, dump_file, buffer,
2191 (buffers << UNIV_PAGE_SIZE_SHIFT) & 0xFFFFFFFFUL,
2192 (buffers >> (32 - UNIV_PAGE_SIZE_SHIFT)),
2194 if (success == FALSE) {
2200 if (dump_file != -1)
2201 os_file_close(dump_file);
2209 ib_uint32_t space_id;
2210 ib_uint32_t page_no;
2213 static int dump_record_cmp(
const void *a,
const void *b)
2218 if (rec1->space_id < rec2->space_id)
2220 if (rec1->space_id > rec2->space_id)
2222 if (rec1->page_no < rec2->page_no)
2224 return rec1->page_no > rec2->page_no;
2231 buf_LRU_file_restore(
void)
2236 byte* buffer_base = NULL;
2237 byte* buffer = NULL;
2242 bool terminated =
false;
2249 dump_file = os_file_create_simple_no_error_handling(innodb_file_temp_key,
2250 LRU_DUMP_FILE,
OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
2254 " InnoDB: cannot open %s\n", LRU_DUMP_FILE);
2257 if (size == 0 || size_high > 0 || size % 8) {
2258 fprintf(stderr,
" InnoDB: broken LRU dump file\n");
2261 buffer_base =
static_cast<byte *
>(
ut_malloc(2 * UNIV_PAGE_SIZE));
2262 buffer =
static_cast<byte *
>(
ut_align(buffer_base, UNIV_PAGE_SIZE));
2264 if (buffer == NULL || records == NULL) {
2266 " InnoDB: cannot allocate buffer.\n");
2272 while (!terminated) {
2273 success = os_file_read(dump_file, buffer,
2274 (buffers << UNIV_PAGE_SIZE_SHIFT) & 0xFFFFFFFFUL,
2275 (buffers >> (32 - UNIV_PAGE_SIZE_SHIFT)),
2277 if (success == FALSE) {
2279 " InnoDB: either could not read page %lu of %s,"
2280 " or terminated unexpectedly.\n",
2281 buffers, LRU_DUMP_FILE);
2285 for (offset = 0; offset < UNIV_PAGE_SIZE/4; offset += 2) {
2291 if (space_id == 0xFFFFFFFFUL
2292 || page_no == 0xFFFFFFFFUL) {
2297 records[length].space_id = space_id;
2298 records[length].page_no = page_no;
2300 if (length * 8 >= size) {
2302 " InnoDB: could not find the "
2303 "end-of-file marker after reading "
2304 "the expected %lu bytes from the "
2306 " InnoDB: this could be caused by a "
2307 "broken or incomplete file.\n"
2308 " InnoDB: trying to process what has "
2309 "been read so far.\n",
2318 qsort(records, length,
sizeof(
dump_record_t), dump_record_cmp);
2320 for (offset = 0; offset < length; offset++) {
2325 int64_t tablespace_version;
2327 space_id = records[offset].space_id;
2328 page_no = records[offset].page_no;
2330 if (offset % 16 == 15) {
2332 buf_flush_free_margins();
2335 zip_size = fil_space_get_zip_size(space_id);
2336 if (UNIV_UNLIKELY(zip_size == ULINT_UNDEFINED)) {
2340 if (fil_is_exist(space_id, page_no)) {
2342 tablespace_version = fil_space_get_version(space_id);
2347 space_id, zip_size, TRUE,
2348 tablespace_version, page_no);
2354 buf_flush_free_margins();
2358 " InnoDB: reading pages based on the dumped LRU list was done."
2359 " (requested: %lu, read: %lu)\n", req, reads);
2362 if (dump_file != -1)
2363 os_file_close(dump_file);
2372 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2377 buf_LRU_validate_instance(
2397 - (BUF_LRU_OLD_TOLERANCE
2398 + BUF_LRU_NON_OLD_MIN_LEN));
2399 ut_a(old_len >= new_len - BUF_LRU_OLD_TOLERANCE);
2400 ut_a(old_len <= new_len + BUF_LRU_OLD_TOLERANCE);
2404 ut_ad(ut_list_node_313->in_LRU_list));
2410 while (bpage != NULL) {
2449 ut_ad(ut_list_node_313->in_free_list));
2459 ut_ad(ut_list_node_313->in_unzip_LRU_list
2460 && ut_list_node_313->page.in_LRU_list));
2466 ut_ad(block->in_unzip_LRU_list);
2479 buf_LRU_validate(
void)
2488 buf_LRU_validate_instance(buf_pool);
2495 #if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2500 buf_LRU_print_instance(
2511 while (bpage != NULL) {
2514 fprintf(stderr,
"BLOCK space %lu page %lu ",
2519 fputs(
"old ", stderr);
2523 fprintf(stderr,
"buffix count %lu ",
2528 fprintf(stderr,
"io_fix %lu ",
2533 fputs(
"modif. ", stderr);
2539 frame = buf_block_get_frame((
buf_block_t*) bpage);
2540 fprintf(stderr,
"\ntype %lu"
2542 (ulong) fil_page_get_type(frame),
2547 fprintf(stderr,
"\ntype %lu size %lu"
2549 (ulong) fil_page_get_type(frame),
2555 fprintf(stderr,
"\n!state %lu!\n",
2577 for (i = 0; i < srv_buf_pool_instances; i++) {
2579 buf_LRU_print_instance(buf_pool);