1
1
/*****************************************************************************
3
Copyright (c) 1995, 2010, Innobase Oy. All Rights Reserved.
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
4
4
Copyright (c) 2008, 2009 Google Inc.
5
Copyright (c) 2009, Percona 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
10
9
incorporated with their permission, and subject to the conditions contained in
11
10
the file COPYING.Google.
13
Portions of this file contain modifications contributed and copyrighted
14
by Percona Inc.. Those modifications are
15
gratefully acknowledged and are described briefly in the InnoDB
16
documentation. The contributions by Percona Inc. are incorporated with
17
their permission, and subject to the conditions contained in the file
20
12
This program is free software; you can redistribute it and/or modify it under
21
13
the terms of the GNU General Public License as published by the Free Software
22
14
Foundation; version 2 of the License.
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
136
154
on duplicate key checking and foreign key checking */
137
155
UNIV_INTERN ibool srv_locks_unsafe_for_binlog = FALSE;
139
/* If this flag is TRUE, then we will use the native aio of the
140
OS (provided we compiled Innobase with it in), otherwise we will
141
use simulated aio we build below with threads.
142
Currently we support native aio on windows and linux */
143
UNIV_INTERN my_bool srv_use_native_aio = TRUE;
145
157
UNIV_INTERN ulint srv_n_data_files = 0;
146
158
UNIV_INTERN char** srv_data_file_names = NULL;
147
159
/* size in database pages */
176
188
the checkpoints. */
177
189
UNIV_INTERN bool srv_adaptive_flushing = TRUE;
179
/** Maximum number of times allowed to conditionally acquire
180
mutex before switching to blocking wait on the mutex */
181
#define MAX_MUTEX_NOWAIT 20
183
/** Check whether the number of failed nonblocking mutex
184
acquisition attempts exceeds maximum allowed value. If so,
185
srv_printf_innodb_monitor() will request mutex acquisition
186
with mutex_enter(), which will wait until it gets the mutex. */
187
#define MUTEX_NOWAIT(mutex_skipped) ((mutex_skipped) < MAX_MUTEX_NOWAIT)
189
/** 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
191
193
#if defined(BUILD_DRIZZLE)
192
194
UNIV_INTERN const byte srv_latin1_ordering[256] /* The sort order table of the latin1
472
466
/* Mutex for locking srv_monitor_file */
473
467
UNIV_INTERN mutex_t srv_monitor_file_mutex;
475
#ifdef UNIV_PFS_MUTEX
476
/* Key to register kernel_mutex with performance schema */
477
UNIV_INTERN mysql_pfs_key_t kernel_mutex_key;
478
/* Key to register srv_innodb_monitor_mutex with performance schema */
479
UNIV_INTERN mysql_pfs_key_t srv_innodb_monitor_mutex_key;
480
/* Key to register srv_monitor_file_mutex with performance schema */
481
UNIV_INTERN mysql_pfs_key_t srv_monitor_file_mutex_key;
482
/* Key to register srv_dict_tmpfile_mutex with performance schema */
483
UNIV_INTERN mysql_pfs_key_t srv_dict_tmpfile_mutex_key;
484
/* Key to register the mutex with performance schema */
485
UNIV_INTERN mysql_pfs_key_t srv_misc_tmpfile_mutex_key;
486
#endif /* UNIV_PFS_MUTEX */
488
468
/* Temporary file for innodb monitor output */
489
469
UNIV_INTERN FILE* srv_monitor_file;
490
470
/* Mutex for locking srv_dict_tmpfile.
1000
980
srv_sys = mem_alloc(sizeof(srv_sys_t));
1002
982
kernel_mutex_temp = mem_alloc(sizeof(mutex_t));
1003
mutex_create(kernel_mutex_key, &kernel_mutex, SYNC_KERNEL);
983
mutex_create(&kernel_mutex, SYNC_KERNEL);
1005
mutex_create(srv_innodb_monitor_mutex_key,
1006
&srv_innodb_monitor_mutex, SYNC_NO_ORDER_CHECK);
985
mutex_create(&srv_innodb_monitor_mutex, SYNC_NO_ORDER_CHECK);
1008
987
srv_sys->threads = mem_alloc(OS_THREAD_MAX_N * sizeof(srv_slot_t));
1749
1723
/******************************************************************//**
1750
Outputs to a file the output of the InnoDB Monitor.
1751
@return FALSE if not all information printed
1752
due to failure to obtain necessary mutex */
1724
Outputs to a file the output of the InnoDB Monitor. */
1755
1727
srv_printf_innodb_monitor(
1756
1728
/*======================*/
1757
1729
FILE* file, /*!< in: output stream */
1758
ibool nowait, /*!< in: whether to wait for kernel mutex */
1759
1730
ulint* trx_start, /*!< out: file position of the start of
1760
1731
the list of active transactions */
1761
1732
ulint* trx_end) /*!< out: file position of the end of
1815
1785
mutex_exit(&dict_foreign_err_mutex);
1817
/* Only if lock_print_info_summary proceeds correctly,
1818
before we call the lock_print_info_all_transactions
1819
to print all the lock information. */
1820
ret = lock_print_info_summary(file, nowait);
1824
long t = ftell(file);
1826
*trx_start = ULINT_UNDEFINED;
1828
*trx_start = (ulint) t;
1831
lock_print_info_all_transactions(file);
1833
long t = ftell(file);
1835
*trx_end = ULINT_UNDEFINED;
1837
*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;
1842
1805
fputs("--------\n"
1844
1807
"--------\n", file);
1969
1922
export_vars.innodb_data_reads = os_n_file_reads;
1970
1923
export_vars.innodb_data_writes = os_n_file_writes;
1971
1924
export_vars.innodb_data_written = srv_data_written;
1972
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;
1973
1926
export_vars.innodb_buffer_pool_write_requests
1974
1927
= srv_buf_pool_write_requests;
1975
1928
export_vars.innodb_buffer_pool_wait_free = srv_buf_pool_wait_free;
1976
1929
export_vars.innodb_buffer_pool_pages_flushed = srv_buf_pool_flushed;
1977
1930
export_vars.innodb_buffer_pool_reads = srv_buf_pool_reads;
1978
1931
export_vars.innodb_buffer_pool_read_ahead
1979
= stat.n_ra_pages_read;
1932
= buf_pool->stat.n_ra_pages_read;
1980
1933
export_vars.innodb_buffer_pool_read_ahead_evicted
1981
= stat.n_ra_pages_evicted;
1982
export_vars.innodb_buffer_pool_pages_data = LRU_len;
1983
export_vars.innodb_buffer_pool_pages_dirty = flush_list_len;
1984
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);
1985
1941
#ifdef UNIV_DEBUG
1986
1942
export_vars.innodb_buffer_pool_pages_latched
1987
1943
= buf_get_latched_pages_number();
1988
1944
#endif /* UNIV_DEBUG */
1989
export_vars.innodb_buffer_pool_pages_total = buf_pool_get_n_pages();
1945
export_vars.innodb_buffer_pool_pages_total = buf_pool->curr_size;
1991
export_vars.innodb_buffer_pool_pages_misc
1992
= 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);
1993
1950
#ifdef HAVE_ATOMIC_BUILTINS
1994
1951
export_vars.innodb_have_atomic_builtins = 1;
2005
1962
export_vars.innodb_log_writes = srv_log_writes;
2006
1963
export_vars.innodb_dblwr_pages_written = srv_dblwr_pages_written;
2007
1964
export_vars.innodb_dblwr_writes = srv_dblwr_writes;
2008
export_vars.innodb_pages_created = stat.n_pages_created;
2009
export_vars.innodb_pages_read = stat.n_pages_read;
2010
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;
2011
1968
export_vars.innodb_row_lock_waits = srv_n_lock_wait_count;
2012
1969
export_vars.innodb_row_lock_current_waits
2013
1970
= srv_n_lock_wait_current_count;
2031
1988
/*********************************************************************//**
2032
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.
2033
1991
@return a dummy parameter */
2035
1993
os_thread_ret_t
1994
srv_lock_timeout_and_monitor_thread(
1995
/*================================*/
2038
1996
void* arg __attribute__((unused)))
2039
1997
/*!< in: a dummy parameter required by
2040
1998
os_thread_create */
2042
2001
double time_elapsed;
2043
2002
time_t current_time;
2044
2003
time_t last_table_monitor_time;
2045
2004
time_t last_tablespace_monitor_time;
2046
2005
time_t last_monitor_time;
2047
ulint mutex_skipped;
2048
ibool last_srv_print_monitor;
2050
2010
#ifdef UNIV_DEBUG_THREAD_CREATION
2051
2011
fprintf(stderr, "Lock timeout thread starts, id %lu\n",
2052
2012
os_thread_pf(os_thread_get_curr_id()));
2055
#ifdef UNIV_PFS_THREAD
2056
pfs_register_thread(srv_monitor_thread_key);
2059
2014
UT_NOT_USED(arg);
2060
2015
srv_last_monitor_time = time(NULL);
2061
2016
last_table_monitor_time = time(NULL);
2062
2017
last_tablespace_monitor_time = time(NULL);
2063
2018
last_monitor_time = time(NULL);
2065
last_srv_print_monitor = srv_print_innodb_monitor;
2067
srv_monitor_active = TRUE;
2069
/* Wake up every 5 seconds to see if we need to print
2070
monitor information. */
2072
os_thread_sleep(5000000);
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);
2074
2027
current_time = time(NULL);
2079
2032
last_monitor_time = time(NULL);
2081
2034
if (srv_print_innodb_monitor) {
2082
/* Reset mutex_skipped counter everytime
2083
srv_print_innodb_monitor changes. This is to
2084
ensure we will not be blocked by kernel_mutex
2085
for short duration information printing,
2086
such as requested by sync_array_print_long_waits() */
2087
if (!last_srv_print_monitor) {
2089
last_srv_print_monitor = TRUE;
2092
if (!srv_printf_innodb_monitor(stderr,
2093
MUTEX_NOWAIT(mutex_skipped),
2097
/* Reset the counter */
2101
last_srv_print_monitor = FALSE;
2035
srv_printf_innodb_monitor(stderr, NULL, NULL);
2105
2038
if (srv_innodb_status) {
2106
2039
mutex_enter(&srv_monitor_file_mutex);
2107
2040
rewind(srv_monitor_file);
2108
if (!srv_printf_innodb_monitor(srv_monitor_file,
2109
MUTEX_NOWAIT(mutex_skipped),
2041
srv_printf_innodb_monitor(srv_monitor_file, NULL,
2116
2043
os_file_set_eof(srv_monitor_file);
2117
2044
mutex_exit(&srv_monitor_file_mutex);
2168
if (srv_shutdown_state >= SRV_SHUTDOWN_CLEANUP) {
2172
if (srv_print_innodb_monitor
2173
|| srv_print_innodb_lock_monitor
2174
|| srv_print_innodb_tablespace_monitor
2175
|| srv_print_innodb_table_monitor) {
2179
srv_monitor_active = FALSE;
2184
srv_monitor_active = FALSE;
2186
/* We count the number of threads in os_thread_exit(). A created
2187
thread should always use that to exit and not use return() to exit. */
2189
os_thread_exit(NULL);
2191
OS_THREAD_DUMMY_RETURN;
2194
/*********************************************************************//**
2195
A thread which wakes up threads whose lock wait may have lasted too long.
2196
@return a dummy parameter */
2199
srv_lock_timeout_thread(
2200
/*====================*/
2201
void* arg __attribute__((unused)))
2202
/* in: a dummy parameter required by
2210
#ifdef UNIV_PFS_THREAD
2211
pfs_register_thread(srv_lock_timeout_thread_key);
2215
/* When someone is waiting for a lock, we wake up every second
2216
and check if a timeout has passed for a lock wait */
2218
os_thread_sleep(1000000);
2220
srv_lock_timeout_active = TRUE;
2222
2095
mutex_enter(&kernel_mutex);
2224
2097
some_waits = FALSE;
2402
2275
OS_THREAD_DUMMY_RETURN;
2405
/**********************************************************************//**
2406
Check whether any background thread is active.
2407
@return FALSE if all are are suspended or have exited. */
2410
srv_is_any_background_thread_active(void)
2411
/*=====================================*/
2416
mutex_enter(&kernel_mutex);
2418
for (i = SRV_COM; i <= SRV_MASTER; ++i) {
2419
if (srv_n_threads_active[i] != 0) {
2425
mutex_exit(&kernel_mutex);
2430
2278
/*******************************************************************//**
2431
2279
Tells the InnoDB server that there has been activity in the database
2432
2280
and wakes up the master thread if it is suspended (not sleeping). Used
2433
2281
in the MySQL interface. Note that there is a small chance that the master
2434
thread stays suspended (we do not protect our operation with the
2435
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). */
2438
2286
srv_active_wake_master_thread(void)
2453
2301
/*******************************************************************//**
2454
Tells the purge thread that there has been activity in the database
2455
and wakes up the purge thread if it is suspended (not sleeping). Note
2456
that there is a small chance that the purge thread stays suspended
2457
(we do not protect our operation with the kernel mutex, for
2458
performace reasons). */
2461
srv_wake_purge_thread_if_not_active(void)
2462
/*=====================================*/
2464
ut_ad(!mutex_own(&kernel_mutex));
2466
if (srv_n_purge_threads > 0
2467
&& srv_n_threads_active[SRV_WORKER] == 0) {
2469
mutex_enter(&kernel_mutex);
2471
srv_release_threads(SRV_WORKER, 1);
2473
mutex_exit(&kernel_mutex);
2477
/*******************************************************************//**
2478
2302
Wakes up the master thread if it is suspended or being suspended. */
2490
2314
mutex_exit(&kernel_mutex);
2493
/*******************************************************************//**
2494
Wakes up the purge thread if it's not already awake. */
2497
srv_wake_purge_thread(void)
2498
/*=======================*/
2500
ut_ad(!mutex_own(&kernel_mutex));
2502
if (srv_n_purge_threads > 0) {
2504
mutex_enter(&kernel_mutex);
2506
srv_release_threads(SRV_WORKER, 1);
2508
mutex_exit(&kernel_mutex);
2512
2317
/**********************************************************************
2513
2318
The master thread is tasked to ensure that flush of log file happens
2514
2319
once every second in the background. This is to ensure that not more
2532
/********************************************************************//**
2533
Do a full purge, reconfigure the purge sub-system if a dynamic
2534
change is detected. */
2537
srv_master_do_purge(void)
2538
/*=====================*/
2540
ulint n_pages_purged;
2542
ut_ad(!mutex_own(&kernel_mutex));
2544
ut_a(srv_n_purge_threads == 0);
2547
/* Check for shutdown and change in purge config. */
2548
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2549
/* Nothing to purge. */
2552
n_pages_purged = trx_purge(srv_purge_batch_size);
2555
srv_sync_log_buffer_in_background();
2557
} while (n_pages_purged > 0);
2560
2337
/*********************************************************************//**
2561
2338
The master thread controlling the server.
2562
2339
@return a dummy parameter */
2629
2399
when there is database activity */
2631
2401
srv_last_log_flush_time = time(NULL);
2632
next_itr_time = ut_time_ms();
2634
2404
for (i = 0; i < 10; i++) {
2635
ulint cur_time = ut_time_ms();
2637
buf_get_total_stat(&buf_stat);
2639
n_ios_old = log_sys->n_log_ios + buf_stat.n_pages_read
2640
+ buf_stat.n_pages_written;
2405
n_ios_old = log_sys->n_log_ios + buf_pool->stat.n_pages_read
2406
+ buf_pool->stat.n_pages_written;
2642
2407
srv_main_thread_op_info = "sleeping";
2643
2408
srv_main_1_second_loops++;
2645
if (next_itr_time > cur_time) {
2647
/* Get sleep interval in micro seconds. We use
2648
ut_min() to avoid long sleep in case of
2650
os_thread_sleep(ut_min(1000000,
2651
(next_itr_time - cur_time)
2412
os_thread_sleep(1000000);
2653
2413
srv_main_sleeps++;
2656
/* Each iteration should happen at 1 second interval. */
2657
next_itr_time = ut_time_ms() + 1000;
2659
2418
/* ALTER TABLE in MySQL requires on Unix that the table handler
2660
2419
can drop tables lazily after there no longer are SELECT
2678
2437
log_free_check();
2680
2439
/* If i/os during one second sleep were less than 5% of
2681
capacity, we assume that there is free disk i/o capacity
2682
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. */
2684
buf_get_total_stat(&buf_stat);
2685
2443
n_pend_ios = buf_get_n_pending_ios()
2686
2444
+ log_sys->n_pending_writes;
2687
n_ios = log_sys->n_log_ios + buf_stat.n_pages_read
2688
+ 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;
2689
2447
if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2690
2448
&& (n_ios - n_ios_old < SRV_RECENT_IO_ACTIVITY)) {
2691
2449
srv_main_thread_op_info = "doing insert buffer merge";
2704
2462
srv_main_thread_op_info =
2705
2463
"flushing buffer pool pages";
2706
n_pages_flushed = buf_flush_list(
2707
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. */
2709
2474
} else if (srv_adaptive_flushing) {
2711
2476
/* Try to keep the rate of flushing of dirty
2750
2517
loop above requests writes for that case. The writes done here
2751
2518
are not required, and may be disabled. */
2753
buf_get_total_stat(&buf_stat);
2754
2520
n_pend_ios = buf_get_n_pending_ios() + log_sys->n_pending_writes;
2755
n_ios = log_sys->n_log_ios + buf_stat.n_pages_read
2756
+ 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;
2758
2524
srv_main_10_second_loops++;
2759
2525
if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2760
2526
&& (n_ios - n_ios_very_old < SRV_PAST_IO_ACTIVITY)) {
2762
2528
srv_main_thread_op_info = "flushing buffer pool pages";
2763
buf_flush_list(PCT_IO(100), IB_ULONGLONG_MAX);
2529
buf_flush_batch(BUF_FLUSH_LIST, PCT_IO(100),
2765
2532
/* Flush logs if needed */
2766
2533
srv_sync_log_buffer_in_background();
2775
2542
/* Flush logs if needed */
2776
2543
srv_sync_log_buffer_in_background();
2778
if (srv_n_purge_threads == 0) {
2779
srv_main_thread_op_info = "master purging";
2781
srv_master_do_purge();
2545
/* We run a full purge every 10 seconds, even if the server
2783
2549
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2785
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);
2789
2562
srv_main_thread_op_info = "flushing buffer pool pages";
2796
2569
(> 70 %), we assume we can afford reserving the disk(s) for
2797
2570
the time it requires to flush 100 pages */
2799
n_pages_flushed = buf_flush_list(
2800
PCT_IO(100), IB_ULONGLONG_MAX);
2572
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2802
2576
/* Otherwise, we only flush a small number of pages so that
2803
2577
we do not unnecessarily use much disk i/o capacity from
2806
n_pages_flushed = buf_flush_list(
2807
PCT_IO(10), IB_ULONGLONG_MAX);
2580
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2810
2585
srv_main_thread_op_info = "making checkpoint";
3011
2797
OS_THREAD_DUMMY_RETURN; /* Not reached, avoid compiler warning */
3015
/*********************************************************************//**
3016
Asynchronous purge thread.
3017
@return a dummy parameter */
3022
void* arg __attribute__((unused))) /*!< in: a dummy parameter
3023
required by os_thread_create */
3026
ulint slot_no = ULINT_UNDEFINED;
3027
ulint n_total_purged = ULINT_UNDEFINED;
3029
ut_a(srv_n_purge_threads == 1);
3031
#ifdef UNIV_DEBUG_THREAD_CREATION
3032
fprintf(stderr, "InnoDB: Purge thread running, id %lu\n",
3033
os_thread_pf(os_thread_get_curr_id()));
3034
#endif /* UNIV_DEBUG_THREAD_CREATION */
3036
mutex_enter(&kernel_mutex);
3038
slot_no = srv_table_reserve_slot(SRV_WORKER);
3040
++srv_n_threads_active[SRV_WORKER];
3042
mutex_exit(&kernel_mutex);
3044
while (srv_shutdown_state != SRV_SHUTDOWN_EXIT_THREADS) {
3046
ulint n_pages_purged;
3048
/* If there are very few records to purge or the last
3049
purge didn't purge any records then wait for activity.
3050
We peek at the history len without holding any mutex
3051
because in the worst case we will end up waiting for
3052
the next purge event. */
3053
if (trx_sys->rseg_history_len < srv_purge_batch_size
3054
|| n_total_purged == 0) {
3058
mutex_enter(&kernel_mutex);
3060
event = srv_suspend_thread();
3062
mutex_exit(&kernel_mutex);
3064
os_event_wait(event);
3067
/* Check for shutdown and whether we should do purge at all. */
3068
if (srv_force_recovery >= SRV_FORCE_NO_BACKGROUND
3069
|| srv_shutdown_state != 0
3070
|| srv_fast_shutdown) {
3077
/* Purge until there are no more records to purge and there is
3078
no change in configuration or server state. */
3080
n_pages_purged = trx_purge(srv_purge_batch_size);
3082
n_total_purged += n_pages_purged;
3084
} while (n_pages_purged > 0 && !srv_fast_shutdown);
3086
srv_sync_log_buffer_in_background();
3089
mutex_enter(&kernel_mutex);
3091
/* Decrement the active count. */
3092
srv_suspend_thread();
3094
mutex_exit(&kernel_mutex);
3096
/* Free the thread local memory. */
3097
thr_local_free(os_thread_get_curr_id());
3099
mutex_enter(&kernel_mutex);
3101
/* Free the slot for reuse. */
3102
slot = srv_table_get_nth_slot(slot_no);
3103
slot->in_use = FALSE;
3105
mutex_exit(&kernel_mutex);
3107
#ifdef UNIV_DEBUG_THREAD_CREATION
3108
fprintf(stderr, "InnoDB: Purge thread exiting, id %lu\n",
3109
os_thread_pf(os_thread_get_curr_id()));
3110
#endif /* UNIV_DEBUG_THREAD_CREATION */
3112
/* We count the number of threads in os_thread_exit(). A created
3113
thread should always use that to exit and not use return() to exit. */
3114
os_thread_exit(NULL);
3116
OS_THREAD_DUMMY_RETURN; /* Not reached, avoid compiler warning */
3119
/**********************************************************************//**
3120
Enqueues a task to server task queue and releases a worker thread, if there
3121
is a suspended one. */
3124
srv_que_task_enqueue_low(
3125
/*=====================*/
3126
que_thr_t* thr) /*!< in: query thread */
3130
mutex_enter(&kernel_mutex);
3132
UT_LIST_ADD_LAST(queue, srv_sys->tasks, thr);
3134
srv_release_threads(SRV_WORKER, 1);
3136
mutex_exit(&kernel_mutex);
added
removed
plugin/innobase/srv/srv0srv.c
