~percona-dev/percona-server/5.5.8-show-LRU-flushed

diff -ruN a/storage/innobase/buf/buf0flu.c b/storage/innobase/buf/buf0flu.c

--- a/storage/innobase/buf/buf0flu.c    2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/buf/buf0flu.c    2010-12-03 15:10:08.934990091 +0900

 

        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);

 

diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc

--- a/storage/innobase/handler/ha_innodb.cc     2010-12-03 15:09:51.283956391 +0900

+++ b/storage/innobase/handler/ha_innodb.cc     2010-12-03 15:10:08.963980444 +0900

   "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout.",

   NULL, NULL, 50, 1, 1024 * 1024 * 1024, 0);

 

 

 static handler *innobase_create_handler(handlerton *hton,

                                         TABLE_SHARE *table,

        }

 }

 

 /********************************************************************//**

 Obtain the InnoDB transaction of a MySQL thread.

 @return        reference to transaction pointer */

        srv_n_read_io_threads = (ulint) innobase_read_io_threads;

        srv_n_write_io_threads = (ulint) innobase_write_io_threads;

 

        srv_force_recovery = (ulint) innobase_force_recovery;

 

        srv_use_doublewrite_buf = (ibool) innobase_use_doublewrite;

+               if (srv_enable_unsafe_group_commit && !THDVAR(thd, support_xa)) {

+                       /* choose group commit rather than binlog order */

+                       return(error);

 

                /* For ibbackup to work the order of transactions in binlog

                and InnoDB must be the same. Consider the situation

 

 static MYSQL_SYSVAR_ULONG(purge_threads, srv_n_purge_threads,

   PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,

   0,                   /* Minimum value */

   1, 0);               /* Maximum value */

 

 static MYSQL_SYSVAR_BOOL(adaptive_flushing, srv_adaptive_flushing,

   PLUGIN_VAR_NOCMDARG,

   "Attempt flushing dirty pages to avoid IO bursts at checkpoints.",

 

 static MYSQL_SYSVAR_ULONG(max_purge_lag, srv_max_purge_lag,

   PLUGIN_VAR_RQCMDARG,

 static MYSQL_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,

   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,

   "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",

 

 static MYSQL_SYSVAR_LONG(buffer_pool_instances, innobase_buffer_pool_instances,

   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,

   "trigger a readahead.",

   NULL, NULL, 56, 0, 64, 0);

 

 static struct st_mysql_sys_var* innobase_system_variables[]= {

   MYSQL_SYSVAR(additional_mem_pool_size),

   MYSQL_SYSVAR(autoextend_increment),

   MYSQL_SYSVAR(show_verbose_locks),

   MYSQL_SYSVAR(show_locks_held),

   MYSQL_SYSVAR(version),

diff -ruN a/storage/innobase/ibuf/ibuf0ibuf.c b/storage/innobase/ibuf/ibuf0ibuf.c

--- a/storage/innobase/ibuf/ibuf0ibuf.c 2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/ibuf/ibuf0ibuf.c 2010-12-03 15:10:09.073984282 +0900

        grow in size, as the references on the upper levels of the tree can

        change */

 

 

        mutex_create(ibuf_pessimistic_insert_mutex_key,

                     &ibuf_pessimistic_insert_mutex,

        size = ibuf->size;

        max_size = ibuf->max_size;

 

diff -ruN a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h

--- a/storage/innobase/include/srv0srv.h        2010-12-03 15:09:51.291955835 +0900

+++ b/storage/innobase/include/srv0srv.h        2010-12-03 15:10:09.079029047 +0900

 extern ulong   srv_max_purge_lag;

 

 extern ulong   srv_replication_delay;

 /*-------------------------------------------*/

 

 extern ulint   srv_n_rows_inserted;

                                when writing data files, but do flush

                                after writing to log files */

        SRV_UNIX_NOSYNC,        /*!< do not flush after writing */

diff -ruN a/storage/innobase/include/trx0trx.h b/storage/innobase/include/trx0trx.h

--- a/storage/innobase/include/trx0trx.h        2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/include/trx0trx.h        2010-12-03 15:10:09.081029243 +0900

                                        FALSE, one can save CPU time and about

                                        150 bytes in the undo log size as then

                                        we skip XA steps */

                /* A checkpoint is not urgent: do it asynchronously */

 

                do_checkpoint = TRUE;

                log_sys->flushed_to_disk_lsn,

                log_sys->last_checkpoint_lsn);

 

diff -ruN a/storage/innobase/os/os0file.c b/storage/innobase/os/os0file.c

--- a/storage/innobase/os/os0file.c     2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/os/os0file.c     2010-12-03 15:10:09.093023540 +0900

                os_file_set_nocache(file, name, mode_str);

        }

 

 /*-------------------------------------------*/

 UNIV_INTERN ulong      srv_n_spin_wait_rounds  = 30;

 UNIV_INTERN ulong      srv_n_free_tickets_to_enter = 500;

        ulint           n_pages_purged  = 0;

        ulint           n_bytes_merged;

        ulint           n_pages_flushed;

        ulint           n_bytes_archived;

        ulint           n_tables_to_drop;

        ulint           n_ios;

        ulint           n_ios_very_old;

        ulint           n_pend_ios;

        ulint           next_itr_time;

 

 #ifdef UNIV_DEBUG_THREAD_CREATION

        fprintf(stderr, "Master thread starts, id %lu\n",

 

        mutex_exit(&kernel_mutex);

 

 loop:

        /*****************************************************************/

        /* ---- When there is database activity by users, we cycle in this

        /* Sleep for 1 second on entrying the for loop below the first time. */

        next_itr_time = ut_time_ms() + 1000;

 

        for (i = 0; i < 10; i++) {

                ulint   cur_time = ut_time_ms();

 

                srv_main_thread_op_info = "sleeping";

                srv_main_1_second_loops++;

 

+               if (!skip_sleep) {

 

                                        (next_itr_time - cur_time)

                                         * 1000));

                        srv_main_sleeps++;

+

+               skip_sleep = FALSE;

 

                if (n_pend_ios < SRV_PEND_IO_THRESHOLD

                    && (n_ios - n_ios_old < SRV_RECENT_IO_ACTIVITY)) {

                        srv_main_thread_op_info = "doing insert buffer merge";

 

                        /* Flush logs if needed */

                        srv_sync_log_buffer_in_background();

                        n_pages_flushed = buf_flush_list(

                                PCT_IO(100), IB_ULONGLONG_MAX);

 

                } else if (srv_adaptive_flushing) {

 

                        /* Try to keep the rate of flushing of dirty

                                                n_flush,

                                                IB_ULONGLONG_MAX);

                        }

                }

 

                if (srv_activity_count == old_activity_count) {

        even if the server were active */

 

        srv_main_thread_op_info = "doing insert buffer merge";

 

        /* Flush logs if needed */

        srv_sync_log_buffer_in_background();

                buf_flush_list below. Otherwise, the system favors

                clean pages over cleanup throughput. */

                n_bytes_merged = ibuf_contract_for_n_pages(FALSE,

        }

 

        srv_main_thread_op_info = "reserving kernel mutex";

        srv_slot_t*     slot;

        ulint           slot_no = ULINT_UNDEFINED;

        ulint           n_total_purged = ULINT_UNDEFINED;

 

        ut_a(srv_n_purge_threads == 1);

 

 

        mutex_exit(&kernel_mutex);

 

 

                /* If there are very few records to purge or the last

                purge didn't purge any records then wait for activity.

                } while (n_pages_purged > 0 && !srv_fast_shutdown);

 

                srv_sync_log_buffer_in_background();

diff -ruN a/storage/innobase/srv/srv0start.c b/storage/innobase/srv/srv0start.c

--- a/storage/innobase/srv/srv0start.c  2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/srv/srv0start.c  2010-12-03 15:10:09.103023543 +0900

        } else if (0 == ut_strcmp(srv_file_flush_method_str, "O_DIRECT")) {

                srv_unix_file_flush_method = SRV_UNIX_O_DIRECT;

 

diff -ruN a/storage/innobase/trx/trx0trx.c b/storage/innobase/trx/trx0trx.c

--- a/storage/innobase/trx/trx0trx.c    2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/trx/trx0trx.c    2010-12-03 15:10:09.106023937 +0900

 

        trx->support_xa = TRUE;

 

        trx->check_foreigns = TRUE;

        trx->check_unique_secondary = TRUE;

 

        generated by the same transaction, doesn't. */

        trx->support_xa = thd_supports_xa(trx->mysql_thd);

 

        mutex_enter(&kernel_mutex);

 

        ret = trx_start_low(trx, rseg_id);

        trx->read_view = NULL;

 

        if (lsn) {

 

                mutex_exit(&kernel_mutex);

 

                        trx_undo_insert_cleanup(trx);

                }

 

                /* NOTE that we could possibly make a group commit more

                efficient here: call os_thread_yield here to allow also other

                trxs to come to commit! */

                if (trx->flush_log_later) {

                        /* Do nothing yet */

                        trx->must_flush_log_later = TRUE;

                        if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {

                                /* Write the log but do not flush it to disk */

 

 

                                log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);

                        }

 

                        /* Write the log but do not flush it to disk */

 

        trx_t*  trx)    /*!< in: trx handle */

 {

        ib_uint64_t     lsn     = trx->commit_lsn;

                if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {

                        /* Write the log but do not flush it to disk */

 

 

                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);

                }

 

                /* Write the log but do not flush it to disk */

 

        /*--------------------------------------*/

 

        if (lsn) {

                /* Depending on the my.cnf options, we may now write the log

                buffer to the log files, making the prepared state of the

                transaction durable if the OS does not crash. We may also

 

                mutex_exit(&kernel_mutex);

 

                        if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {

                                /* Write the log but do not flush it to disk */

 

 

                                log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);

                        }