~drizzle-trunk/drizzle/development

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

 

Copyright (c) 2008, 2009 Google Inc.

 

Portions of this file contain modifications contributed and copyrighted by

Google, Inc. Those modifications are gratefully acknowledged and are described

incorporated with their permission, and subject to the conditions contained in

the file COPYING.Google.

 

This program is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free Software

Foundation; version 2 of the License.

St, Fifth Floor, Boston, MA 02110-1301 USA

 

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

 

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

@file srv/srv0srv.c

#include "sync0sync.h"

#include "thr0loc.h"

#include "que0que.h"

#include "log0recv.h"

#include "pars0pars.h"

#include "usr0sess.h"

in microseconds, in order to reduce the lagging of the purge thread. */

UNIV_INTERN ulint       srv_dml_needed_delay = 0;

 

UNIV_INTERN ibool       srv_error_monitor_active = FALSE;

 

UNIV_INTERN const char* srv_main_thread_op_info = "";

/** Whether to check file format during startup.  A value of

DICT_TF_FORMAT_MAX + 1 means no checking ie. FALSE.  The default is to

set it to the highest format we support. */

 

#if DICT_TF_FORMAT_51

# error "DICT_TF_FORMAT_51 must be 0!"

on duplicate key checking and foreign key checking */

UNIV_INTERN ibool       srv_locks_unsafe_for_binlog = FALSE;

 

UNIV_INTERN ulint       srv_n_data_files = 0;

UNIV_INTERN char**      srv_data_file_names = NULL;

/* size in database pages */

the checkpoints. */

UNIV_INTERN bool        srv_adaptive_flushing   = TRUE;

 

collation */

#if defined(BUILD_DRIZZLE)

UNIV_INTERN const byte  srv_latin1_ordering[256]        /* The sort order table of the latin1

UNIV_INTERN my_bool     srv_use_sys_malloc      = TRUE;

/* requested size in kilobytes */

UNIV_INTERN ulint       srv_buf_pool_size       = ULINT_MAX;

/* previously requested size */

UNIV_INTERN ulint       srv_buf_pool_old_size;

/* current size in kilobytes */

 

UNIV_INTERN ulong       srv_max_buf_pool_modified_pct   = 75;

 

/* variable counts amount of data read in total (in bytes) */

UNIV_INTERN ulint srv_data_read = 0;

 

UNIV_INTERN ib_int64_t  srv_n_lock_wait_time            = 0;

UNIV_INTERN ulint               srv_n_lock_max_wait_time        = 0;

 

 

/*

  Set the following to 0 if you want InnoDB to write messages on

 

/* Mutex for locking srv_monitor_file */

UNIV_INTERN mutex_t     srv_monitor_file_mutex;

/* Temporary file for innodb monitor output */

UNIV_INTERN FILE*       srv_monitor_file;

/* Mutex for locking srv_dict_tmpfile.

static ulint    srv_meter_foreground[SRV_MASTER + 1];

#endif

 

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

Prints counters for work done by srv_master_thread. */

static

                      srv_log_writes_and_flush);

}

 

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

Sets the info describing an i/o thread current state. */

UNIV_INTERN

        srv_sys = mem_alloc(sizeof(srv_sys_t));

 

        kernel_mutex_temp = mem_alloc(sizeof(mutex_t));

 

 

        srv_sys->threads = mem_alloc(OS_THREAD_MAX_N * sizeof(srv_slot_t));

 

                row_mysql_unfreeze_data_dictionary(trx);

                break;

        case RW_X_LATCH:

                /* Release fast index creation latch */

                row_mysql_unlock_data_dictionary(trx);

                break;

                row_mysql_freeze_data_dictionary(trx);

                break;

        case RW_X_LATCH:

                row_mysql_lock_data_dictionary(trx);

                break;

        }

                    start_time != -1 && finish_time != -1) {

                        srv_n_lock_max_wait_time = diff_time;

                }

        }

 

        if (trx->was_chosen_as_deadlock_victim) {

 

                trx->error_state = DB_LOCK_WAIT_TIMEOUT;

        }

}

 

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

 

        log_refresh_stats();

 

 

        srv_n_rows_inserted_old = srv_n_rows_inserted;

        srv_n_rows_updated_old = srv_n_rows_updated;

}

 

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

UNIV_INTERN

srv_printf_innodb_monitor(

/*======================*/

        FILE*   file,           /*!< in: output stream */

        ulint*  trx_start,      /*!< out: file position of the start of

                                the list of active transactions */

        ulint*  trx_end)        /*!< out: file position of the end of

        double  time_elapsed;

        time_t  current_time;

        ulint   n_reserved;

 

        mutex_enter(&srv_innodb_monitor_mutex);

 

                "Per second averages calculated from the last %lu seconds\n",

                (ulong)time_elapsed);

 

        srv_print_master_thread_info(file);

 

        fputs("----------\n"

 

        mutex_exit(&dict_foreign_err_mutex);

 

        fputs("--------\n"

              "FILE I/O\n"

              "--------\n", file);

              "============================\n", file);

        mutex_exit(&srv_innodb_monitor_mutex);

        fflush(file);

}

 

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

srv_export_innodb_status(void)

/*==========================*/

{

        mutex_enter(&srv_innodb_monitor_mutex);

 

        export_vars.innodb_data_pending_reads

        export_vars.innodb_data_reads = os_n_file_reads;

        export_vars.innodb_data_writes = os_n_file_writes;

        export_vars.innodb_data_written = srv_data_written;

        export_vars.innodb_buffer_pool_write_requests

                = srv_buf_pool_write_requests;

        export_vars.innodb_buffer_pool_wait_free = srv_buf_pool_wait_free;

        export_vars.innodb_buffer_pool_pages_flushed = srv_buf_pool_flushed;

        export_vars.innodb_buffer_pool_reads = srv_buf_pool_reads;

        export_vars.innodb_buffer_pool_read_ahead

        export_vars.innodb_buffer_pool_read_ahead_evicted

#ifdef UNIV_DEBUG

        export_vars.innodb_buffer_pool_pages_latched

                = buf_get_latched_pages_number();

#endif /* UNIV_DEBUG */

 

#ifdef HAVE_ATOMIC_BUILTINS

        export_vars.innodb_have_atomic_builtins = 1;

#else

        export_vars.innodb_log_writes = srv_log_writes;

        export_vars.innodb_dblwr_pages_written = srv_dblwr_pages_written;

        export_vars.innodb_dblwr_writes = srv_dblwr_writes;

        export_vars.innodb_row_lock_waits = srv_n_lock_wait_count;

        export_vars.innodb_row_lock_current_waits

                = srv_n_lock_wait_current_count;

        export_vars.innodb_rows_inserted = srv_n_rows_inserted;

        export_vars.innodb_rows_updated = srv_n_rows_updated;

        export_vars.innodb_rows_deleted = srv_n_rows_deleted;

 

        mutex_exit(&srv_innodb_monitor_mutex);

}

 

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

@return a dummy parameter */

UNIV_INTERN

os_thread_ret_t

        void*   arg __attribute__((unused)))

                        /*!< in: a dummy parameter required by

                        os_thread_create */

{

        double          time_elapsed;

        time_t          current_time;

        time_t          last_table_monitor_time;

        time_t          last_tablespace_monitor_time;

        time_t          last_monitor_time;

 

#ifdef UNIV_DEBUG_THREAD_CREATION

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

                os_thread_pf(os_thread_get_curr_id()));

#endif

        UT_NOT_USED(arg);

        srv_last_monitor_time = time(NULL);

        last_table_monitor_time = time(NULL);

        last_tablespace_monitor_time = time(NULL);

        last_monitor_time = time(NULL);

loop:

 

        current_time = time(NULL);

 

                last_monitor_time = time(NULL);

 

                if (srv_print_innodb_monitor) {

                }

 

                if (srv_innodb_status) {

                        mutex_enter(&srv_monitor_file_mutex);

                        rewind(srv_monitor_file);

                        os_file_set_eof(srv_monitor_file);

                        mutex_exit(&srv_monitor_file_mutex);

                }

                }

        }

 

        mutex_enter(&kernel_mutex);

 

        some_waits = FALSE;

                        lock_wait_timeout = thd_lock_wait_timeout(

                                trx->mysql_thd);

 

 

                                /* Timeout exceeded or a wrap-around in system

                                time counter: cancel the lock request queued

                goto exit_func;

        }

 

                goto loop;

        }

 

 

#if 0

        /* The following synchronisation is disabled, since

        goto loop;

 

exit_func:

 

        /* We count the number of threads in os_thread_exit(). A created

        thread should always use that to exit and not use return() to exit. */

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

                os_thread_pf(os_thread_get_curr_id()));

#endif

loop:

        srv_error_monitor_active = TRUE;

 

        OS_THREAD_DUMMY_RETURN;

}

 

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

Tells the InnoDB server that there has been activity in the database

and wakes up the master thread if it is suspended (not sleeping). Used

in the MySQL interface. Note that there is a small chance that the master

UNIV_INTERN

void

srv_active_wake_master_thread(void)

}

 

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

Wakes up the master thread if it is suspended or being suspended. */

UNIV_INTERN

void

        mutex_exit(&kernel_mutex);

}

 

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

The master thread is tasked to ensure that flush of log file happens

once every second in the background. This is to ensure that not more

        }

}

 

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

The master thread controlling the server.

@return a dummy parameter */

                        /*!< in: a dummy parameter required by

                        os_thread_create */

{

        os_event_t      event;

        ulint           old_activity_count;

        ulint           n_pages_purged  = 0;

        ulint           n_ios_old;

        ulint           n_ios_very_old;

        ulint           n_pend_ios;

        ulint           i;

 

#ifdef UNIV_DEBUG_THREAD_CREATION

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

                os_thread_pf(os_thread_get_curr_id()));

#endif

        srv_main_thread_process_no = os_proc_get_number();

        srv_main_thread_id = os_thread_pf(os_thread_get_curr_id());

 

 

        srv_main_thread_op_info = "reserving kernel mutex";

 

        mutex_enter(&kernel_mutex);

 

        /* Store the user activity counter at the start of this loop */

        when there is database activity */

 

        srv_last_log_flush_time = time(NULL);

 

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