1
1
/*****************************************************************************
3
Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
4
Copyright (C) 2008, 2009 Google Inc.
5
Copyright (C) 2009, Percona Inc.
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
4
Copyright (c) 2008, 2009 Google Inc.
7
6
Portions of this file contain modifications contributed and copyrighted by
8
7
Google, Inc. Those modifications are gratefully acknowledged and are described
30
22
St, Fifth Floor, Boston, MA 02110-1301 USA
32
24
*****************************************************************************/
25
/***********************************************************************
27
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
28
Copyright (c) 2009, Percona Inc.
30
Portions of this file contain modifications contributed and copyrighted
31
by Percona Inc.. Those modifications are
32
gratefully acknowledged and are described briefly in the InnoDB
33
documentation. The contributions by Percona Inc. are incorporated with
34
their permission, and subject to the conditions contained in the file
37
This program is free software; you can redistribute it and/or modify it
38
under the terms of the GNU General Public License as published by the
39
Free Software Foundation; version 2 of the License.
41
This program is distributed in the hope that it will be useful, but
42
WITHOUT ANY WARRANTY; without even the implied warranty of
43
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
44
Public License for more details.
46
You should have received a copy of the GNU General Public License along
47
with this program; if not, write to the Free Software Foundation, Inc.,
48
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
50
***********************************************************************/
34
52
/**************************************************//**
35
53
@file srv/srv0srv.c
100
119
in microseconds, in order to reduce the lagging of the purge thread. */
101
120
UNIV_INTERN ulint srv_dml_needed_delay = 0;
103
UNIV_INTERN ibool srv_lock_timeout_active = FALSE;
104
UNIV_INTERN ibool srv_monitor_active = FALSE;
122
UNIV_INTERN ibool srv_lock_timeout_and_monitor_active = FALSE;
105
123
UNIV_INTERN ibool srv_error_monitor_active = FALSE;
107
125
UNIV_INTERN const char* srv_main_thread_op_info = "";
127
/** Prefix used by MySQL to indicate pre-5.1 table name encoding */
128
UNIV_INTERN const char srv_mysql50_table_name_prefix[9] = "#mysql50#";
109
130
/* Server parameters which are read from the initfile */
111
132
/* The following three are dir paths which are catenated before file
133
154
on duplicate key checking and foreign key checking */
134
155
UNIV_INTERN ibool srv_locks_unsafe_for_binlog = FALSE;
136
/* If this flag is TRUE, then we will use the native aio of the
137
OS (provided we compiled Innobase with it in), otherwise we will
138
use simulated aio we build below with threads.
139
Currently we support native aio on windows and linux */
140
UNIV_INTERN my_bool srv_use_native_aio = TRUE;
143
/* Windows native condition variables. We use runtime loading / function
144
pointers, because they are not available on Windows Server 2003 and
147
We use condition for events on Windows if possible, even if os_event
148
resembles Windows kernel event object well API-wise. The reason is
149
performance, kernel objects are heavyweights and WaitForSingleObject() is a
150
performance killer causing calling thread to context switch. Besides, Innodb
151
is preallocating large number (often millions) of os_events. With kernel event
152
objects it takes a big chunk out of non-paged pool, which is better suited
153
for tasks like IO than for storing idle event objects. */
154
UNIV_INTERN ibool srv_use_native_conditions = FALSE;
157
157
UNIV_INTERN ulint srv_n_data_files = 0;
158
158
UNIV_INTERN char** srv_data_file_names = NULL;
159
159
/* size in database pages */
188
188
the checkpoints. */
189
189
UNIV_INTERN bool srv_adaptive_flushing = TRUE;
191
/** Maximum number of times allowed to conditionally acquire
192
mutex before switching to blocking wait on the mutex */
193
#define MAX_MUTEX_NOWAIT 20
195
/** Check whether the number of failed nonblocking mutex
196
acquisition attempts exceeds maximum allowed value. If so,
197
srv_printf_innodb_monitor() will request mutex acquisition
198
with mutex_enter(), which will wait until it gets the mutex. */
199
#define MUTEX_NOWAIT(mutex_skipped) ((mutex_skipped) < MAX_MUTEX_NOWAIT)
201
/** The sort order table of the MySQL latin1_swedish_ci character set
191
/* The sort order table of the MySQL latin1_swedish_ci character set
203
193
#if defined(BUILD_DRIZZLE)
204
const byte srv_latin1_ordering[256] /* The sort order table of the latin1
194
UNIV_INTERN const byte srv_latin1_ordering[256] /* The sort order table of the latin1
205
195
character set. The following table is
206
196
the MySQL order as of Feb 10th, 2002 */
485
466
/* Mutex for locking srv_monitor_file */
486
467
UNIV_INTERN mutex_t srv_monitor_file_mutex;
488
#ifdef UNIV_PFS_MUTEX
489
/* Key to register kernel_mutex with performance schema */
490
UNIV_INTERN mysql_pfs_key_t kernel_mutex_key;
491
/* Key to protect writing the commit_id to the sys header */
492
UNIV_INTERN mysql_pfs_key_t commit_id_mutex_key;
493
/* Key to register srv_innodb_monitor_mutex with performance schema */
494
UNIV_INTERN mysql_pfs_key_t srv_innodb_monitor_mutex_key;
495
/* Key to register srv_monitor_file_mutex with performance schema */
496
UNIV_INTERN mysql_pfs_key_t srv_monitor_file_mutex_key;
497
/* Key to register srv_dict_tmpfile_mutex with performance schema */
498
UNIV_INTERN mysql_pfs_key_t srv_dict_tmpfile_mutex_key;
499
/* Key to register the mutex with performance schema */
500
UNIV_INTERN mysql_pfs_key_t srv_misc_tmpfile_mutex_key;
501
#endif /* UNIV_PFS_MUTEX */
503
468
/* Temporary file for innodb monitor output */
504
469
UNIV_INTERN FILE* srv_monitor_file;
505
470
/* Mutex for locking srv_dict_tmpfile.
1023
977
srv_slot_t* slot;
1026
srv_sys = static_cast<srv_sys_t *>(mem_alloc(sizeof(srv_sys_t)));
1028
kernel_mutex_temp = static_cast<ib_mutex_t *>(mem_alloc(sizeof(mutex_t)));
1029
mutex_create(kernel_mutex_key, &kernel_mutex, SYNC_KERNEL);
1031
commit_id_mutex_temp = static_cast<ib_mutex_t *>(mem_alloc(sizeof(mutex_t)));
1032
mutex_create(commit_id_mutex_key, &commit_id_mutex, SYNC_COMMIT_ID_LOCK);
1034
mutex_create(srv_innodb_monitor_mutex_key,
1035
&srv_innodb_monitor_mutex, SYNC_NO_ORDER_CHECK);
1037
srv_sys->threads = static_cast<srv_table_t *>(mem_alloc(OS_THREAD_MAX_N * sizeof(srv_slot_t)));
980
srv_sys = mem_alloc(sizeof(srv_sys_t));
982
kernel_mutex_temp = mem_alloc(sizeof(mutex_t));
983
mutex_create(&kernel_mutex, SYNC_KERNEL);
985
mutex_create(&srv_innodb_monitor_mutex, SYNC_NO_ORDER_CHECK);
987
srv_sys->threads = mem_alloc(OS_THREAD_MAX_N * sizeof(srv_slot_t));
1039
989
for (i = 0; i < OS_THREAD_MAX_N; i++) {
1040
990
slot = srv_table_get_nth_slot(i);
1642
1583
row_mysql_unfreeze_data_dictionary(trx);
1644
1585
case RW_X_LATCH:
1645
/* There should never be a lock wait when the
1646
dictionary latch is reserved in X mode. Dictionary
1647
transactions should only acquire locks on dictionary
1648
tables, not other tables. All access to dictionary
1649
tables should be covered by dictionary
1651
ut_print_timestamp(stderr);
1652
fputs(" InnoDB: Error: dict X latch held in "
1653
"srv_suspend_mysql_thread\n", stderr);
1654
/* This should never occur. This incorrect handling
1655
was added in the early development of
1656
ha_innobase::add_index() in InnoDB Plugin 1.0. */
1657
1586
/* Release fast index creation latch */
1658
1587
row_mysql_unlock_data_dictionary(trx);
1805
1723
/******************************************************************//**
1806
Outputs to a file the output of the InnoDB Monitor.
1807
@return FALSE if not all information printed
1808
due to failure to obtain necessary mutex */
1724
Outputs to a file the output of the InnoDB Monitor. */
1811
1727
srv_printf_innodb_monitor(
1812
1728
/*======================*/
1813
1729
FILE* file, /*!< in: output stream */
1814
ibool nowait, /*!< in: whether to wait for kernel mutex */
1815
1730
ulint* trx_start, /*!< out: file position of the start of
1816
1731
the list of active transactions */
1817
1732
ulint* trx_end) /*!< out: file position of the end of
1871
1785
mutex_exit(&dict_foreign_err_mutex);
1873
/* Only if lock_print_info_summary proceeds correctly,
1874
before we call the lock_print_info_all_transactions
1875
to print all the lock information. */
1876
ret = lock_print_info_summary(file, nowait);
1880
long t = ftell(file);
1882
*trx_start = ULINT_UNDEFINED;
1884
*trx_start = (ulint) t;
1887
lock_print_info_all_transactions(file);
1889
long t = ftell(file);
1891
*trx_end = ULINT_UNDEFINED;
1893
*trx_end = (ulint) t;
1787
lock_print_info_summary(file);
1789
long t = ftell(file);
1791
*trx_start = ULINT_UNDEFINED;
1793
*trx_start = (ulint) t;
1796
lock_print_info_all_transactions(file);
1798
long t = ftell(file);
1800
*trx_end = ULINT_UNDEFINED;
1802
*trx_end = (ulint) t;
1898
1805
fputs("--------\n"
1900
1807
"--------\n", file);
2025
1922
export_vars.innodb_data_reads = os_n_file_reads;
2026
1923
export_vars.innodb_data_writes = os_n_file_writes;
2027
1924
export_vars.innodb_data_written = srv_data_written;
2028
export_vars.innodb_buffer_pool_read_requests = stat.n_page_gets;
1925
export_vars.innodb_buffer_pool_read_requests = buf_pool->stat.n_page_gets;
2029
1926
export_vars.innodb_buffer_pool_write_requests
2030
1927
= srv_buf_pool_write_requests;
2031
1928
export_vars.innodb_buffer_pool_wait_free = srv_buf_pool_wait_free;
2032
1929
export_vars.innodb_buffer_pool_pages_flushed = srv_buf_pool_flushed;
2033
1930
export_vars.innodb_buffer_pool_reads = srv_buf_pool_reads;
2034
1931
export_vars.innodb_buffer_pool_read_ahead
2035
= stat.n_ra_pages_read;
1932
= buf_pool->stat.n_ra_pages_read;
2036
1933
export_vars.innodb_buffer_pool_read_ahead_evicted
2037
= stat.n_ra_pages_evicted;
2038
export_vars.innodb_buffer_pool_pages_data = LRU_len;
2039
export_vars.innodb_buffer_pool_pages_dirty = flush_list_len;
2040
export_vars.innodb_buffer_pool_pages_free = free_len;
1934
= buf_pool->stat.n_ra_pages_evicted;
1935
export_vars.innodb_buffer_pool_pages_data
1936
= UT_LIST_GET_LEN(buf_pool->LRU);
1937
export_vars.innodb_buffer_pool_pages_dirty
1938
= UT_LIST_GET_LEN(buf_pool->flush_list);
1939
export_vars.innodb_buffer_pool_pages_free
1940
= UT_LIST_GET_LEN(buf_pool->free);
2041
1941
#ifdef UNIV_DEBUG
2042
1942
export_vars.innodb_buffer_pool_pages_latched
2043
1943
= buf_get_latched_pages_number();
2044
1944
#endif /* UNIV_DEBUG */
2045
export_vars.innodb_buffer_pool_pages_total = buf_pool_get_n_pages();
1945
export_vars.innodb_buffer_pool_pages_total = buf_pool->curr_size;
2047
export_vars.innodb_buffer_pool_pages_misc
2048
= buf_pool_get_n_pages() - LRU_len - free_len;
1947
export_vars.innodb_buffer_pool_pages_misc = buf_pool->curr_size
1948
- UT_LIST_GET_LEN(buf_pool->LRU)
1949
- UT_LIST_GET_LEN(buf_pool->free);
2049
1950
#ifdef HAVE_ATOMIC_BUILTINS
2050
1951
export_vars.innodb_have_atomic_builtins = 1;
2061
1962
export_vars.innodb_log_writes = srv_log_writes;
2062
1963
export_vars.innodb_dblwr_pages_written = srv_dblwr_pages_written;
2063
1964
export_vars.innodb_dblwr_writes = srv_dblwr_writes;
2064
export_vars.innodb_pages_created = stat.n_pages_created;
2065
export_vars.innodb_pages_read = stat.n_pages_read;
2066
export_vars.innodb_pages_written = stat.n_pages_written;
1965
export_vars.innodb_pages_created = buf_pool->stat.n_pages_created;
1966
export_vars.innodb_pages_read = buf_pool->stat.n_pages_read;
1967
export_vars.innodb_pages_written = buf_pool->stat.n_pages_written;
2067
1968
export_vars.innodb_row_lock_waits = srv_n_lock_wait_count;
2068
1969
export_vars.innodb_row_lock_current_waits
2069
1970
= srv_n_lock_wait_current_count;
2080
1981
export_vars.innodb_rows_inserted = srv_n_rows_inserted;
2081
1982
export_vars.innodb_rows_updated = srv_n_rows_updated;
2082
1983
export_vars.innodb_rows_deleted = srv_n_rows_deleted;
2083
export_vars.innodb_truncated_status_writes = srv_truncated_status_writes;
2085
1985
mutex_exit(&srv_innodb_monitor_mutex);
2088
1988
/*********************************************************************//**
2089
A thread which prints the info output by various InnoDB monitors.
1989
A thread which wakes up threads whose lock wait may have lasted too long.
1990
This also prints the info output by various InnoDB monitors.
2090
1991
@return a dummy parameter */
2092
1993
os_thread_ret_t
2095
void* /*arg __attribute__((unused))*/)
1994
srv_lock_timeout_and_monitor_thread(
1995
/*================================*/
1996
void* arg __attribute__((unused)))
2096
1997
/*!< in: a dummy parameter required by
2097
1998
os_thread_create */
2099
ib_int64_t sig_count;
2100
2001
double time_elapsed;
2101
2002
time_t current_time;
2102
2003
time_t last_table_monitor_time;
2103
2004
time_t last_tablespace_monitor_time;
2104
2005
time_t last_monitor_time;
2105
ulint mutex_skipped;
2106
ibool last_srv_print_monitor;
2108
2010
#ifdef UNIV_DEBUG_THREAD_CREATION
2109
2011
fprintf(stderr, "Lock timeout thread starts, id %lu\n",
2110
2012
os_thread_pf(os_thread_get_curr_id()));
2113
#ifdef UNIV_PFS_THREAD
2114
pfs_register_thread(srv_monitor_thread_key);
2117
srv_last_monitor_time = ut_time();
2118
last_table_monitor_time = ut_time();
2119
last_tablespace_monitor_time = ut_time();
2120
last_monitor_time = ut_time();
2122
last_srv_print_monitor = srv_print_innodb_monitor;
2015
srv_last_monitor_time = time(NULL);
2016
last_table_monitor_time = time(NULL);
2017
last_tablespace_monitor_time = time(NULL);
2018
last_monitor_time = time(NULL);
2124
srv_monitor_active = TRUE;
2126
/* Wake up every 5 seconds to see if we need to print
2127
monitor information or if signalled at shutdown. */
2129
sig_count = os_event_reset(srv_monitor_event);
2131
os_event_wait_time_low(srv_monitor_event, 5000000, sig_count);
2133
current_time = ut_time();
2020
srv_lock_timeout_and_monitor_active = TRUE;
2022
/* When someone is waiting for a lock, we wake up every second
2023
and check if a timeout has passed for a lock wait */
2025
os_thread_sleep(1000000);
2027
current_time = time(NULL);
2135
2029
time_elapsed = difftime(current_time, last_monitor_time);
2137
2031
if (time_elapsed > 15) {
2138
last_monitor_time = ut_time();
2032
last_monitor_time = time(NULL);
2140
2034
if (srv_print_innodb_monitor) {
2141
/* Reset mutex_skipped counter everytime
2142
srv_print_innodb_monitor changes. This is to
2143
ensure we will not be blocked by kernel_mutex
2144
for short duration information printing,
2145
such as requested by sync_array_print_long_waits() */
2146
if (!last_srv_print_monitor) {
2148
last_srv_print_monitor = TRUE;
2151
if (!srv_printf_innodb_monitor(stderr,
2152
MUTEX_NOWAIT(mutex_skipped),
2156
/* Reset the counter */
2160
last_srv_print_monitor = FALSE;
2035
srv_printf_innodb_monitor(stderr, NULL, NULL);
2164
2038
if (srv_innodb_status) {
2165
2039
mutex_enter(&srv_monitor_file_mutex);
2166
2040
rewind(srv_monitor_file);
2167
if (!srv_printf_innodb_monitor(srv_monitor_file,
2168
MUTEX_NOWAIT(mutex_skipped),
2041
srv_printf_innodb_monitor(srv_monitor_file, NULL,
2175
2043
os_file_set_eof(srv_monitor_file);
2176
2044
mutex_exit(&srv_monitor_file_mutex);
2227
if (srv_shutdown_state >= SRV_SHUTDOWN_CLEANUP) {
2231
if (srv_print_innodb_monitor
2232
|| srv_print_innodb_lock_monitor
2233
|| srv_print_innodb_tablespace_monitor
2234
|| srv_print_innodb_table_monitor) {
2238
srv_monitor_active = FALSE;
2243
srv_monitor_active = FALSE;
2245
/* We count the number of threads in os_thread_exit(). A created
2246
thread should always use that to exit and not use return() to exit. */
2248
os_thread_exit(NULL);
2250
OS_THREAD_DUMMY_RETURN;
2253
/*********************************************************************//**
2254
A thread which wakes up threads whose lock wait may have lasted too long.
2255
@return a dummy parameter */
2258
srv_lock_timeout_thread(
2259
/*====================*/
2260
void* /*arg __attribute__((unused))*/)
2261
/* in: a dummy parameter required by
2268
ib_int64_t sig_count;
2270
#ifdef UNIV_PFS_THREAD
2271
pfs_register_thread(srv_lock_timeout_thread_key);
2276
/* When someone is waiting for a lock, we wake up every second
2277
and check if a timeout has passed for a lock wait */
2279
sig_count = os_event_reset(srv_timeout_event);
2281
os_event_wait_time_low(srv_timeout_event, 1000000, sig_count);
2283
srv_lock_timeout_active = TRUE;
2285
2095
mutex_enter(&kernel_mutex);
2287
2097
some_waits = FALSE;
2468
2275
OS_THREAD_DUMMY_RETURN;
2471
/**********************************************************************//**
2472
Check whether any background thread is active.
2473
@return FALSE if all are are suspended or have exited. */
2476
srv_is_any_background_thread_active(void)
2477
/*=====================================*/
2482
mutex_enter(&kernel_mutex);
2484
for (i = SRV_COM; i <= SRV_MASTER; ++i) {
2485
if (srv_n_threads_active[i] != 0) {
2491
mutex_exit(&kernel_mutex);
2496
2278
/*******************************************************************//**
2497
2279
Tells the InnoDB server that there has been activity in the database
2498
2280
and wakes up the master thread if it is suspended (not sleeping). Used
2499
2281
in the MySQL interface. Note that there is a small chance that the master
2500
thread stays suspended (we do not protect our operation with the
2501
srv_sys_t->mutex, for performance reasons). */
2282
thread stays suspended (we do not protect our operation with the kernel
2283
mutex, for performace reasons). */
2504
2286
srv_active_wake_master_thread(void)
2519
2301
/*******************************************************************//**
2520
Tells the purge thread that there has been activity in the database
2521
and wakes up the purge thread if it is suspended (not sleeping). Note
2522
that there is a small chance that the purge thread stays suspended
2523
(we do not protect our operation with the kernel mutex, for
2524
performace reasons). */
2527
srv_wake_purge_thread_if_not_active(void)
2528
/*=====================================*/
2530
ut_ad(!mutex_own(&kernel_mutex));
2532
if (srv_n_purge_threads > 0
2533
&& srv_n_threads_active[SRV_WORKER] == 0) {
2535
mutex_enter(&kernel_mutex);
2537
srv_release_threads(SRV_WORKER, 1);
2539
mutex_exit(&kernel_mutex);
2543
/*******************************************************************//**
2544
2302
Wakes up the master thread if it is suspended or being suspended. */
2556
2314
mutex_exit(&kernel_mutex);
2559
/*******************************************************************//**
2560
Wakes up the purge thread if it's not already awake. */
2563
srv_wake_purge_thread(void)
2564
/*=======================*/
2566
ut_ad(!mutex_own(&kernel_mutex));
2568
if (srv_n_purge_threads > 0) {
2570
mutex_enter(&kernel_mutex);
2572
srv_release_threads(SRV_WORKER, 1);
2574
mutex_exit(&kernel_mutex);
2578
2317
/**********************************************************************
2579
2318
The master thread is tasked to ensure that flush of log file happens
2580
2319
once every second in the background. This is to ensure that not more
2598
/********************************************************************//**
2599
Do a full purge, reconfigure the purge sub-system if a dynamic
2600
change is detected. */
2603
srv_master_do_purge(void)
2604
/*=====================*/
2606
ulint n_pages_purged;
2608
ut_ad(!mutex_own(&kernel_mutex));
2610
ut_a(srv_n_purge_threads == 0);
2613
/* Check for shutdown and change in purge config. */
2614
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2615
/* Nothing to purge. */
2618
n_pages_purged = trx_purge(srv_purge_batch_size);
2621
srv_sync_log_buffer_in_background();
2623
} while (n_pages_purged > 0);
2626
2337
/*********************************************************************//**
2627
2338
The master thread controlling the server.
2628
2339
@return a dummy parameter */
2695
2399
when there is database activity */
2697
2401
srv_last_log_flush_time = time(NULL);
2699
/* Sleep for 1 second on entrying the for loop below the first time. */
2700
next_itr_time = ut_time_ms() + 1000;
2702
2404
for (i = 0; i < 10; i++) {
2703
ulint cur_time = ut_time_ms();
2405
n_ios_old = log_sys->n_log_ios + buf_pool->stat.n_pages_read
2406
+ buf_pool->stat.n_pages_written;
2407
srv_main_thread_op_info = "sleeping";
2408
srv_main_1_second_loops++;
2412
os_thread_sleep(1000000);
2705
2418
/* ALTER TABLE in MySQL requires on Unix that the table handler
2706
2419
can drop tables lazily after there no longer are SELECT
2717
2430
goto background_loop;
2720
buf_get_total_stat(&buf_stat);
2722
n_ios_old = log_sys->n_log_ios + buf_stat.n_pages_read
2723
+ buf_stat.n_pages_written;
2725
srv_main_thread_op_info = "sleeping";
2726
srv_main_1_second_loops++;
2728
if (next_itr_time > cur_time
2729
&& srv_shutdown_state == SRV_SHUTDOWN_NONE) {
2731
/* Get sleep interval in micro seconds. We use
2732
ut_min() to avoid long sleep in case of
2734
os_thread_sleep(ut_min(1000000,
2735
(next_itr_time - cur_time)
2740
/* Each iteration should happen at 1 second interval. */
2741
next_itr_time = ut_time_ms() + 1000;
2743
2433
/* Flush logs if needed */
2744
2434
srv_sync_log_buffer_in_background();
2747
2437
log_free_check();
2749
2439
/* If i/os during one second sleep were less than 5% of
2750
capacity, we assume that there is free disk i/o capacity
2751
available, and it makes sense to do an insert buffer merge. */
2440
capacity, we assume that there is free disk i/o capacity
2441
available, and it makes sense to do an insert buffer merge. */
2753
buf_get_total_stat(&buf_stat);
2754
2443
n_pend_ios = buf_get_n_pending_ios()
2755
2444
+ log_sys->n_pending_writes;
2756
n_ios = log_sys->n_log_ios + buf_stat.n_pages_read
2757
+ buf_stat.n_pages_written;
2445
n_ios = log_sys->n_log_ios + buf_pool->stat.n_pages_read
2446
+ buf_pool->stat.n_pages_written;
2758
2447
if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2759
2448
&& (n_ios - n_ios_old < SRV_RECENT_IO_ACTIVITY)) {
2760
2449
srv_main_thread_op_info = "doing insert buffer merge";
2773
2462
srv_main_thread_op_info =
2774
2463
"flushing buffer pool pages";
2775
n_pages_flushed = buf_flush_list(
2776
PCT_IO(100), IB_ULONGLONG_MAX);
2464
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2468
/* If we had to do the flush, it may have taken
2469
even more than 1 second, and also, there may be more
2470
to flush. Do not sleep 1 second during the next
2471
iteration of this loop. */
2778
2474
} else if (srv_adaptive_flushing) {
2780
2476
/* Try to keep the rate of flushing of dirty
2819
2517
loop above requests writes for that case. The writes done here
2820
2518
are not required, and may be disabled. */
2822
buf_get_total_stat(&buf_stat);
2823
2520
n_pend_ios = buf_get_n_pending_ios() + log_sys->n_pending_writes;
2824
n_ios = log_sys->n_log_ios + buf_stat.n_pages_read
2825
+ buf_stat.n_pages_written;
2521
n_ios = log_sys->n_log_ios + buf_pool->stat.n_pages_read
2522
+ buf_pool->stat.n_pages_written;
2827
2524
srv_main_10_second_loops++;
2828
2525
if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2829
2526
&& (n_ios - n_ios_very_old < SRV_PAST_IO_ACTIVITY)) {
2831
2528
srv_main_thread_op_info = "flushing buffer pool pages";
2832
buf_flush_list(PCT_IO(100), IB_ULONGLONG_MAX);
2529
buf_flush_batch(BUF_FLUSH_LIST, PCT_IO(100),
2834
2532
/* Flush logs if needed */
2835
2533
srv_sync_log_buffer_in_background();
2844
2542
/* Flush logs if needed */
2845
2543
srv_sync_log_buffer_in_background();
2847
if (srv_n_purge_threads == 0) {
2848
srv_main_thread_op_info = "master purging";
2850
srv_master_do_purge();
2545
/* We run a full purge every 10 seconds, even if the server
2852
2549
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2854
2551
goto background_loop;
2554
srv_main_thread_op_info = "purging";
2555
n_pages_purged = trx_purge();
2557
/* Flush logs if needed */
2558
srv_sync_log_buffer_in_background();
2560
} while (n_pages_purged);
2858
2562
srv_main_thread_op_info = "flushing buffer pool pages";
2865
2569
(> 70 %), we assume we can afford reserving the disk(s) for
2866
2570
the time it requires to flush 100 pages */
2868
n_pages_flushed = buf_flush_list(
2869
PCT_IO(100), IB_ULONGLONG_MAX);
2572
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2871
2576
/* Otherwise, we only flush a small number of pages so that
2872
2577
we do not unnecessarily use much disk i/o capacity from
2875
n_pages_flushed = buf_flush_list(
2876
PCT_IO(10), IB_ULONGLONG_MAX);
2580
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2879
2585
srv_main_thread_op_info = "making checkpoint";
2917
2623
MySQL tries to drop a table while there are still open handles
2918
2624
to it and we had to put it to the background drop queue.) */
2920
if (srv_shutdown_state == SRV_SHUTDOWN_NONE) {
2921
os_thread_sleep(100000);
2626
os_thread_sleep(100000);
2629
srv_main_thread_op_info = "purging";
2631
/* Run a full purge */
2633
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2925
if (srv_n_purge_threads == 0) {
2926
srv_main_thread_op_info = "master purging";
2928
srv_master_do_purge();
2638
srv_main_thread_op_info = "purging";
2639
n_pages_purged = trx_purge();
2641
/* Flush logs if needed */
2642
srv_sync_log_buffer_in_background();
2644
} while (n_pages_purged);
2931
2646
srv_main_thread_op_info = "reserving kernel mutex";
3081
#if !defined(__SUNPRO_C)
2796
#if (!defined(__SUNPRO_C) && !defined(__SUNPRO_CC))
3082
2797
OS_THREAD_DUMMY_RETURN; /* Not reached, avoid compiler warning */
3086
/*********************************************************************//**
3087
Asynchronous purge thread.
3088
@return a dummy parameter */
3093
void* /*arg __attribute__((unused))*/) /*!< in: a dummy parameter
3094
required by os_thread_create */
3097
ulint slot_no = ULINT_UNDEFINED;
3098
ulint n_total_purged = ULINT_UNDEFINED;
3100
ut_a(srv_n_purge_threads == 1);
3102
#ifdef UNIV_DEBUG_THREAD_CREATION
3103
fprintf(stderr, "InnoDB: Purge thread running, id %lu\n",
3104
os_thread_pf(os_thread_get_curr_id()));
3105
#endif /* UNIV_DEBUG_THREAD_CREATION */
3107
mutex_enter(&kernel_mutex);
3109
slot_no = srv_table_reserve_slot(SRV_WORKER);
3111
slot = srv_table_get_nth_slot(slot_no);
3113
++srv_n_threads_active[SRV_WORKER];
3115
mutex_exit(&kernel_mutex);
3117
while (srv_shutdown_state != SRV_SHUTDOWN_EXIT_THREADS) {
3119
ulint n_pages_purged;
3121
/* If there are very few records to purge or the last
3122
purge didn't purge any records then wait for activity.
3123
We peek at the history len without holding any mutex
3124
because in the worst case we will end up waiting for
3125
the next purge event. */
3126
if (trx_sys->rseg_history_len < srv_purge_batch_size
3127
|| n_total_purged == 0) {
3131
mutex_enter(&kernel_mutex);
3133
event = srv_suspend_thread();
3135
mutex_exit(&kernel_mutex);
3137
os_event_wait(event);
3140
/* Check for shutdown and whether we should do purge at all. */
3141
if (srv_force_recovery >= SRV_FORCE_NO_BACKGROUND
3142
|| srv_shutdown_state != 0
3143
|| srv_fast_shutdown) {
3150
/* Purge until there are no more records to purge and there is
3151
no change in configuration or server state. */
3153
n_pages_purged = trx_purge(srv_purge_batch_size);
3155
n_total_purged += n_pages_purged;
3157
} while (n_pages_purged > 0 && !srv_fast_shutdown);
3159
srv_sync_log_buffer_in_background();
3162
mutex_enter(&kernel_mutex);
3164
ut_ad(srv_table_get_nth_slot(slot_no) == slot);
3166
/* Decrement the active count. */
3167
srv_suspend_thread();
3169
slot->in_use = FALSE;
3171
/* Free the thread local memory. */
3172
thr_local_free(os_thread_get_curr_id());
3174
mutex_exit(&kernel_mutex);
3176
#ifdef UNIV_DEBUG_THREAD_CREATION
3177
fprintf(stderr, "InnoDB: Purge thread exiting, id %lu\n",
3178
os_thread_pf(os_thread_get_curr_id()));
3179
#endif /* UNIV_DEBUG_THREAD_CREATION */
3181
/* We count the number of threads in os_thread_exit(). A created
3182
thread should always use that to exit and not use return() to exit. */
3183
os_thread_exit(NULL);
3185
OS_THREAD_DUMMY_RETURN; /* Not reached, avoid compiler warning */
3188
/**********************************************************************//**
3189
Enqueues a task to server task queue and releases a worker thread, if there
3190
is a suspended one. */
3193
srv_que_task_enqueue_low(
3194
/*=====================*/
3195
que_thr_t* thr) /*!< in: query thread */
3199
mutex_enter(&kernel_mutex);
3201
UT_LIST_ADD_LAST(queue, srv_sys->tasks, thr);
3203
srv_release_threads(SRV_WORKER, 1);
3205
mutex_exit(&kernel_mutex);
added
removed
plugin/innobase/srv/srv0srv.c
