函数buf_LRU_get_free_block

 

/******************************************************************//**
Returns a free block from the buf_pool. The block is taken off the
free list. If it is empty, blocks are moved from the end of the
LRU list to the free list.
@return    the free control block, in state BUF_BLOCK_READY_FOR_USE */
UNIV_INTERN
buf_block_t*
buf_LRU_get_free_block(
/*===================*/
    buf_pool_t*    buf_pool)    /*!< in/out: buffer pool instance */
{
    buf_block_t*    block        = NULL;
    ibool        freed;
    ulint        n_iterations    = 1;
    ibool        mon_value_was    = FALSE;
    ibool        started_monitor    = FALSE;
loop:
    buf_pool_mutex_enter(buf_pool);

    if (!recv_recovery_on && UT_LIST_GET_LEN(buf_pool->free)
        + UT_LIST_GET_LEN(buf_pool->LRU) < buf_pool->curr_size / 20) {
        ut_print_timestamp(stderr);

        fprintf(stderr,
            "  InnoDB: ERROR: over 95 percent of the buffer pool"
            " is occupied by\n"
            "InnoDB: lock heaps or the adaptive hash index!"
            " Check that your\n"
            "InnoDB: transactions do not set too many row locks.\n"
            "InnoDB: Your buffer pool size is %lu MB."
            " Maybe you should make\n"
            "InnoDB: the buffer pool bigger?\n"
            "InnoDB: We intentionally generate a seg fault"
            " to print a stack trace\n"
            "InnoDB: on Linux!\n",
            (ulong) (buf_pool->curr_size
                 / (1024 * 1024 / UNIV_PAGE_SIZE)));

        ut_error;

    } else if (!recv_recovery_on
           && (UT_LIST_GET_LEN(buf_pool->free)
               + UT_LIST_GET_LEN(buf_pool->LRU))
           < buf_pool->curr_size / 3) {

        if (!buf_lru_switched_on_innodb_mon) {

            /* Over 67 % of the buffer pool is occupied by lock
            heaps or the adaptive hash index. This may be a memory
            leak! */

            ut_print_timestamp(stderr);
            fprintf(stderr,
                "  InnoDB: WARNING: over 67 percent of"
                " the buffer pool is occupied by\n"
                "InnoDB: lock heaps or the adaptive"
                " hash index! Check that your\n"
                "InnoDB: transactions do not set too many"
                " row locks.\n"
                "InnoDB: Your buffer pool size is %lu MB."
                " Maybe you should make\n"
                "InnoDB: the buffer pool bigger?\n"
                "InnoDB: Starting the InnoDB Monitor to print"
                " diagnostics, including\n"
                "InnoDB: lock heap and hash index sizes.\n",
                (ulong) (buf_pool->curr_size
                     / (1024 * 1024 / UNIV_PAGE_SIZE)));

            buf_lru_switched_on_innodb_mon = TRUE;
            srv_print_innodb_monitor = TRUE;
            os_event_set(srv_lock_timeout_thread_event);
        }
    } else if (buf_lru_switched_on_innodb_mon) {

        /* Switch off the InnoDB Monitor; this is a simple way
        to stop the monitor if the situation becomes less urgent,
        but may also surprise users if the user also switched on the
        monitor! */

        buf_lru_switched_on_innodb_mon = FALSE;
        srv_print_innodb_monitor = FALSE;
    }

    /* If there is a block in the free list, take it */
    block = buf_LRU_get_free_only(buf_pool); //这里
    buf_pool_mutex_exit(buf_pool);

    if (block) {
        ut_ad(buf_pool_from_block(block) == buf_pool);
        memset(&block->page.zip, 0, sizeof block->page.zip);

        if (started_monitor) {
            srv_print_innodb_monitor = mon_value_was;
        }

        return(block);
    }

    /* If no block was in the free list, search from the end of the LRU
    list and try to free a block there */

    freed = buf_LRU_search_and_free_block(buf_pool, n_iterations); //从lru中取一块 这里     if (freed > 0) {
        goto loop;
    }

    if (n_iterations > 30) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            "  InnoDB: Warning: difficult to find free blocks in\n"
            "InnoDB: the buffer pool (%lu search iterations)!"
            " Consider\n"
            "InnoDB: increasing the buffer pool size.\n"
            "InnoDB: It is also possible that"
            " in your Unix version\n"
            "InnoDB: fsync is very slow, or"
            " completely frozen inside\n"
            "InnoDB: the OS kernel. Then upgrading to"
            " a newer version\n"
            "InnoDB: of your operating system may help."
            " Look at the\n"
            "InnoDB: number of fsyncs in diagnostic info below.\n"
            "InnoDB: Pending flushes (fsync) log: %lu;"
            " buffer pool: %lu\n"
            "InnoDB: %lu OS file reads, %lu OS file writes,"
            " %lu OS fsyncs\n"
            "InnoDB: Starting InnoDB Monitor to print further\n"
            "InnoDB: diagnostics to the standard output.\n",
            (ulong) n_iterations,
            (ulong) fil_n_pending_log_flushes,
            (ulong) fil_n_pending_tablespace_flushes,
            (ulong) os_n_file_reads, (ulong) os_n_file_writes,
            (ulong) os_n_fsyncs);

        mon_value_was = srv_print_innodb_monitor;
        started_monitor = TRUE;
        srv_print_innodb_monitor = TRUE;
        os_event_set(srv_lock_timeout_thread_event);
    }

    /* No free block was found: try to flush the LRU list */

    buf_flush_free_margin(buf_pool);
    ++srv_buf_pool_wait_free;

    os_aio_simulated_wake_handler_threads();

    buf_pool_mutex_enter(buf_pool);

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

        buf_LRU_try_free_flushed_blocks(buf_pool);
    } else {
        buf_pool_mutex_exit(buf_pool);
    }

    if (n_iterations > 10) {

        os_thread_sleep(500000);
    }

    n_iterations++;

    goto loop;
}