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, 2010, Innobase Oy. All Rights Reserved.
4
Copyright (c) 2008, 2009 Google Inc.
5
Copyright (c) 2009, Percona Inc.
7
7
Portions of this file contain modifications contributed and copyrighted by
8
8
Google, Inc. Those modifications are gratefully acknowledged and are described
136
137
on duplicate key checking and foreign key checking */
137
138
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;
146
/* Windows native condition variables. We use runtime loading / function
147
pointers, because they are not available on Windows Server 2003 and
150
We use condition for events on Windows if possible, even if os_event
151
resembles Windows kernel event object well API-wise. The reason is
152
performance, kernel objects are heavyweights and WaitForSingleObject() is a
153
performance killer causing calling thread to context switch. Besides, Innodb
154
is preallocating large number (often millions) of os_events. With kernel event
155
objects it takes a big chunk out of non-paged pool, which is better suited
156
for tasks like IO than for storing idle event objects. */
157
UNIV_INTERN ibool srv_use_native_conditions = FALSE;
160
140
UNIV_INTERN ulint srv_n_data_files = 0;
161
141
UNIV_INTERN char** srv_data_file_names = NULL;
162
142
/* size in database pages */
488
459
/* Mutex for locking srv_monitor_file */
489
460
UNIV_INTERN mutex_t srv_monitor_file_mutex;
491
#ifdef UNIV_PFS_MUTEX
492
/* Key to register kernel_mutex with performance schema */
493
UNIV_INTERN mysql_pfs_key_t kernel_mutex_key;
494
/* Key to protect writing the commit_id to the sys header */
495
UNIV_INTERN mysql_pfs_key_t commit_id_mutex_key;
496
/* Key to register srv_innodb_monitor_mutex with performance schema */
497
UNIV_INTERN mysql_pfs_key_t srv_innodb_monitor_mutex_key;
498
/* Key to register srv_monitor_file_mutex with performance schema */
499
UNIV_INTERN mysql_pfs_key_t srv_monitor_file_mutex_key;
500
/* Key to register srv_dict_tmpfile_mutex with performance schema */
501
UNIV_INTERN mysql_pfs_key_t srv_dict_tmpfile_mutex_key;
502
/* Key to register the mutex with performance schema */
503
UNIV_INTERN mysql_pfs_key_t srv_misc_tmpfile_mutex_key;
504
#endif /* UNIV_PFS_MUTEX */
506
461
/* Temporary file for innodb monitor output */
507
462
UNIV_INTERN FILE* srv_monitor_file;
508
463
/* Mutex for locking srv_dict_tmpfile.
1026
970
srv_slot_t* slot;
1029
srv_sys = static_cast<srv_sys_t *>(mem_alloc(sizeof(srv_sys_t)));
1031
kernel_mutex_temp = static_cast<ib_mutex_t *>(mem_alloc(sizeof(mutex_t)));
1032
mutex_create(kernel_mutex_key, &kernel_mutex, SYNC_KERNEL);
1034
commit_id_mutex_temp = static_cast<ib_mutex_t *>(mem_alloc(sizeof(mutex_t)));
1035
mutex_create(commit_id_mutex_key, &commit_id_mutex, SYNC_COMMIT_ID_LOCK);
1037
mutex_create(srv_innodb_monitor_mutex_key,
1038
&srv_innodb_monitor_mutex, SYNC_NO_ORDER_CHECK);
1040
srv_sys->threads = static_cast<srv_table_t *>(mem_alloc(OS_THREAD_MAX_N * sizeof(srv_slot_t)));
973
srv_sys = mem_alloc(sizeof(srv_sys_t));
975
kernel_mutex_temp = mem_alloc(sizeof(mutex_t));
976
mutex_create(&kernel_mutex, SYNC_KERNEL);
978
mutex_create(&srv_innodb_monitor_mutex, SYNC_NO_ORDER_CHECK);
980
srv_sys->threads = mem_alloc(OS_THREAD_MAX_N * sizeof(srv_slot_t));
1042
982
for (i = 0; i < OS_THREAD_MAX_N; i++) {
1043
983
slot = srv_table_get_nth_slot(i);
1645
1576
row_mysql_unfreeze_data_dictionary(trx);
1647
1578
case RW_X_LATCH:
1648
/* There should never be a lock wait when the
1649
dictionary latch is reserved in X mode. Dictionary
1650
transactions should only acquire locks on dictionary
1651
tables, not other tables. All access to dictionary
1652
tables should be covered by dictionary
1654
ut_print_timestamp(stderr);
1655
fputs(" InnoDB: Error: dict X latch held in "
1656
"srv_suspend_mysql_thread\n", stderr);
1657
/* This should never occur. This incorrect handling
1658
was added in the early development of
1659
ha_innobase::add_index() in InnoDB Plugin 1.0. */
1660
1579
/* Release fast index creation latch */
1661
1580
row_mysql_unlock_data_dictionary(trx);
2028
1933
export_vars.innodb_data_reads = os_n_file_reads;
2029
1934
export_vars.innodb_data_writes = os_n_file_writes;
2030
1935
export_vars.innodb_data_written = srv_data_written;
2031
export_vars.innodb_buffer_pool_read_requests = stat.n_page_gets;
1936
export_vars.innodb_buffer_pool_read_requests = buf_pool->stat.n_page_gets;
2032
1937
export_vars.innodb_buffer_pool_write_requests
2033
1938
= srv_buf_pool_write_requests;
2034
1939
export_vars.innodb_buffer_pool_wait_free = srv_buf_pool_wait_free;
2035
1940
export_vars.innodb_buffer_pool_pages_flushed = srv_buf_pool_flushed;
2036
1941
export_vars.innodb_buffer_pool_reads = srv_buf_pool_reads;
2037
1942
export_vars.innodb_buffer_pool_read_ahead
2038
= stat.n_ra_pages_read;
1943
= buf_pool->stat.n_ra_pages_read;
2039
1944
export_vars.innodb_buffer_pool_read_ahead_evicted
2040
= stat.n_ra_pages_evicted;
2041
export_vars.innodb_buffer_pool_pages_data = LRU_len;
2042
export_vars.innodb_buffer_pool_pages_dirty = flush_list_len;
2043
export_vars.innodb_buffer_pool_pages_free = free_len;
1945
= buf_pool->stat.n_ra_pages_evicted;
1946
export_vars.innodb_buffer_pool_pages_data
1947
= UT_LIST_GET_LEN(buf_pool->LRU);
1948
export_vars.innodb_buffer_pool_pages_dirty
1949
= UT_LIST_GET_LEN(buf_pool->flush_list);
1950
export_vars.innodb_buffer_pool_pages_free
1951
= UT_LIST_GET_LEN(buf_pool->free);
2044
1952
#ifdef UNIV_DEBUG
2045
1953
export_vars.innodb_buffer_pool_pages_latched
2046
1954
= buf_get_latched_pages_number();
2047
1955
#endif /* UNIV_DEBUG */
2048
export_vars.innodb_buffer_pool_pages_total = buf_pool_get_n_pages();
1956
export_vars.innodb_buffer_pool_pages_total = buf_pool->curr_size;
2050
export_vars.innodb_buffer_pool_pages_misc
2051
= buf_pool_get_n_pages() - LRU_len - free_len;
1958
export_vars.innodb_buffer_pool_pages_misc = buf_pool->curr_size
1959
- UT_LIST_GET_LEN(buf_pool->LRU)
1960
- UT_LIST_GET_LEN(buf_pool->free);
2052
1961
#ifdef HAVE_ATOMIC_BUILTINS
2053
1962
export_vars.innodb_have_atomic_builtins = 1;
2064
1973
export_vars.innodb_log_writes = srv_log_writes;
2065
1974
export_vars.innodb_dblwr_pages_written = srv_dblwr_pages_written;
2066
1975
export_vars.innodb_dblwr_writes = srv_dblwr_writes;
2067
export_vars.innodb_pages_created = stat.n_pages_created;
2068
export_vars.innodb_pages_read = stat.n_pages_read;
2069
export_vars.innodb_pages_written = stat.n_pages_written;
1976
export_vars.innodb_pages_created = buf_pool->stat.n_pages_created;
1977
export_vars.innodb_pages_read = buf_pool->stat.n_pages_read;
1978
export_vars.innodb_pages_written = buf_pool->stat.n_pages_written;
2070
1979
export_vars.innodb_row_lock_waits = srv_n_lock_wait_count;
2071
1980
export_vars.innodb_row_lock_current_waits
2072
1981
= srv_n_lock_wait_current_count;
2112
2019
fprintf(stderr, "Lock timeout thread starts, id %lu\n",
2113
2020
os_thread_pf(os_thread_get_curr_id()));
2116
#ifdef UNIV_PFS_THREAD
2117
pfs_register_thread(srv_monitor_thread_key);
2120
srv_last_monitor_time = ut_time();
2121
last_table_monitor_time = ut_time();
2122
last_tablespace_monitor_time = ut_time();
2123
last_monitor_time = ut_time();
2023
srv_last_monitor_time = time(NULL);
2024
last_table_monitor_time = time(NULL);
2025
last_tablespace_monitor_time = time(NULL);
2026
last_monitor_time = time(NULL);
2124
2027
mutex_skipped = 0;
2125
2028
last_srv_print_monitor = srv_print_innodb_monitor;
2127
2030
srv_monitor_active = TRUE;
2129
2032
/* Wake up every 5 seconds to see if we need to print
2130
monitor information or if signalled at shutdown. */
2132
sig_count = os_event_reset(srv_monitor_event);
2134
os_event_wait_time_low(srv_monitor_event, 5000000, sig_count);
2136
current_time = ut_time();
2033
monitor information. */
2035
os_thread_sleep(5000000);
2037
current_time = time(NULL);
2138
2039
time_elapsed = difftime(current_time, last_monitor_time);
2140
2041
if (time_elapsed > 15) {
2141
last_monitor_time = ut_time();
2042
last_monitor_time = time(NULL);
2143
2044
if (srv_print_innodb_monitor) {
2144
2045
/* Reset mutex_skipped counter everytime
2467
2356
OS_THREAD_DUMMY_RETURN;
2470
/**********************************************************************//**
2471
Check whether any background thread is active.
2472
@return FALSE if all are are suspended or have exited. */
2475
srv_is_any_background_thread_active(void)
2476
/*=====================================*/
2481
mutex_enter(&kernel_mutex);
2483
for (i = SRV_COM; i <= SRV_MASTER; ++i) {
2484
if (srv_n_threads_active[i] != 0) {
2490
mutex_exit(&kernel_mutex);
2495
2359
/*******************************************************************//**
2496
2360
Tells the InnoDB server that there has been activity in the database
2497
2361
and wakes up the master thread if it is suspended (not sleeping). Used
2498
2362
in the MySQL interface. Note that there is a small chance that the master
2499
thread stays suspended (we do not protect our operation with the
2500
srv_sys_t->mutex, for performance reasons). */
2363
thread stays suspended (we do not protect our operation with the kernel
2364
mutex, for performace reasons). */
2503
2367
srv_active_wake_master_thread(void)
2518
2382
/*******************************************************************//**
2519
Tells the purge thread that there has been activity in the database
2520
and wakes up the purge thread if it is suspended (not sleeping). Note
2521
that there is a small chance that the purge thread stays suspended
2522
(we do not protect our operation with the kernel mutex, for
2523
performace reasons). */
2526
srv_wake_purge_thread_if_not_active(void)
2527
/*=====================================*/
2529
ut_ad(!mutex_own(&kernel_mutex));
2531
if (srv_n_purge_threads > 0
2532
&& srv_n_threads_active[SRV_WORKER] == 0) {
2534
mutex_enter(&kernel_mutex);
2536
srv_release_threads(SRV_WORKER, 1);
2538
mutex_exit(&kernel_mutex);
2542
/*******************************************************************//**
2543
2383
Wakes up the master thread if it is suspended or being suspended. */
2555
2395
mutex_exit(&kernel_mutex);
2558
/*******************************************************************//**
2559
Wakes up the purge thread if it's not already awake. */
2562
srv_wake_purge_thread(void)
2563
/*=======================*/
2565
ut_ad(!mutex_own(&kernel_mutex));
2567
if (srv_n_purge_threads > 0) {
2569
mutex_enter(&kernel_mutex);
2571
srv_release_threads(SRV_WORKER, 1);
2573
mutex_exit(&kernel_mutex);
2577
2398
/**********************************************************************
2578
2399
The master thread is tasked to ensure that flush of log file happens
2579
2400
once every second in the background. This is to ensure that not more
2597
/********************************************************************//**
2598
Do a full purge, reconfigure the purge sub-system if a dynamic
2599
change is detected. */
2602
srv_master_do_purge(void)
2603
/*=====================*/
2605
ulint n_pages_purged;
2607
ut_ad(!mutex_own(&kernel_mutex));
2609
ut_a(srv_n_purge_threads == 0);
2612
/* Check for shutdown and change in purge config. */
2613
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2614
/* Nothing to purge. */
2617
n_pages_purged = trx_purge(srv_purge_batch_size);
2620
srv_sync_log_buffer_in_background();
2622
} while (n_pages_purged > 0);
2625
2418
/*********************************************************************//**
2626
2419
The master thread controlling the server.
2627
2420
@return a dummy parameter */
2694
2480
when there is database activity */
2696
2482
srv_last_log_flush_time = time(NULL);
2698
/* Sleep for 1 second on entrying the for loop below the first time. */
2699
next_itr_time = ut_time_ms() + 1000;
2701
2485
for (i = 0; i < 10; i++) {
2702
ulint cur_time = ut_time_ms();
2486
n_ios_old = log_sys->n_log_ios + buf_pool->stat.n_pages_read
2487
+ buf_pool->stat.n_pages_written;
2488
srv_main_thread_op_info = "sleeping";
2489
srv_main_1_second_loops++;
2493
os_thread_sleep(1000000);
2704
2499
/* ALTER TABLE in MySQL requires on Unix that the table handler
2705
2500
can drop tables lazily after there no longer are SELECT
2716
2511
goto background_loop;
2719
buf_get_total_stat(&buf_stat);
2721
n_ios_old = log_sys->n_log_ios + buf_stat.n_pages_read
2722
+ buf_stat.n_pages_written;
2724
srv_main_thread_op_info = "sleeping";
2725
srv_main_1_second_loops++;
2727
if (next_itr_time > cur_time
2728
&& srv_shutdown_state == SRV_SHUTDOWN_NONE) {
2730
/* Get sleep interval in micro seconds. We use
2731
ut_min() to avoid long sleep in case of
2733
os_thread_sleep(ut_min(1000000,
2734
(next_itr_time - cur_time)
2739
/* Each iteration should happen at 1 second interval. */
2740
next_itr_time = ut_time_ms() + 1000;
2742
2514
/* Flush logs if needed */
2743
2515
srv_sync_log_buffer_in_background();
2746
2518
log_free_check();
2748
2520
/* If i/os during one second sleep were less than 5% of
2749
capacity, we assume that there is free disk i/o capacity
2750
available, and it makes sense to do an insert buffer merge. */
2521
capacity, we assume that there is free disk i/o capacity
2522
available, and it makes sense to do an insert buffer merge. */
2752
buf_get_total_stat(&buf_stat);
2753
2524
n_pend_ios = buf_get_n_pending_ios()
2754
2525
+ log_sys->n_pending_writes;
2755
n_ios = log_sys->n_log_ios + buf_stat.n_pages_read
2756
+ buf_stat.n_pages_written;
2526
n_ios = log_sys->n_log_ios + buf_pool->stat.n_pages_read
2527
+ buf_pool->stat.n_pages_written;
2757
2528
if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2758
2529
&& (n_ios - n_ios_old < SRV_RECENT_IO_ACTIVITY)) {
2759
2530
srv_main_thread_op_info = "doing insert buffer merge";
2772
2543
srv_main_thread_op_info =
2773
2544
"flushing buffer pool pages";
2774
n_pages_flushed = buf_flush_list(
2775
PCT_IO(100), IB_ULONGLONG_MAX);
2545
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2549
/* If we had to do the flush, it may have taken
2550
even more than 1 second, and also, there may be more
2551
to flush. Do not sleep 1 second during the next
2552
iteration of this loop. */
2777
2555
} else if (srv_adaptive_flushing) {
2779
2557
/* Try to keep the rate of flushing of dirty
2818
2601
loop above requests writes for that case. The writes done here
2819
2602
are not required, and may be disabled. */
2821
buf_get_total_stat(&buf_stat);
2822
2604
n_pend_ios = buf_get_n_pending_ios() + log_sys->n_pending_writes;
2823
n_ios = log_sys->n_log_ios + buf_stat.n_pages_read
2824
+ buf_stat.n_pages_written;
2605
n_ios = log_sys->n_log_ios + buf_pool->stat.n_pages_read
2606
+ buf_pool->stat.n_pages_written;
2826
2608
srv_main_10_second_loops++;
2827
2609
if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2828
2610
&& (n_ios - n_ios_very_old < SRV_PAST_IO_ACTIVITY)) {
2830
2612
srv_main_thread_op_info = "flushing buffer pool pages";
2831
buf_flush_list(PCT_IO(100), IB_ULONGLONG_MAX);
2613
buf_flush_batch(BUF_FLUSH_LIST, PCT_IO(100),
2833
2616
/* Flush logs if needed */
2834
2617
srv_sync_log_buffer_in_background();
2843
2626
/* Flush logs if needed */
2844
2627
srv_sync_log_buffer_in_background();
2846
if (srv_n_purge_threads == 0) {
2847
srv_main_thread_op_info = "master purging";
2849
srv_master_do_purge();
2629
/* We run a full purge every 10 seconds, even if the server
2851
2633
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2853
2635
goto background_loop;
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);
2857
2646
srv_main_thread_op_info = "flushing buffer pool pages";
2864
2653
(> 70 %), we assume we can afford reserving the disk(s) for
2865
2654
the time it requires to flush 100 pages */
2867
n_pages_flushed = buf_flush_list(
2868
PCT_IO(100), IB_ULONGLONG_MAX);
2656
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2870
2660
/* Otherwise, we only flush a small number of pages so that
2871
2661
we do not unnecessarily use much disk i/o capacity from
2874
n_pages_flushed = buf_flush_list(
2875
PCT_IO(10), IB_ULONGLONG_MAX);
2664
n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
2878
2669
srv_main_thread_op_info = "making checkpoint";
2916
2707
MySQL tries to drop a table while there are still open handles
2917
2708
to it and we had to put it to the background drop queue.) */
2919
if (srv_shutdown_state == SRV_SHUTDOWN_NONE) {
2920
os_thread_sleep(100000);
2710
os_thread_sleep(100000);
2713
srv_main_thread_op_info = "purging";
2715
/* Run a full purge */
2717
if (srv_fast_shutdown && srv_shutdown_state > 0) {
2924
if (srv_n_purge_threads == 0) {
2925
srv_main_thread_op_info = "master purging";
2927
srv_master_do_purge();
2722
srv_main_thread_op_info = "purging";
2723
n_pages_purged = trx_purge();
2725
/* Flush logs if needed */
2726
srv_sync_log_buffer_in_background();
2728
} while (n_pages_purged);
2930
2730
srv_main_thread_op_info = "reserving kernel mutex";
3080
#if !defined(__SUNPRO_C)
2880
#if (!defined(__SUNPRO_C) && !defined(__SUNPRO_CC))
3081
2881
OS_THREAD_DUMMY_RETURN; /* Not reached, avoid compiler warning */
3085
/*********************************************************************//**
3086
Asynchronous purge thread.
3087
@return a dummy parameter */
3092
void* /*arg __attribute__((unused))*/) /*!< in: a dummy parameter
3093
required by os_thread_create */
3096
ulint slot_no = ULINT_UNDEFINED;
3097
ulint n_total_purged = ULINT_UNDEFINED;
3099
ut_a(srv_n_purge_threads == 1);
3101
#ifdef UNIV_DEBUG_THREAD_CREATION
3102
fprintf(stderr, "InnoDB: Purge thread running, id %lu\n",
3103
os_thread_pf(os_thread_get_curr_id()));
3104
#endif /* UNIV_DEBUG_THREAD_CREATION */
3106
mutex_enter(&kernel_mutex);
3108
slot_no = srv_table_reserve_slot(SRV_WORKER);
3110
slot = srv_table_get_nth_slot(slot_no);
3112
++srv_n_threads_active[SRV_WORKER];
3114
mutex_exit(&kernel_mutex);
3116
while (srv_shutdown_state != SRV_SHUTDOWN_EXIT_THREADS) {
3118
ulint n_pages_purged;
3120
/* If there are very few records to purge or the last
3121
purge didn't purge any records then wait for activity.
3122
We peek at the history len without holding any mutex
3123
because in the worst case we will end up waiting for
3124
the next purge event. */
3125
if (trx_sys->rseg_history_len < srv_purge_batch_size
3126
|| n_total_purged == 0) {
3130
mutex_enter(&kernel_mutex);
3132
event = srv_suspend_thread();
3134
mutex_exit(&kernel_mutex);
3136
os_event_wait(event);
3139
/* Check for shutdown and whether we should do purge at all. */
3140
if (srv_force_recovery >= SRV_FORCE_NO_BACKGROUND
3141
|| srv_shutdown_state != 0
3142
|| srv_fast_shutdown) {
3149
/* Purge until there are no more records to purge and there is
3150
no change in configuration or server state. */
3152
n_pages_purged = trx_purge(srv_purge_batch_size);
3154
n_total_purged += n_pages_purged;
3156
} while (n_pages_purged > 0 && !srv_fast_shutdown);
3158
srv_sync_log_buffer_in_background();
3161
mutex_enter(&kernel_mutex);
3163
ut_ad(srv_table_get_nth_slot(slot_no) == slot);
3165
/* Decrement the active count. */
3166
srv_suspend_thread();
3168
slot->in_use = FALSE;
3170
/* Free the thread local memory. */
3171
thr_local_free(os_thread_get_curr_id());
3173
mutex_exit(&kernel_mutex);
3175
#ifdef UNIV_DEBUG_THREAD_CREATION
3176
fprintf(stderr, "InnoDB: Purge thread exiting, id %lu\n",
3177
os_thread_pf(os_thread_get_curr_id()));
3178
#endif /* UNIV_DEBUG_THREAD_CREATION */
3180
/* We count the number of threads in os_thread_exit(). A created
3181
thread should always use that to exit and not use return() to exit. */
3182
os_thread_exit(NULL);
3184
OS_THREAD_DUMMY_RETURN; /* Not reached, avoid compiler warning */
3187
/**********************************************************************//**
3188
Enqueues a task to server task queue and releases a worker thread, if there
3189
is a suspended one. */
3192
srv_que_task_enqueue_low(
3193
/*=====================*/
3194
que_thr_t* thr) /*!< in: query thread */
3198
mutex_enter(&kernel_mutex);
3200
UT_LIST_ADD_LAST(queue, srv_sys->tasks, thr);
3202
srv_release_threads(SRV_WORKER, 1);
3204
mutex_exit(&kernel_mutex);
added
removed
plugin/innobase/srv/srv0srv.c
