1
1
/*****************************************************************************
3
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
4
Copyright (c) 2008, Google Inc.
4
Copyright (c) 2008, 2009 Google Inc.
6
6
Portions of this file contain modifications contributed and copyrighted by
7
7
Google, Inc. Those modifications are gratefully acknowledged and are described
22
22
Place, Suite 330, Boston, MA 02111-1307 USA
24
24
*****************************************************************************/
26
/******************************************************
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
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
50
***********************************************************************/
52
/**************************************************//**
27
54
The database server main program
29
56
NOTE: SQL Server 7 uses something which the documentation
97
124
UNIV_INTERN const char* srv_main_thread_op_info = "";
99
/* Prefix used by MySQL to indicate pre-5.1 table name encoding */
126
/** Prefix used by MySQL to indicate pre-5.1 table name encoding */
100
127
UNIV_INTERN const char srv_mysql50_table_name_prefix[9] = "#mysql50#";
102
129
/* Server parameters which are read from the initfile */
109
136
UNIV_INTERN char* srv_arch_dir = NULL;
110
137
#endif /* UNIV_LOG_ARCHIVE */
112
/* store to its own file each table created by an user; data
139
/** store to its own file each table created by an user; data
113
140
dictionary tables are in the system tablespace 0 */
114
141
UNIV_INTERN my_bool srv_file_per_table;
115
/* The file format to use on new *.ibd files. */
142
/** The file format to use on new *.ibd files. */
116
143
UNIV_INTERN ulint srv_file_format = 0;
117
/* Whether to check file format during startup a value of
144
/** Whether to check file format during startup. A value of
118
145
DICT_TF_FORMAT_MAX + 1 means no checking ie. FALSE. The default is to
119
146
set it to the highest format we support. */
120
147
UNIV_INTERN ulint srv_check_file_format_at_startup = DICT_TF_FORMAT_MAX;
122
149
#if DICT_TF_FORMAT_51
123
150
# error "DICT_TF_FORMAT_51 must be 0!"
125
/* Place locks to records only i.e. do not use next-key locking except
152
/** Place locks to records only i.e. do not use next-key locking except
126
153
on duplicate key checking and foreign key checking */
127
154
UNIV_INTERN ibool srv_locks_unsafe_for_binlog = FALSE;
156
183
UNIV_INTERN ulint srv_log_buffer_size = ULINT_MAX;
157
184
UNIV_INTERN ulong srv_flush_log_at_trx_commit = 1;
186
/* Try to flush dirty pages so as to avoid IO bursts at
188
UNIV_INTERN bool srv_adaptive_flushing = TRUE;
159
190
/* The sort order table of the MySQL latin1_swedish_ci character set
192
#if defined(BUILD_DRIZZLE)
161
193
UNIV_INTERN const byte srv_latin1_ordering[256] /* The sort order table of the latin1
162
194
character set. The following table is
163
195
the MySQL order as of Feb 10th, 2002 */
195
227
, 0x44, 0x4E, 0x4F, 0x4F, 0x4F, 0x4F, 0x5D, 0xF7
196
228
, 0xD8, 0x55, 0x55, 0x55, 0x59, 0x59, 0xDE, 0xFF
231
UNIV_INTERN const byte* srv_latin1_ordering;
232
#endif /* BUILD_DRIZZLE */
200
235
/* use os/external memory allocator */
209
244
UNIV_INTERN ulint srv_mem_pool_size = ULINT_MAX;
210
245
UNIV_INTERN ulint srv_lock_table_size = ULINT_MAX;
247
/* This parameter is deprecated. Use srv_n_io_[read|write]_threads
212
249
UNIV_INTERN ulint srv_n_file_io_threads = ULINT_MAX;
250
UNIV_INTERN ulint srv_n_read_io_threads = ULINT_MAX;
251
UNIV_INTERN ulint srv_n_write_io_threads = ULINT_MAX;
253
/* User settable value of the number of pages that must be present
254
in the buffer cache and accessed sequentially for InnoDB to trigger a
255
readahead request. */
256
UNIV_INTERN ulong srv_read_ahead_threshold = 56;
214
258
#ifdef UNIV_LOG_ARCHIVE
215
259
UNIV_INTERN ibool srv_log_archive_on = FALSE;
234
278
UNIV_INTERN ulint srv_max_n_open_files = 300;
280
/* Number of IO operations per second the server can do */
281
UNIV_INTERN ulong srv_io_capacity = 200;
236
283
/* The InnoDB main thread tries to keep the ratio of modified pages
237
284
in the buffer pool to all database pages in the buffer pool smaller than
238
285
the following number. But it is not guaranteed that the value stays below
239
286
that during a time of heavy update/insert activity. */
241
UNIV_INTERN ulong srv_max_buf_pool_modified_pct = 90;
288
UNIV_INTERN ulong srv_max_buf_pool_modified_pct = 75;
243
290
/* variable counts amount of data read in total (in bytes) */
244
291
UNIV_INTERN ulint srv_data_read = 0;
282
329
pool to the disk */
283
330
UNIV_INTERN ulint srv_buf_pool_flushed = 0;
285
/* variable to count the number of buffer pool reads that led to the
332
/** Number of buffer pool reads that led to the
286
333
reading of a disk page */
287
334
UNIV_INTERN ulint srv_buf_pool_reads = 0;
289
/* variable to count the number of sequential read-aheads */
336
/** Number of sequential read-aheads */
290
337
UNIV_INTERN ulint srv_read_ahead_seq = 0;
292
/* variable to count the number of random read-aheads */
339
/** Number of random read-aheads */
293
340
UNIV_INTERN ulint srv_read_ahead_rnd = 0;
295
342
/* structure to pass status variables to MySQL */
331
377
typedef struct srv_conc_slot_struct srv_conc_slot_t;
332
378
struct srv_conc_slot_struct{
333
os_event_t event; /* event to wait */
334
ibool reserved; /* TRUE if slot
379
os_event_t event; /*!< event to wait */
380
ibool reserved; /*!< TRUE if slot
336
ibool wait_ended; /* TRUE when another
382
ibool wait_ended; /*!< TRUE when another
337
383
thread has already set
338
384
the event and the
339
385
thread in this slot is
340
386
free to proceed; but
341
387
reserved may still be
342
388
TRUE at that point */
343
UT_LIST_NODE_T(srv_conc_slot_t) srv_conc_queue; /* queue node */
389
UT_LIST_NODE_T(srv_conc_slot_t) srv_conc_queue; /*!< queue node */
346
392
/* queue of threads waiting to get in */
375
421
UNIV_INTERN ulong srv_replication_delay = 0;
377
423
/*-------------------------------------------*/
378
UNIV_INTERN ulong srv_n_spin_wait_rounds = 20;
424
UNIV_INTERN ulong srv_n_spin_wait_rounds = 30;
379
425
UNIV_INTERN ulong srv_n_free_tickets_to_enter = 500;
380
426
UNIV_INTERN ulong srv_thread_sleep_delay = 10000;
381
UNIV_INTERN ulint srv_spin_wait_delay = 5;
427
UNIV_INTERN ulong srv_spin_wait_delay = 6;
382
428
UNIV_INTERN ibool srv_priority_boost = TRUE;
384
430
#ifdef UNIV_DEBUG
393
439
UNIV_INTERN ulint srv_n_rows_updated = 0;
394
440
UNIV_INTERN ulint srv_n_rows_deleted = 0;
395
441
UNIV_INTERN ulint srv_n_rows_read = 0;
396
#ifndef UNIV_HOTBACKUP
397
443
static ulint srv_n_rows_inserted_old = 0;
398
444
static ulint srv_n_rows_updated_old = 0;
399
445
static ulint srv_n_rows_deleted_old = 0;
400
446
static ulint srv_n_rows_read_old = 0;
401
#endif /* !UNIV_HOTBACKUP */
403
448
UNIV_INTERN ulint srv_n_lock_wait_count = 0;
404
449
UNIV_INTERN ulint srv_n_lock_wait_current_count = 0;
446
491
UNIV_INTERN ulint srv_main_thread_process_no = 0;
447
492
UNIV_INTERN ulint srv_main_thread_id = 0;
494
/* The following count work done by srv_master_thread. */
496
/* Iterations by the 'once per second' loop. */
497
static ulint srv_main_1_second_loops = 0;
498
/* Calls to sleep by the 'once per second' loop. */
499
static ulint srv_main_sleeps = 0;
500
/* Iterations by the 'once per 10 seconds' loop. */
501
static ulint srv_main_10_second_loops = 0;
502
/* Iterations of the loop bounded by the 'background_loop' label. */
503
static ulint srv_main_background_loops = 0;
504
/* Iterations of the loop bounded by the 'flush_loop' label. */
505
static ulint srv_main_flush_loops = 0;
506
/* Log writes involving flush. */
507
static ulint srv_log_writes_and_flush = 0;
508
/* Log writes not including flush. */
509
static ulint srv_log_buffer_writes = 0;
511
/* This is only ever touched by the master thread. It records the
512
time when the last flush of log file has happened. The master
513
thread ensures that we flush the log files at least once per
515
static time_t srv_last_log_flush_time;
517
/* The master thread performs various tasks based on the current
518
state of IO activity and the level of IO utilization is past
519
intervals. Following macros define thresholds for these conditions. */
520
#define SRV_PEND_IO_THRESHOLD (PCT_IO(3))
521
#define SRV_RECENT_IO_ACTIVITY (PCT_IO(5))
522
#define SRV_PAST_IO_ACTIVITY (PCT_IO(200))
450
525
IMPLEMENTATION OF THE SERVER MAIN PROGRAM
451
526
=========================================
617
692
/* Thread slot in the thread table */
618
693
struct srv_slot_struct{
619
os_thread_id_t id; /* thread id */
620
os_thread_t handle; /* thread handle */
621
unsigned type:3; /* thread type: user, utility etc. */
622
unsigned in_use:1; /* TRUE if this slot is in use */
623
unsigned suspended:1; /* TRUE if the thread is waiting
694
os_thread_id_t id; /*!< thread id */
695
os_thread_t handle; /*!< thread handle */
696
unsigned type:3; /*!< thread type: user, utility etc. */
697
unsigned in_use:1; /*!< TRUE if this slot is in use */
698
unsigned suspended:1; /*!< TRUE if the thread is waiting
624
699
for the event of this slot */
625
ib_time_t suspend_time; /* time when the thread was
700
ib_time_t suspend_time; /*!< time when the thread was
627
os_event_t event; /* event used in suspending the
702
os_event_t event; /*!< event used in suspending the
628
703
thread when it has nothing to do */
629
que_thr_t* thr; /* suspended query thread (only
704
que_thr_t* thr; /*!< suspended query thread (only
630
705
used for MySQL threads) */
667
742
UNIV_INTERN ulint srv_n_threads_active[SRV_MASTER + 1];
668
743
UNIV_INTERN ulint srv_n_threads[SRV_MASTER + 1];
670
/*************************************************************************
745
/***********************************************************************
746
Prints counters for work done by srv_master_thread. */
749
srv_print_master_thread_info(
750
/*=========================*/
751
FILE *file) /* in: output stream */
753
fprintf(file, "srv_master_thread loops: %lu 1_second, %lu sleeps, "
754
"%lu 10_second, %lu background, %lu flush\n",
755
srv_main_1_second_loops, srv_main_sleeps,
756
srv_main_10_second_loops, srv_main_background_loops,
757
srv_main_flush_loops);
758
fprintf(file, "srv_master_thread log flush and writes: %lu "
759
" log writes only: %lu\n",
760
srv_log_writes_and_flush, srv_log_buffer_writes);
763
/*********************************************************************//**
671
764
Sets the info describing an i/o thread current state. */
674
767
srv_set_io_thread_op_info(
675
768
/*======================*/
676
ulint i, /* in: the 'segment' of the i/o thread */
677
const char* str) /* in: constant char string describing the
769
ulint i, /*!< in: the 'segment' of the i/o thread */
770
const char* str) /*!< in: constant char string describing the
680
773
ut_a(i < SRV_MAX_N_IO_THREADS);
682
775
srv_io_thread_op_info[i] = str;
685
/*************************************************************************
778
/*********************************************************************//**
686
779
Accessor function to get pointer to n'th slot in the server thread
781
@return pointer to the slot */
690
784
srv_table_get_nth_slot(
691
785
/*===================*/
692
/* out: pointer to the slot */
693
ulint index) /* in: index of the slot */
786
ulint index) /*!< in: index of the slot */
695
788
ut_a(index < OS_THREAD_MAX_N);
697
790
return(srv_sys->threads + index);
700
#ifndef UNIV_HOTBACKUP
701
/*************************************************************************
702
Gets the number of threads in the system. */
793
/*********************************************************************//**
794
Gets the number of threads in the system.
795
@return sum of srv_n_threads[] */
705
798
srv_get_n_threads(void)
720
813
return(n_threads);
723
/*************************************************************************
816
/*********************************************************************//**
724
817
Reserves a slot in the thread table for the current thread. Also creates the
725
818
thread local storage struct for the current thread. NOTE! The server mutex
726
has to be reserved by the caller! */
819
has to be reserved by the caller!
820
@return reserved slot index */
729
823
srv_table_reserve_slot(
730
824
/*===================*/
731
/* out: reserved slot index */
732
enum srv_thread_type type) /* in: type of the thread */
825
enum srv_thread_type type) /*!< in: type of the thread */
734
827
srv_slot_t* slot;
763
/*************************************************************************
856
/*********************************************************************//**
764
857
Suspends the calling thread to wait for the event in its thread slot.
765
NOTE! The server mutex has to be reserved by the caller! */
858
NOTE! The server mutex has to be reserved by the caller!
859
@return event for the calling thread to wait */
768
862
srv_suspend_thread(void)
769
863
/*====================*/
770
/* out: event for the calling thread to wait */
772
865
srv_slot_t* slot;
773
866
os_event_t event;
806
#endif /* !UNIV_HOTBACKUP */
808
/*************************************************************************
900
/*********************************************************************//**
809
901
Releases threads of the type given from suspension in the thread table.
810
NOTE! The server mutex has to be reserved by the caller! */
902
NOTE! The server mutex has to be reserved by the caller!
903
@return number of threads released: this may be less than n if not
904
enough threads were suspended at the moment */
813
907
srv_release_threads(
814
908
/*================*/
815
/* out: number of threads
816
released: this may be < n if
817
not enough threads were
818
suspended at the moment */
819
enum srv_thread_type type, /* in: thread type */
820
ulint n) /* in: number of threads to release */
909
enum srv_thread_type type, /*!< in: thread type */
910
ulint n) /*!< in: number of threads to release */
822
912
srv_slot_t* slot;
862
/*************************************************************************
863
Returns the calling thread type. */
952
/*********************************************************************//**
953
Returns the calling thread type.
954
@return SRV_COM, ... */
865
956
enum srv_thread_type
866
957
srv_get_thread_type(void)
867
958
/*=====================*/
868
/* out: SRV_COM, ... */
871
961
srv_slot_t* slot;
943
1032
UT_LIST_INIT(srv_sys->tasks);
945
/* create dummy table and index for old-style infimum and supremum */
946
table = dict_mem_table_create("SYS_DUMMY1",
947
DICT_HDR_SPACE, 1, 0);
948
dict_mem_table_add_col(table, NULL, NULL, DATA_CHAR,
949
DATA_ENGLISH | DATA_NOT_NULL, 8);
951
srv_sys->dummy_ind1 = dict_mem_index_create(
952
"SYS_DUMMY1", "SYS_DUMMY1", DICT_HDR_SPACE, 0, 1);
953
dict_index_add_col(srv_sys->dummy_ind1, table,
954
dict_table_get_nth_col(table, 0), 0);
955
srv_sys->dummy_ind1->table = table;
956
/* create dummy table and index for new-style infimum and supremum */
957
table = dict_mem_table_create("SYS_DUMMY2",
958
DICT_HDR_SPACE, 1, DICT_TF_COMPACT);
959
dict_mem_table_add_col(table, NULL, NULL, DATA_CHAR,
960
DATA_ENGLISH | DATA_NOT_NULL, 8);
961
srv_sys->dummy_ind2 = dict_mem_index_create(
962
"SYS_DUMMY2", "SYS_DUMMY2", DICT_HDR_SPACE, 0, 1);
963
dict_index_add_col(srv_sys->dummy_ind2, table,
964
dict_table_get_nth_col(table, 0), 0);
965
srv_sys->dummy_ind2->table = table;
967
/* avoid ut_ad(index->cached) in dict_index_get_n_unique_in_tree */
968
srv_sys->dummy_ind1->cached = srv_sys->dummy_ind2->cached = TRUE;
1034
/* Create dummy indexes for infimum and supremum records */
970
1038
/* Init the server concurrency restriction data structures */
1016
1084
/* Maximum allowable purge history length. <=0 means 'infinite'. */
1017
1085
UNIV_INTERN ulong srv_max_purge_lag = 0;
1019
/*************************************************************************
1087
/*********************************************************************//**
1020
1088
Puts an OS thread to wait if there are too many concurrent threads
1021
1089
(>= srv_thread_concurrency) inside InnoDB. The threads wait in a FIFO queue. */
1024
1092
srv_conc_enter_innodb(
1025
1093
/*==================*/
1026
trx_t* trx) /* in: transaction object associated with the
1094
trx_t* trx) /*!< in: transaction object associated with the
1029
1097
ibool has_slept = FALSE;
1176
1244
os_fast_mutex_unlock(&srv_conc_mutex);
1179
/*************************************************************************
1247
/*********************************************************************//**
1180
1248
This lets a thread enter InnoDB regardless of the number of threads inside
1181
1249
InnoDB. This must be called when a thread ends a lock wait. */
1184
1252
srv_conc_force_enter_innodb(
1185
1253
/*========================*/
1186
trx_t* trx) /* in: transaction object associated with the
1254
trx_t* trx) /*!< in: transaction object associated with the
1189
1257
if (UNIV_LIKELY(!srv_thread_concurrency)) {
1202
1270
os_fast_mutex_unlock(&srv_conc_mutex);
1205
/*************************************************************************
1273
/*********************************************************************//**
1206
1274
This must be called when a thread exits InnoDB in a lock wait or at the
1207
1275
end of an SQL statement. */
1210
1278
srv_conc_force_exit_innodb(
1211
1279
/*=======================*/
1212
trx_t* trx) /* in: transaction object associated with the
1280
trx_t* trx) /*!< in: transaction object associated with the
1215
1283
srv_conc_slot_t* slot = NULL;
1262
/*************************************************************************
1330
/*********************************************************************//**
1263
1331
This must be called when a thread exits InnoDB. */
1266
1334
srv_conc_exit_innodb(
1267
1335
/*=================*/
1268
trx_t* trx) /* in: transaction object associated with the
1336
trx_t* trx) /*!< in: transaction object associated with the
1271
1339
if (trx->n_tickets_to_enter_innodb > 0) {
1285
1353
/*========================================================================*/
1287
/*************************************************************************
1288
Normalizes init parameter values to use units we use inside InnoDB. */
1355
/*********************************************************************//**
1356
Normalizes init parameter values to use units we use inside InnoDB.
1357
@return DB_SUCCESS or error code */
1291
1360
srv_normalize_init_values(void)
1292
1361
/*===========================*/
1293
/* out: DB_SUCCESS or error code */
1345
1413
return(DB_SUCCESS);
1348
#ifndef UNIV_HOTBACKUP
1349
/*************************************************************************
1416
/*********************************************************************//**
1350
1417
Reserves a slot in the thread table for the current MySQL OS thread.
1351
NOTE! The kernel mutex has to be reserved by the caller! */
1418
NOTE! The kernel mutex has to be reserved by the caller!
1419
@return reserved slot */
1354
1422
srv_table_reserve_slot_for_mysql(void)
1355
1423
/*==================================*/
1356
/* out: reserved slot */
1358
1425
srv_slot_t* slot;
1413
#endif /* !UNIV_HOTBACKUP */
1415
/*******************************************************************
1481
/***************************************************************//**
1416
1482
Puts a MySQL OS thread to wait for a lock to be released. If an error
1417
1483
occurs during the wait trx->error_state associated with thr is
1418
1484
!= DB_SUCCESS when we return. DB_LOCK_WAIT_TIMEOUT and DB_DEADLOCK
1591
1656
trx->error_state = DB_LOCK_WAIT_TIMEOUT;
1593
#else /* UNIV_HOTBACKUP */
1594
/* This function depends on MySQL code that is not included in
1595
InnoDB Hot Backup builds. Besides, this function should never
1596
be called in InnoDB Hot Backup. */
1598
#endif /* UNIV_HOTBACKUP */
1601
/************************************************************************
1660
/********************************************************************//**
1602
1661
Releases a MySQL OS thread waiting for a lock to be released, if the
1603
1662
thread is already suspended. */
1606
1665
srv_release_mysql_thread_if_suspended(
1607
1666
/*==================================*/
1608
que_thr_t* thr) /* in: query thread associated with the
1667
que_thr_t* thr) /*!< in: query thread associated with the
1609
1668
MySQL OS thread */
1611
#ifndef UNIV_HOTBACKUP
1612
1670
srv_slot_t* slot;
1630
1688
/* not found */
1631
#else /* UNIV_HOTBACKUP */
1632
/* This function depends on MySQL code that is not included in
1633
InnoDB Hot Backup builds. Besides, this function should never
1634
be called in InnoDB Hot Backup. */
1636
#endif /* UNIV_HOTBACKUP */
1639
#ifndef UNIV_HOTBACKUP
1640
/**********************************************************************
1691
/******************************************************************//**
1641
1692
Refreshes the values used to calculate per-second averages. */
1665
1716
mutex_exit(&srv_innodb_monitor_mutex);
1668
/**********************************************************************
1719
/******************************************************************//**
1669
1720
Outputs to a file the output of the InnoDB Monitor. */
1672
1723
srv_printf_innodb_monitor(
1673
1724
/*======================*/
1674
FILE* file, /* in: output stream */
1675
ulint* trx_start, /* out: file position of the start of
1725
FILE* file, /*!< in: output stream */
1726
ulint* trx_start, /*!< out: file position of the start of
1676
1727
the list of active transactions */
1677
ulint* trx_end) /* out: file position of the end of
1728
ulint* trx_end) /*!< out: file position of the end of
1678
1729
the list of active transactions */
1680
1731
double time_elapsed;
1844
/**********************************************************************
1900
/******************************************************************//**
1845
1901
Function to pass InnoDB status variables to MySQL */
1848
1904
srv_export_innodb_status(void)
1905
/*==========================*/
1850
1907
mutex_enter(&srv_innodb_monitor_mutex);
1884
1941
export_vars.innodb_buffer_pool_pages_misc = buf_pool->curr_size
1885
1942
- UT_LIST_GET_LEN(buf_pool->LRU)
1886
1943
- UT_LIST_GET_LEN(buf_pool->free);
1887
#ifdef HAVE_GCC_ATOMIC_BUILTINS
1944
#ifdef HAVE_ATOMIC_BUILTINS
1888
1945
export_vars.innodb_have_atomic_builtins = 1;
1890
1947
export_vars.innodb_have_atomic_builtins = 0;
1922
1979
mutex_exit(&srv_innodb_monitor_mutex);
1925
/*************************************************************************
1982
/*********************************************************************//**
1926
1983
A thread which wakes up threads whose lock wait may have lasted too long.
1927
This also prints the info output by various InnoDB monitors. */
1984
This also prints the info output by various InnoDB monitors.
1985
@return a dummy parameter */
1929
1987
os_thread_ret_t
1930
1988
srv_lock_timeout_and_monitor_thread(
1931
1989
/*================================*/
1932
/* out: a dummy parameter */
1933
1990
void* arg __attribute__((unused)))
1934
/* in: a dummy parameter required by
1991
/*!< in: a dummy parameter required by
1935
1992
os_thread_create */
1937
1994
srv_slot_t* slot;
2109
2166
OS_THREAD_DUMMY_RETURN;
2112
/*************************************************************************
2169
/*********************************************************************//**
2113
2170
A thread which prints warnings about semaphore waits which have lasted
2114
too long. These can be used to track bugs which cause hangs. */
2171
too long. These can be used to track bugs which cause hangs.
2172
@return a dummy parameter */
2116
2174
os_thread_ret_t
2117
2175
srv_error_monitor_thread(
2118
2176
/*=====================*/
2119
/* out: a dummy parameter */
2120
2177
void* arg __attribute__((unused)))
2121
/* in: a dummy parameter required by
2178
/*!< in: a dummy parameter required by
2122
2179
os_thread_create */
2124
2181
/* number of successive fatal timeouts observed */
2163
2220
/* Update the statistics collected for deciding LRU
2165
2222
buf_LRU_stat_update();
2224
/* Update the statistics collected for flush rate policy. */
2225
buf_flush_stat_update();
2167
2227
/* In case mutex_exit is not a memory barrier, it is
2168
2228
theoretically possible some threads are left waiting though
2169
2229
the semaphore is already released. Wake up those threads: */
2171
2231
sync_arr_wake_threads_if_sema_free();
2173
2233
if (sync_array_print_long_waits()) {
2209
2269
OS_THREAD_DUMMY_RETURN;
2212
/***********************************************************************
2272
/*******************************************************************//**
2213
2273
Tells the InnoDB server that there has been activity in the database
2214
2274
and wakes up the master thread if it is suspended (not sleeping). Used
2215
2275
in the MySQL interface. Note that there is a small chance that the master
2248
2308
mutex_exit(&kernel_mutex);
2251
/*************************************************************************
2252
The master thread controlling the server. */
2311
/**********************************************************************
2312
The master thread is tasked to ensure that flush of log file happens
2313
once every second in the background. This is to ensure that not more
2314
than one second of trxs are lost in case of crash when
2315
innodb_flush_logs_at_trx_commit != 1 */
2318
srv_sync_log_buffer_in_background(void)
2319
/*===================================*/
2321
time_t current_time = time(NULL);
2323
srv_main_thread_op_info = "flushing log";
2324
if (difftime(current_time, srv_last_log_flush_time) >= 1) {
2325
log_buffer_sync_in_background(TRUE);
2326
srv_last_log_flush_time = current_time;
2327
srv_log_writes_and_flush++;
2329
/* Actually we don't need to write logs here.
2330
We are just being extra safe here by forcing
2331
the log buffer to log file. */
2332
log_buffer_sync_in_background(FALSE);
2333
srv_log_buffer_writes++;
2337
/*********************************************************************//**
2338
The master thread controlling the server.
2339
@return a dummy parameter */
2254
2341
os_thread_ret_t
2255
2342
srv_master_thread(
2256
2343
/*==============*/
2257
/* out: a dummy parameter */
2258
2344
void* arg __attribute__((unused)))
2259
/* in: a dummy parameter required by
2345
/*!< in: a dummy parameter required by
2260
2346
os_thread_create */
2262
2348
os_event_t event;
2263
time_t last_flush_time;
2264
time_t current_time;
2265
2349
ulint old_activity_count;
2266
2350
ulint n_pages_purged = 0;
2267
2351
ulint n_bytes_merged;
2314
2398
/* ---- We run the following loop approximately once per second
2315
2399
when there is database activity */
2401
srv_last_log_flush_time = time(NULL);
2317
2402
skip_sleep = FALSE;
2319
2404
for (i = 0; i < 10; i++) {
2320
2405
n_ios_old = log_sys->n_log_ios + buf_pool->n_pages_read
2321
2406
+ buf_pool->n_pages_written;
2322
2407
srv_main_thread_op_info = "sleeping";
2408
srv_main_1_second_loops++;
2324
2410
if (!skip_sleep) {
2326
2412
os_thread_sleep(1000000);
2329
2416
skip_sleep = FALSE;
2343
2430
goto background_loop;
2346
/* We flush the log once in a second even if no commit
2347
is issued or the we have specified in my.cnf no flush
2348
at transaction commit */
2350
srv_main_thread_op_info = "flushing log";
2351
log_buffer_flush_to_disk();
2433
/* Flush logs if needed */
2434
srv_sync_log_buffer_in_background();
2353
2436
srv_main_thread_op_info = "making checkpoint";
2354
2437
log_free_check();
2356
/* If there were less than 5 i/os during the
2357
one second sleep, we assume that there is free
2358
disk i/o capacity available, and it makes sense to
2359
do an insert buffer merge. */
2439
/* If i/os during one second sleep were less than 5% of
2440
capacity, we assume that there is free disk i/o capacity
2441
available, and it makes sense to do an insert buffer merge. */
2361
2443
n_pend_ios = buf_get_n_pending_ios()
2362
2444
+ log_sys->n_pending_writes;
2363
2445
n_ios = log_sys->n_log_ios + buf_pool->n_pages_read
2364
2446
+ buf_pool->n_pages_written;
2365
if (n_pend_ios < 3 && (n_ios - n_ios_old < 5)) {
2447
if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2448
&& (n_ios - n_ios_old < SRV_RECENT_IO_ACTIVITY)) {
2366
2449
srv_main_thread_op_info = "doing insert buffer merge";
2367
ibuf_contract_for_n_pages(
2368
TRUE, srv_insert_buffer_batch_size / 4);
2370
srv_main_thread_op_info = "flushing log";
2372
log_buffer_flush_to_disk();
2450
ibuf_contract_for_n_pages(FALSE, PCT_IO(5));
2452
/* Flush logs if needed */
2453
srv_sync_log_buffer_in_background();
2375
2456
if (UNIV_UNLIKELY(buf_get_modified_ratio_pct()
2378
2459
/* Try to keep the number of modified pages in the
2379
2460
buffer pool under the limit wished by the user */
2381
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST, 100,
2462
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2382
2464
IB_ULONGLONG_MAX);
2384
2466
/* If we had to do the flush, it may have taken
2387
2469
iteration of this loop. */
2389
2471
skip_sleep = TRUE;
2472
} else if (srv_adaptive_flushing) {
2474
/* Try to keep the rate of flushing of dirty
2475
pages such that redo log generation does not
2476
produce bursts of IO at checkpoint time. */
2477
ulint n_flush = buf_flush_get_desired_flush_rate();
2480
n_flush = ut_min(PCT_IO(100), n_flush);
2392
2490
if (srv_activity_count == old_activity_count) {
2407
2505
mem_validate_all_blocks();
2409
/* If there were less than 200 i/os during the 10 second period,
2410
we assume that there is free disk i/o capacity available, and it
2411
makes sense to flush 100 pages. */
2507
/* If i/os during the 10 second period were less than 200% of
2508
capacity, we assume that there is free disk i/o capacity
2509
available, and it makes sense to flush srv_io_capacity pages.
2511
Note that this is done regardless of the fraction of dirty
2512
pages relative to the max requested by the user. The one second
2513
loop above requests writes for that case. The writes done here
2514
are not required, and may be disabled. */
2413
2516
n_pend_ios = buf_get_n_pending_ios() + log_sys->n_pending_writes;
2414
2517
n_ios = log_sys->n_log_ios + buf_pool->n_pages_read
2415
2518
+ buf_pool->n_pages_written;
2416
if (n_pend_ios < 3 && (n_ios - n_ios_very_old < 200)) {
2520
srv_main_10_second_loops++;
2521
if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2522
&& (n_ios - n_ios_very_old < SRV_PAST_IO_ACTIVITY)) {
2418
2524
srv_main_thread_op_info = "flushing buffer pool pages";
2419
buf_flush_batch(BUF_FLUSH_LIST, 100, IB_ULONGLONG_MAX);
2525
buf_flush_batch(BUF_FLUSH_LIST, PCT_IO(100),
2421
srv_main_thread_op_info = "flushing log";
2422
log_buffer_flush_to_disk();
2528
/* Flush logs if needed */
2529
srv_sync_log_buffer_in_background();
2425
2532
/* We run a batch of insert buffer merge every 10 seconds,
2426
2533
even if the server were active */
2428
2535
srv_main_thread_op_info = "doing insert buffer merge";
2429
ibuf_contract_for_n_pages(TRUE, srv_insert_buffer_batch_size / 4);
2536
ibuf_contract_for_n_pages(FALSE, PCT_IO(5));
2431
srv_main_thread_op_info = "flushing log";
2432
log_buffer_flush_to_disk();
2538
/* Flush logs if needed */
2539
srv_sync_log_buffer_in_background();
2434
2541
/* We run a full purge every 10 seconds, even if the server
2437
last_flush_time = time(NULL);
2441
2545
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2446
2550
srv_main_thread_op_info = "purging";
2447
2551
n_pages_purged = trx_purge();
2449
current_time = time(NULL);
2451
if (difftime(current_time, last_flush_time) > 1) {
2452
srv_main_thread_op_info = "flushing log";
2454
log_buffer_flush_to_disk();
2455
last_flush_time = current_time;
2553
/* Flush logs if needed */
2554
srv_sync_log_buffer_in_background();
2457
2556
} while (n_pages_purged);
2459
2558
srv_main_thread_op_info = "flushing buffer pool pages";
2466
2565
(> 70 %), we assume we can afford reserving the disk(s) for
2467
2566
the time it requires to flush 100 pages */
2469
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST, 100,
2568
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2470
2570
IB_ULONGLONG_MAX);
2472
2572
/* Otherwise, we only flush a small number of pages so that
2473
2573
we do not unnecessarily use much disk i/o capacity from
2476
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST, 10,
2576
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2477
2578
IB_ULONGLONG_MAX);
2536
2634
srv_main_thread_op_info = "purging";
2537
2635
n_pages_purged = trx_purge();
2539
current_time = time(NULL);
2541
if (difftime(current_time, last_flush_time) > 1) {
2542
srv_main_thread_op_info = "flushing log";
2544
log_buffer_flush_to_disk();
2545
last_flush_time = current_time;
2637
/* Flush logs if needed */
2638
srv_sync_log_buffer_in_background();
2547
2640
} while (n_pages_purged);
2549
2642
srv_main_thread_op_info = "reserving kernel mutex";
2560
2653
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2561
2654
n_bytes_merged = 0;
2563
n_bytes_merged = ibuf_contract_for_n_pages(
2564
TRUE, srv_insert_buffer_batch_size);
2656
/* This should do an amount of IO similar to the number of
2657
dirty pages that will be flushed in the call to
2658
buf_flush_batch below. Otherwise, the system favors
2659
clean pages over cleanup throughput. */
2660
n_bytes_merged = ibuf_contract_for_n_pages(FALSE,
2567
2664
srv_main_thread_op_info = "reserving kernel mutex";
2577
2674
srv_main_thread_op_info = "flushing buffer pool pages";
2675
srv_main_flush_loops++;
2579
2676
if (srv_fast_shutdown < 2) {
2580
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST, 100,
2677
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2581
2679
IB_ULONGLONG_MAX);
2583
2681
/* In the fastest shutdown we do not flush the buffer pool
2598
2696
srv_main_thread_op_info = "waiting for buffer pool flush to end";
2599
2697
buf_flush_wait_batch_end(BUF_FLUSH_LIST);
2601
srv_main_thread_op_info = "flushing log";
2603
log_buffer_flush_to_disk();
2699
/* Flush logs if needed */
2700
srv_sync_log_buffer_in_background();
2605
2702
srv_main_thread_op_info = "making checkpoint";
added
removed
plugin/innobase/srv/srv0srv.c
