← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/srv/srv0srv.c

  • Committer: Joseph Daly
  • Date: 2010-10-24 03:19:07 UTC
  • mto: (1856.2.16 transaction_id_innodb)
  • mto: This revision was merged to the branch mainline in revision 1900.
  • Revision ID: skinny.moey@gmail.com-20101024031907-cnkdjmjycx62jsv0
create schema changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/srv/srv0srv.c
1
1
/*****************************************************************************
2
2
 
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.
6
5
 
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.
12
11
 
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
18
 
COPYING.Percona.
19
 
 
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
31
23
 
32
24
*****************************************************************************/
 
25
/***********************************************************************
 
26
 
 
27
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
 
28
Copyright (c) 2009, Percona Inc.
 
29
 
 
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
 
35
COPYING.Percona.
 
36
 
 
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.
 
40
 
 
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.
 
45
 
 
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
 
49
 
 
50
***********************************************************************/
33
51
 
34
52
/**************************************************//**
35
53
@file srv/srv0srv.c
60
78
/* Dummy comment */
61
79
#include "srv0srv.h"
62
80
 
63
 
#include <drizzled/error.h>
64
 
#include <drizzled/errmsg_print.h>
65
 
 
66
81
#include "ut0mem.h"
67
82
#include "ut0ut.h"
68
83
#include "os0proc.h"
71
86
#include "sync0sync.h"
72
87
#include "thr0loc.h"
73
88
#include "que0que.h"
 
89
#include "srv0que.h"
74
90
#include "log0recv.h"
75
91
#include "pars0pars.h"
76
92
#include "usr0sess.h"
103
119
in microseconds, in order to reduce the lagging of the purge thread. */
104
120
UNIV_INTERN ulint       srv_dml_needed_delay = 0;
105
121
 
106
 
UNIV_INTERN ibool       srv_lock_timeout_active = FALSE;
107
 
UNIV_INTERN ibool       srv_monitor_active = FALSE;
 
122
UNIV_INTERN ibool       srv_lock_timeout_and_monitor_active = FALSE;
108
123
UNIV_INTERN ibool       srv_error_monitor_active = FALSE;
109
124
 
110
125
UNIV_INTERN const char* srv_main_thread_op_info = "";
111
126
 
 
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#";
 
129
 
112
130
/* Server parameters which are read from the initfile */
113
131
 
114
132
/* The following three are dir paths which are catenated before file
127
145
/** Whether to check file format during startup.  A value of
128
146
DICT_TF_FORMAT_MAX + 1 means no checking ie. FALSE.  The default is to
129
147
set it to the highest format we support. */
130
 
UNIV_INTERN ulint       srv_max_file_format_at_startup = DICT_TF_FORMAT_MAX;
 
148
UNIV_INTERN ulint       srv_check_file_format_at_startup = DICT_TF_FORMAT_MAX;
131
149
 
132
150
#if DICT_TF_FORMAT_51
133
151
# error "DICT_TF_FORMAT_51 must be 0!"
136
154
on duplicate key checking and foreign key checking */
137
155
UNIV_INTERN ibool       srv_locks_unsafe_for_binlog = FALSE;
138
156
 
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;
144
 
 
145
 
#ifdef __WIN__
146
 
/* Windows native condition variables. We use runtime loading / function
147
 
pointers, because they are not available on Windows Server 2003 and
148
 
Windows XP/2000.
149
 
 
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;
158
 
#endif /* __WIN__ */
159
 
 
160
157
UNIV_INTERN ulint       srv_n_data_files = 0;
161
158
UNIV_INTERN char**      srv_data_file_names = NULL;
162
159
/* size in database pages */
191
188
the checkpoints. */
192
189
UNIV_INTERN bool        srv_adaptive_flushing   = TRUE;
193
190
 
194
 
/** Maximum number of times allowed to conditionally acquire
195
 
mutex before switching to blocking wait on the mutex */
196
 
#define MAX_MUTEX_NOWAIT        20
197
 
 
198
 
/** Check whether the number of failed nonblocking mutex
199
 
acquisition attempts exceeds maximum allowed value. If so,
200
 
srv_printf_innodb_monitor() will request mutex acquisition
201
 
with mutex_enter(), which will wait until it gets the mutex. */
202
 
#define MUTEX_NOWAIT(mutex_skipped)     ((mutex_skipped) < MAX_MUTEX_NOWAIT)
203
 
 
204
 
/** 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
205
192
collation */
206
193
#if defined(BUILD_DRIZZLE)
207
 
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
208
195
                                        character set. The following table is
209
196
                                        the MySQL order as of Feb 10th, 2002 */
210
197
= {
250
237
UNIV_INTERN my_bool     srv_use_sys_malloc      = TRUE;
251
238
/* requested size in kilobytes */
252
239
UNIV_INTERN ulint       srv_buf_pool_size       = ULINT_MAX;
253
 
/* requested number of buffer pool instances */
254
 
UNIV_INTERN ulint       srv_buf_pool_instances  = 1;
255
240
/* previously requested size */
256
241
UNIV_INTERN ulint       srv_buf_pool_old_size;
257
242
/* current size in kilobytes */
303
288
 
304
289
UNIV_INTERN ulong       srv_max_buf_pool_modified_pct   = 75;
305
290
 
306
 
/* the number of purge threads to use from the worker pool (currently 0 or 1).*/
307
 
UNIV_INTERN ulong srv_n_purge_threads = 0;
308
 
 
309
 
/* the number of records to purge in one batch */
310
 
UNIV_INTERN ulong srv_purge_batch_size = 20;
311
 
 
312
291
/* variable counts amount of data read in total (in bytes) */
313
292
UNIV_INTERN ulint srv_data_read = 0;
314
293
 
463
442
UNIV_INTERN ib_int64_t  srv_n_lock_wait_time            = 0;
464
443
UNIV_INTERN ulint               srv_n_lock_max_wait_time        = 0;
465
444
 
466
 
UNIV_INTERN ulint               srv_truncated_status_writes     = 0;
467
445
 
468
446
/*
469
447
  Set the following to 0 if you want InnoDB to write messages on
487
465
 
488
466
/* Mutex for locking srv_monitor_file */
489
467
UNIV_INTERN mutex_t     srv_monitor_file_mutex;
490
 
 
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 */
505
 
 
506
468
/* Temporary file for innodb monitor output */
507
469
UNIV_INTERN FILE*       srv_monitor_file;
508
470
/* Mutex for locking srv_dict_tmpfile.
736
698
/* Table for MySQL threads where they will be suspended to wait for locks */
737
699
UNIV_INTERN srv_slot_t* srv_mysql_table = NULL;
738
700
 
739
 
UNIV_INTERN os_event_t  srv_timeout_event;
740
 
 
741
 
UNIV_INTERN os_event_t  srv_monitor_event;
742
 
 
743
 
UNIV_INTERN os_event_t  srv_error_event;
744
 
 
745
701
UNIV_INTERN os_event_t  srv_lock_timeout_thread_event;
746
702
 
747
703
UNIV_INTERN srv_sys_t*  srv_sys = NULL;
751
707
UNIV_INTERN byte        srv_pad1[64];
752
708
/* mutex protecting the server, trx structs, query threads, and lock table */
753
709
UNIV_INTERN mutex_t*    kernel_mutex_temp;
754
 
/* mutex protecting the sys header for writing the commit id */
755
 
UNIV_INTERN mutex_t*    commit_id_mutex_temp;
756
 
 
757
710
/* padding to prevent other memory update hotspots from residing on
758
711
the same memory cache line */
759
712
UNIV_INTERN byte        srv_pad2[64];
772
725
static ulint    srv_meter_foreground[SRV_MASTER + 1];
773
726
#endif
774
727
 
 
728
/* The following values give info about the activity going on in
 
729
the database. They are protected by the server mutex. The arrays
 
730
are indexed by the type of the thread. */
 
731
 
 
732
UNIV_INTERN ulint       srv_n_threads_active[SRV_MASTER + 1];
 
733
UNIV_INTERN ulint       srv_n_threads[SRV_MASTER + 1];
 
734
 
775
735
/***********************************************************************
776
736
Prints counters for work done by srv_master_thread. */
777
737
static
789
749
                      srv_log_writes_and_flush);
790
750
}
791
751
 
792
 
/* The following values give info about the activity going on in
793
 
the database. They are protected by the server mutex. The arrays
794
 
are indexed by the type of the thread. */
795
 
 
796
 
UNIV_INTERN ulint       srv_n_threads_active[SRV_MASTER + 1];
797
 
UNIV_INTERN ulint       srv_n_threads[SRV_MASTER + 1];
798
 
 
799
752
/*********************************************************************//**
800
753
Sets the info describing an i/o thread current state. */
801
754
UNIV_INTERN
915
868
 
916
869
        slot = srv_table_get_nth_slot(slot_no);
917
870
 
918
 
        type = static_cast<srv_thread_type>(slot->type);
 
871
        type = slot->type;
919
872
 
920
873
        ut_ad(type >= SRV_WORKER);
921
874
        ut_ad(type <= SRV_MASTER);
958
911
 
959
912
                slot = srv_table_get_nth_slot(i);
960
913
 
961
 
                if (slot->in_use &&
962
 
                    (static_cast<srv_thread_type>(slot->type) == type) &&
963
 
                    slot->suspended) {
 
914
                if (slot->in_use && slot->type == type && slot->suspended) {
964
915
 
965
916
                        slot->suspended = FALSE;
966
917
 
1005
956
 
1006
957
        slot = srv_table_get_nth_slot(slot_no);
1007
958
 
1008
 
        type = static_cast<srv_thread_type>(slot->type);
 
959
        type = slot->type;
1009
960
 
1010
961
        ut_ad(type >= SRV_WORKER);
1011
962
        ut_ad(type <= SRV_MASTER);
1026
977
        srv_slot_t*             slot;
1027
978
        ulint                   i;
1028
979
 
1029
 
        srv_sys = static_cast<srv_sys_t *>(mem_alloc(sizeof(srv_sys_t)));
1030
 
 
1031
 
        kernel_mutex_temp = static_cast<ib_mutex_t *>(mem_alloc(sizeof(mutex_t)));
1032
 
        mutex_create(kernel_mutex_key, &kernel_mutex, SYNC_KERNEL);
1033
 
 
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);
1036
 
 
1037
 
        mutex_create(srv_innodb_monitor_mutex_key,
1038
 
                     &srv_innodb_monitor_mutex, SYNC_NO_ORDER_CHECK);
1039
 
 
1040
 
        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));
 
981
 
 
982
        kernel_mutex_temp = mem_alloc(sizeof(mutex_t));
 
983
        mutex_create(&kernel_mutex, SYNC_KERNEL);
 
984
 
 
985
        mutex_create(&srv_innodb_monitor_mutex, SYNC_NO_ORDER_CHECK);
 
986
 
 
987
        srv_sys->threads = mem_alloc(OS_THREAD_MAX_N * sizeof(srv_slot_t));
1041
988
 
1042
989
        for (i = 0; i < OS_THREAD_MAX_N; i++) {
1043
990
                slot = srv_table_get_nth_slot(i);
1047
994
                ut_a(slot->event);
1048
995
        }
1049
996
 
1050
 
        srv_mysql_table = static_cast<srv_slot_t *>(mem_alloc(OS_THREAD_MAX_N * sizeof(srv_slot_t)));
 
997
        srv_mysql_table = mem_alloc(OS_THREAD_MAX_N * sizeof(srv_slot_t));
1051
998
 
1052
999
        for (i = 0; i < OS_THREAD_MAX_N; i++) {
1053
1000
                slot = srv_mysql_table + i;
1057
1004
                ut_a(slot->event);
1058
1005
        }
1059
1006
 
1060
 
        srv_error_event = os_event_create(NULL);
1061
 
 
1062
 
        srv_timeout_event = os_event_create(NULL);
1063
 
 
1064
 
        srv_monitor_event = os_event_create(NULL);
1065
 
 
1066
1007
        srv_lock_timeout_thread_event = os_event_create(NULL);
1067
1008
 
1068
1009
        for (i = 0; i < SRV_MASTER + 1; i++) {
1089
1030
 
1090
1031
        UT_LIST_INIT(srv_conc_queue);
1091
1032
 
1092
 
        srv_conc_slots = static_cast<srv_conc_slot_t *>(mem_alloc(OS_THREAD_MAX_N * sizeof(srv_conc_slot_t)));
 
1033
        srv_conc_slots = mem_alloc(OS_THREAD_MAX_N * sizeof(srv_conc_slot_t));
1093
1034
 
1094
1035
        for (i = 0; i < OS_THREAD_MAX_N; i++) {
1095
1036
                conc_slot = srv_conc_slots + i;
1122
1063
        mem_free(srv_mysql_table);
1123
1064
        srv_mysql_table = NULL;
1124
1065
 
1125
 
        mem_free(commit_id_mutex_temp);
1126
 
        commit_id_mutex_temp = NULL;
1127
 
 
1128
1066
        trx_i_s_cache_free(trx_i_s_cache);
1129
1067
}
1130
1068
 
1645
1583
                row_mysql_unfreeze_data_dictionary(trx);
1646
1584
                break;
1647
1585
        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
1653
 
                transactions. */
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
1586
                /* Release fast index creation latch */
1661
1587
                row_mysql_unlock_data_dictionary(trx);
1662
1588
                break;
1676
1602
                row_mysql_freeze_data_dictionary(trx);
1677
1603
                break;
1678
1604
        case RW_X_LATCH:
1679
 
                /* This should never occur. This incorrect handling
1680
 
                was added in the early development of
1681
 
                ha_innobase::add_index() in InnoDB Plugin 1.0. */
1682
1605
                row_mysql_lock_data_dictionary(trx);
1683
1606
                break;
1684
1607
        }
1715
1638
                    start_time != -1 && finish_time != -1) {
1716
1639
                        srv_n_lock_max_wait_time = diff_time;
1717
1640
                }
1718
 
 
1719
 
                /* Record the lock wait time for this thread */
1720
 
                thd_set_lock_wait_time(trx->mysql_thd, diff_time);
1721
1641
        }
1722
1642
 
1723
1643
        if (trx->was_chosen_as_deadlock_victim) {
1739
1659
 
1740
1660
                trx->error_state = DB_LOCK_WAIT_TIMEOUT;
1741
1661
        }
1742
 
 
1743
 
        if (trx_is_interrupted(trx)) {
1744
 
 
1745
 
                trx->error_state = DB_INTERRUPTED;
1746
 
        }
1747
1662
}
1748
1663
 
1749
1664
/********************************************************************//**
1795
1710
 
1796
1711
        log_refresh_stats();
1797
1712
 
1798
 
        buf_refresh_io_stats_all();
 
1713
        buf_refresh_io_stats();
1799
1714
 
1800
1715
        srv_n_rows_inserted_old = srv_n_rows_inserted;
1801
1716
        srv_n_rows_updated_old = srv_n_rows_updated;
1806
1721
}
1807
1722
 
1808
1723
/******************************************************************//**
1809
 
Outputs to a file the output of the InnoDB Monitor.
1810
 
@return FALSE if not all information printed
1811
 
due to failure to obtain necessary mutex */
 
1724
Outputs to a file the output of the InnoDB Monitor. */
1812
1725
UNIV_INTERN
1813
 
ibool
 
1726
void
1814
1727
srv_printf_innodb_monitor(
1815
1728
/*======================*/
1816
1729
        FILE*   file,           /*!< in: output stream */
1817
 
        ibool   nowait,         /*!< in: whether to wait for kernel mutex */
1818
1730
        ulint*  trx_start,      /*!< out: file position of the start of
1819
1731
                                the list of active transactions */
1820
1732
        ulint*  trx_end)        /*!< out: file position of the end of
1823
1735
        double  time_elapsed;
1824
1736
        time_t  current_time;
1825
1737
        ulint   n_reserved;
1826
 
        ibool   ret;
1827
1738
 
1828
1739
        mutex_enter(&srv_innodb_monitor_mutex);
1829
1740
 
1847
1758
                "Per second averages calculated from the last %lu seconds\n",
1848
1759
                (ulong)time_elapsed);
1849
1760
 
1850
 
        fputs("-----------------\n"
1851
 
              "BACKGROUND THREAD\n"
1852
 
              "-----------------\n", file);
 
1761
        fputs("----------\n"
 
1762
                "BACKGROUND THREAD\n"
 
1763
                "----------\n", file);
1853
1764
        srv_print_master_thread_info(file);
1854
1765
 
1855
1766
        fputs("----------\n"
1873
1784
 
1874
1785
        mutex_exit(&dict_foreign_err_mutex);
1875
1786
 
1876
 
        /* Only if lock_print_info_summary proceeds correctly,
1877
 
        before we call the lock_print_info_all_transactions
1878
 
        to print all the lock information. */
1879
 
        ret = lock_print_info_summary(file, nowait);
1880
 
 
1881
 
        if (ret) {
1882
 
                if (trx_start) {
1883
 
                        long    t = ftell(file);
1884
 
                        if (t < 0) {
1885
 
                                *trx_start = ULINT_UNDEFINED;
1886
 
                        } else {
1887
 
                                *trx_start = (ulint) t;
1888
 
                        }
1889
 
                }
1890
 
                lock_print_info_all_transactions(file);
1891
 
                if (trx_end) {
1892
 
                        long    t = ftell(file);
1893
 
                        if (t < 0) {
1894
 
                                *trx_end = ULINT_UNDEFINED;
1895
 
                        } else {
1896
 
                                *trx_end = (ulint) t;
1897
 
                        }
1898
 
                }
1899
 
        }
1900
 
 
 
1787
        lock_print_info_summary(file);
 
1788
        if (trx_start) {
 
1789
                long    t = ftell(file);
 
1790
                if (t < 0) {
 
1791
                        *trx_start = ULINT_UNDEFINED;
 
1792
                } else {
 
1793
                        *trx_start = (ulint) t;
 
1794
                }
 
1795
        }
 
1796
        lock_print_info_all_transactions(file);
 
1797
        if (trx_end) {
 
1798
                long    t = ftell(file);
 
1799
                if (t < 0) {
 
1800
                        *trx_end = ULINT_UNDEFINED;
 
1801
                } else {
 
1802
                        *trx_end = (ulint) t;
 
1803
                }
 
1804
        }
1901
1805
        fputs("--------\n"
1902
1806
              "FILE I/O\n"
1903
1807
              "--------\n", file);
1945
1849
                (ulong) srv_conc_n_waiting_threads);
1946
1850
 
1947
1851
        fprintf(file, "%lu read views open inside InnoDB\n",
1948
 
                static_cast<ulint>(UT_LIST_GET_LEN(trx_sys->view_list)));
 
1852
                UT_LIST_GET_LEN(trx_sys->view_list));
1949
1853
 
1950
1854
        n_reserved = fil_space_get_n_reserved_extents(0);
1951
1855
        if (n_reserved > 0) {
1995
1899
              "============================\n", file);
1996
1900
        mutex_exit(&srv_innodb_monitor_mutex);
1997
1901
        fflush(file);
1998
 
 
1999
 
        return(ret);
2000
1902
}
2001
1903
 
2002
1904
/******************************************************************//**
2006
1908
srv_export_innodb_status(void)
2007
1909
/*==========================*/
2008
1910
{
2009
 
        buf_pool_stat_t stat;
2010
 
        ulint           LRU_len;
2011
 
        ulint           free_len;
2012
 
        ulint           flush_list_len;
2013
 
 
2014
 
        buf_get_total_stat(&stat);
2015
 
        buf_get_total_list_len(&LRU_len, &free_len, &flush_list_len);
2016
 
 
2017
1911
        mutex_enter(&srv_innodb_monitor_mutex);
2018
1912
 
2019
1913
        export_vars.innodb_data_pending_reads
2028
1922
        export_vars.innodb_data_reads = os_n_file_reads;
2029
1923
        export_vars.innodb_data_writes = os_n_file_writes;
2030
1924
        export_vars.innodb_data_written = srv_data_written;
2031
 
        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;
2032
1926
        export_vars.innodb_buffer_pool_write_requests
2033
1927
                = srv_buf_pool_write_requests;
2034
1928
        export_vars.innodb_buffer_pool_wait_free = srv_buf_pool_wait_free;
2035
1929
        export_vars.innodb_buffer_pool_pages_flushed = srv_buf_pool_flushed;
2036
1930
        export_vars.innodb_buffer_pool_reads = srv_buf_pool_reads;
2037
1931
        export_vars.innodb_buffer_pool_read_ahead
2038
 
                = stat.n_ra_pages_read;
 
1932
                = buf_pool->stat.n_ra_pages_read;
2039
1933
        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;
 
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);
2044
1941
#ifdef UNIV_DEBUG
2045
1942
        export_vars.innodb_buffer_pool_pages_latched
2046
1943
                = buf_get_latched_pages_number();
2047
1944
#endif /* UNIV_DEBUG */
2048
 
        export_vars.innodb_buffer_pool_pages_total = buf_pool_get_n_pages();
 
1945
        export_vars.innodb_buffer_pool_pages_total = buf_pool->curr_size;
2049
1946
 
2050
 
        export_vars.innodb_buffer_pool_pages_misc
2051
 
                = 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);
2052
1950
#ifdef HAVE_ATOMIC_BUILTINS
2053
1951
        export_vars.innodb_have_atomic_builtins = 1;
2054
1952
#else
2064
1962
        export_vars.innodb_log_writes = srv_log_writes;
2065
1963
        export_vars.innodb_dblwr_pages_written = srv_dblwr_pages_written;
2066
1964
        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;
 
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;
2070
1968
        export_vars.innodb_row_lock_waits = srv_n_lock_wait_count;
2071
1969
        export_vars.innodb_row_lock_current_waits
2072
1970
                = srv_n_lock_wait_current_count;
2083
1981
        export_vars.innodb_rows_inserted = srv_n_rows_inserted;
2084
1982
        export_vars.innodb_rows_updated = srv_n_rows_updated;
2085
1983
        export_vars.innodb_rows_deleted = srv_n_rows_deleted;
2086
 
        export_vars.innodb_truncated_status_writes = srv_truncated_status_writes;
2087
1984
 
2088
1985
        mutex_exit(&srv_innodb_monitor_mutex);
2089
1986
}
2090
1987
 
2091
1988
/*********************************************************************//**
2092
 
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.
2093
1991
@return a dummy parameter */
2094
1992
UNIV_INTERN
2095
1993
os_thread_ret_t
2096
 
srv_monitor_thread(
2097
 
/*===============*/
2098
 
        void*   /*arg __attribute__((unused))*/)
 
1994
srv_lock_timeout_and_monitor_thread(
 
1995
/*================================*/
 
1996
        void*   arg __attribute__((unused)))
2099
1997
                        /*!< in: a dummy parameter required by
2100
1998
                        os_thread_create */
2101
1999
{
2102
 
        ib_int64_t      sig_count;
 
2000
        srv_slot_t*     slot;
2103
2001
        double          time_elapsed;
2104
2002
        time_t          current_time;
2105
2003
        time_t          last_table_monitor_time;
2106
2004
        time_t          last_tablespace_monitor_time;
2107
2005
        time_t          last_monitor_time;
2108
 
        ulint           mutex_skipped;
2109
 
        ibool           last_srv_print_monitor;
 
2006
        ibool           some_waits;
 
2007
        double          wait_time;
 
2008
        ulint           i;
2110
2009
 
2111
2010
#ifdef UNIV_DEBUG_THREAD_CREATION
2112
2011
        fprintf(stderr, "Lock timeout thread starts, id %lu\n",
2113
2012
                os_thread_pf(os_thread_get_curr_id()));
2114
2013
#endif
2115
 
 
2116
 
#ifdef UNIV_PFS_THREAD
2117
 
        pfs_register_thread(srv_monitor_thread_key);
2118
 
#endif
2119
 
 
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();
2124
 
        mutex_skipped = 0;
2125
 
        last_srv_print_monitor = srv_print_innodb_monitor;
 
2014
        UT_NOT_USED(arg);
 
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);
2126
2019
loop:
2127
 
        srv_monitor_active = TRUE;
2128
 
 
2129
 
        /* Wake up every 5 seconds to see if we need to print
2130
 
        monitor information or if signalled at shutdown. */
2131
 
 
2132
 
        sig_count = os_event_reset(srv_monitor_event);
2133
 
 
2134
 
        os_event_wait_time_low(srv_monitor_event, 5000000, sig_count);
2135
 
 
2136
 
        current_time = ut_time();
 
2020
        srv_lock_timeout_and_monitor_active = TRUE;
 
2021
 
 
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 */
 
2024
 
 
2025
        os_thread_sleep(1000000);
 
2026
 
 
2027
        current_time = time(NULL);
2137
2028
 
2138
2029
        time_elapsed = difftime(current_time, last_monitor_time);
2139
2030
 
2140
2031
        if (time_elapsed > 15) {
2141
 
                last_monitor_time = ut_time();
 
2032
                last_monitor_time = time(NULL);
2142
2033
 
2143
2034
                if (srv_print_innodb_monitor) {
2144
 
                        /* Reset mutex_skipped counter everytime
2145
 
                        srv_print_innodb_monitor changes. This is to
2146
 
                        ensure we will not be blocked by kernel_mutex
2147
 
                        for short duration information printing,
2148
 
                        such as requested by sync_array_print_long_waits() */
2149
 
                        if (!last_srv_print_monitor) {
2150
 
                                mutex_skipped = 0;
2151
 
                                last_srv_print_monitor = TRUE;
2152
 
                        }
2153
 
 
2154
 
                        if (!srv_printf_innodb_monitor(stderr,
2155
 
                                                MUTEX_NOWAIT(mutex_skipped),
2156
 
                                                NULL, NULL)) {
2157
 
                                mutex_skipped++;
2158
 
                        } else {
2159
 
                                /* Reset the counter */
2160
 
                                mutex_skipped = 0;
2161
 
                        }
2162
 
                } else {
2163
 
                        last_srv_print_monitor = FALSE;
 
2035
                        srv_printf_innodb_monitor(stderr, NULL, NULL);
2164
2036
                }
2165
2037
 
2166
 
 
2167
2038
                if (srv_innodb_status) {
2168
2039
                        mutex_enter(&srv_monitor_file_mutex);
2169
2040
                        rewind(srv_monitor_file);
2170
 
                        if (!srv_printf_innodb_monitor(srv_monitor_file,
2171
 
                                                MUTEX_NOWAIT(mutex_skipped),
2172
 
                                                NULL, NULL)) {
2173
 
                                mutex_skipped++;
2174
 
                        } else {
2175
 
                                mutex_skipped = 0;
2176
 
                        }
2177
 
 
 
2041
                        srv_printf_innodb_monitor(srv_monitor_file, NULL,
 
2042
                                                  NULL);
2178
2043
                        os_file_set_eof(srv_monitor_file);
2179
2044
                        mutex_exit(&srv_monitor_file_mutex);
2180
2045
                }
2182
2047
                if (srv_print_innodb_tablespace_monitor
2183
2048
                    && difftime(current_time,
2184
2049
                                last_tablespace_monitor_time) > 60) {
2185
 
                        last_tablespace_monitor_time = ut_time();
 
2050
                        last_tablespace_monitor_time = time(NULL);
2186
2051
 
2187
2052
                        fputs("========================"
2188
2053
                              "========================\n",
2208
2073
                if (srv_print_innodb_table_monitor
2209
2074
                    && difftime(current_time, last_table_monitor_time) > 60) {
2210
2075
 
2211
 
                        last_table_monitor_time = ut_time();
 
2076
                        last_table_monitor_time = time(NULL);
2212
2077
 
2213
2078
                        fputs("===========================================\n",
2214
2079
                              stderr);
2227
2092
                }
2228
2093
        }
2229
2094
 
2230
 
        if (srv_shutdown_state >= SRV_SHUTDOWN_CLEANUP) {
2231
 
                goto exit_func;
2232
 
        }
2233
 
 
2234
 
        if (srv_print_innodb_monitor
2235
 
            || srv_print_innodb_lock_monitor
2236
 
            || srv_print_innodb_tablespace_monitor
2237
 
            || srv_print_innodb_table_monitor) {
2238
 
                goto loop;
2239
 
        }
2240
 
 
2241
 
        srv_monitor_active = FALSE;
2242
 
 
2243
 
        goto loop;
2244
 
 
2245
 
exit_func:
2246
 
        srv_monitor_active = FALSE;
2247
 
 
2248
 
        /* We count the number of threads in os_thread_exit(). A created
2249
 
        thread should always use that to exit and not use return() to exit. */
2250
 
 
2251
 
        os_thread_exit(NULL);
2252
 
 
2253
 
        OS_THREAD_DUMMY_RETURN;
2254
 
}
2255
 
 
2256
 
/*********************************************************************//**
2257
 
A thread which wakes up threads whose lock wait may have lasted too long.
2258
 
@return a dummy parameter */
2259
 
UNIV_INTERN
2260
 
os_thread_ret_t
2261
 
srv_lock_timeout_thread(
2262
 
/*====================*/
2263
 
        void*   /*arg __attribute__((unused))*/)
2264
 
                        /* in: a dummy parameter required by
2265
 
                        os_thread_create */
2266
 
{
2267
 
        srv_slot_t*     slot;
2268
 
        ibool           some_waits;
2269
 
        double          wait_time;
2270
 
        ulint           i;
2271
 
        ib_int64_t      sig_count;
2272
 
 
2273
 
#ifdef UNIV_PFS_THREAD
2274
 
        pfs_register_thread(srv_lock_timeout_thread_key);
2275
 
#endif
2276
 
 
2277
 
loop:
2278
 
 
2279
 
        /* When someone is waiting for a lock, we wake up every second
2280
 
        and check if a timeout has passed for a lock wait */
2281
 
 
2282
 
        sig_count = os_event_reset(srv_timeout_event);
2283
 
 
2284
 
        os_event_wait_time_low(srv_timeout_event, 1000000, sig_count);
2285
 
 
2286
 
        srv_lock_timeout_active = TRUE;
2287
 
 
2288
2095
        mutex_enter(&kernel_mutex);
2289
2096
 
2290
2097
        some_waits = FALSE;
2308
2115
                        lock_wait_timeout = thd_lock_wait_timeout(
2309
2116
                                trx->mysql_thd);
2310
2117
 
2311
 
                        if (trx_is_interrupted(trx)
2312
 
                            || (lock_wait_timeout < 100000000
2313
 
                                && (wait_time > (double) lock_wait_timeout
2314
 
                                    || wait_time < 0))) {
 
2118
                        if (lock_wait_timeout < 100000000
 
2119
                            && (wait_time > (double) lock_wait_timeout
 
2120
                                || wait_time < 0)) {
2315
2121
 
2316
2122
                                /* Timeout exceeded or a wrap-around in system
2317
2123
                                time counter: cancel the lock request queued
2336
2142
                goto exit_func;
2337
2143
        }
2338
2144
 
2339
 
        if (some_waits) {
 
2145
        if (some_waits || srv_print_innodb_monitor
 
2146
            || srv_print_innodb_lock_monitor
 
2147
            || srv_print_innodb_tablespace_monitor
 
2148
            || srv_print_innodb_table_monitor) {
2340
2149
                goto loop;
2341
2150
        }
2342
2151
 
2343
 
        srv_lock_timeout_active = FALSE;
 
2152
        /* No one was waiting for a lock and no monitor was active:
 
2153
        suspend this thread */
 
2154
 
 
2155
        srv_lock_timeout_and_monitor_active = FALSE;
2344
2156
 
2345
2157
#if 0
2346
2158
        /* The following synchronisation is disabled, since
2350
2162
        goto loop;
2351
2163
 
2352
2164
exit_func:
2353
 
        srv_lock_timeout_active = FALSE;
 
2165
        srv_lock_timeout_and_monitor_active = FALSE;
2354
2166
 
2355
2167
        /* We count the number of threads in os_thread_exit(). A created
2356
2168
        thread should always use that to exit and not use return() to exit. */
2368
2180
os_thread_ret_t
2369
2181
srv_error_monitor_thread(
2370
2182
/*=====================*/
2371
 
        void*   /*arg __attribute__((unused))*/)
 
2183
        void*   arg __attribute__((unused)))
2372
2184
                        /*!< in: a dummy parameter required by
2373
2185
                        os_thread_create */
2374
2186
{
2376
2188
        ulint           fatal_cnt       = 0;
2377
2189
        ib_uint64_t     old_lsn;
2378
2190
        ib_uint64_t     new_lsn;
2379
 
        ib_int64_t      sig_count;
2380
2191
 
2381
2192
        old_lsn = srv_start_lsn;
2382
2193
 
2384
2195
        fprintf(stderr, "Error monitor thread starts, id %lu\n",
2385
2196
                os_thread_pf(os_thread_get_curr_id()));
2386
2197
#endif
2387
 
 
2388
 
#ifdef UNIV_PFS_THREAD
2389
 
        pfs_register_thread(srv_error_monitor_thread_key);
2390
 
#endif
2391
 
 
2392
2198
loop:
2393
2199
        srv_error_monitor_active = TRUE;
2394
2200
 
2398
2204
        new_lsn = log_get_lsn();
2399
2205
 
2400
2206
        if (new_lsn < old_lsn) {
2401
 
          drizzled::errmsg_printf(drizzled::error::INFO,
2402
 
                                  "InnoDB: Error: old log sequence number %"PRIu64" was greater than the new log sequence number %"PRIu64"!"
2403
 
                                  "InnoDB: Please submit a bug report to http://bugs.launchpad.net/drizzle",
2404
 
                                  old_lsn, new_lsn);
 
2207
                ut_print_timestamp(stderr);
 
2208
                fprintf(stderr,
 
2209
                        "  InnoDB: Error: old log sequence number %"PRIu64""
 
2210
                        " was greater\n"
 
2211
                        "InnoDB: than the new log sequence number %"PRIu64"!\n"
 
2212
                        "InnoDB: Please submit a bug report"
 
2213
                        " to http://bugs.mysql.com\n",
 
2214
                        old_lsn, new_lsn);
2405
2215
        }
2406
2216
 
2407
2217
        old_lsn = new_lsn;
2448
2258
 
2449
2259
        fflush(stderr);
2450
2260
 
2451
 
        sig_count = os_event_reset(srv_error_event);
2452
 
 
2453
 
        os_event_wait_time_low(srv_error_event, 1000000, sig_count);
 
2261
        os_thread_sleep(1000000);
2454
2262
 
2455
2263
        if (srv_shutdown_state < SRV_SHUTDOWN_CLEANUP) {
2456
2264
 
2467
2275
        OS_THREAD_DUMMY_RETURN;
2468
2276
}
2469
2277
 
2470
 
/**********************************************************************//**
2471
 
Check whether any background thread is active.
2472
 
@return FALSE if all are are suspended or have exited. */
2473
 
UNIV_INTERN
2474
 
ibool
2475
 
srv_is_any_background_thread_active(void)
2476
 
/*=====================================*/
2477
 
{
2478
 
        ulint   i;
2479
 
        ibool   ret = FALSE;
2480
 
 
2481
 
        mutex_enter(&kernel_mutex);
2482
 
 
2483
 
        for (i = SRV_COM; i <= SRV_MASTER; ++i) {
2484
 
                if (srv_n_threads_active[i] != 0) {
2485
 
                        ret = TRUE;
2486
 
                        break;
2487
 
                }
2488
 
        }
2489
 
 
2490
 
        mutex_exit(&kernel_mutex);
2491
 
 
2492
 
        return(ret);
2493
 
}
2494
 
 
2495
2278
/*******************************************************************//**
2496
2279
Tells the InnoDB server that there has been activity in the database
2497
2280
and wakes up the master thread if it is suspended (not sleeping). Used
2498
2281
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). */
 
2282
thread stays suspended (we do not protect our operation with the kernel
 
2283
mutex, for performace reasons). */
2501
2284
UNIV_INTERN
2502
2285
void
2503
2286
srv_active_wake_master_thread(void)
2516
2299
}
2517
2300
 
2518
2301
/*******************************************************************//**
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). */
2524
 
UNIV_INTERN
2525
 
void
2526
 
srv_wake_purge_thread_if_not_active(void)
2527
 
/*=====================================*/
2528
 
{
2529
 
        ut_ad(!mutex_own(&kernel_mutex));
2530
 
 
2531
 
        if (srv_n_purge_threads > 0
2532
 
            && srv_n_threads_active[SRV_WORKER] == 0) {
2533
 
 
2534
 
                mutex_enter(&kernel_mutex);
2535
 
 
2536
 
                srv_release_threads(SRV_WORKER, 1);
2537
 
 
2538
 
                mutex_exit(&kernel_mutex);
2539
 
        }
2540
 
}
2541
 
 
2542
 
/*******************************************************************//**
2543
2302
Wakes up the master thread if it is suspended or being suspended. */
2544
2303
UNIV_INTERN
2545
2304
void
2555
2314
        mutex_exit(&kernel_mutex);
2556
2315
}
2557
2316
 
2558
 
/*******************************************************************//**
2559
 
Wakes up the purge thread if it's not already awake. */
2560
 
UNIV_INTERN
2561
 
void
2562
 
srv_wake_purge_thread(void)
2563
 
/*=======================*/
2564
 
{
2565
 
        ut_ad(!mutex_own(&kernel_mutex));
2566
 
 
2567
 
        if (srv_n_purge_threads > 0) {
2568
 
 
2569
 
                mutex_enter(&kernel_mutex);
2570
 
 
2571
 
                srv_release_threads(SRV_WORKER, 1);
2572
 
 
2573
 
                mutex_exit(&kernel_mutex);
2574
 
        }
2575
 
}
2576
 
 
2577
2317
/**********************************************************************
2578
2318
The master thread is tasked to ensure that flush of log file happens
2579
2319
once every second in the background. This is to ensure that not more
2594
2334
        }
2595
2335
}
2596
2336
 
2597
 
/********************************************************************//**
2598
 
Do a full purge, reconfigure the purge sub-system if a dynamic
2599
 
change is detected. */
2600
 
static
2601
 
void
2602
 
srv_master_do_purge(void)
2603
 
/*=====================*/
2604
 
{
2605
 
        ulint   n_pages_purged;
2606
 
 
2607
 
        ut_ad(!mutex_own(&kernel_mutex));
2608
 
 
2609
 
        ut_a(srv_n_purge_threads == 0);
2610
 
 
2611
 
        do {
2612
 
                /* Check for shutdown and change in purge config. */
2613
 
                if (srv_fast_shutdown && srv_shutdown_state > 0) {
2614
 
                        /* Nothing to purge. */
2615
 
                        n_pages_purged = 0;
2616
 
                } else {
2617
 
                        n_pages_purged = trx_purge(srv_purge_batch_size);
2618
 
                }
2619
 
 
2620
 
                srv_sync_log_buffer_in_background();
2621
 
 
2622
 
        } while (n_pages_purged > 0);
2623
 
}
2624
 
 
2625
2337
/*********************************************************************//**
2626
2338
The master thread controlling the server.
2627
2339
@return a dummy parameter */
2629
2341
os_thread_ret_t
2630
2342
srv_master_thread(
2631
2343
/*==============*/
2632
 
        void*   /*arg __attribute__((unused))*/)
 
2344
        void*   arg __attribute__((unused)))
2633
2345
                        /*!< in: a dummy parameter required by
2634
2346
                        os_thread_create */
2635
2347
{
2636
 
        buf_pool_stat_t buf_stat;
2637
2348
        os_event_t      event;
2638
2349
        ulint           old_activity_count;
2639
2350
        ulint           n_pages_purged  = 0;
2645
2356
        ulint           n_ios_old;
2646
2357
        ulint           n_ios_very_old;
2647
2358
        ulint           n_pend_ios;
2648
 
        ulint           next_itr_time;
 
2359
        ibool           skip_sleep      = FALSE;
2649
2360
        ulint           i;
2650
2361
 
2651
2362
#ifdef UNIV_DEBUG_THREAD_CREATION
2652
2363
        fprintf(stderr, "Master thread starts, id %lu\n",
2653
2364
                os_thread_pf(os_thread_get_curr_id()));
2654
2365
#endif
2655
 
 
2656
 
#ifdef UNIV_PFS_THREAD
2657
 
        pfs_register_thread(srv_master_thread_key);
2658
 
#endif
2659
 
 
2660
2366
        srv_main_thread_process_no = os_proc_get_number();
2661
2367
        srv_main_thread_id = os_thread_pf(os_thread_get_curr_id());
2662
2368
 
2675
2381
 
2676
2382
        srv_main_thread_op_info = "reserving kernel mutex";
2677
2383
 
2678
 
        buf_get_total_stat(&buf_stat);
2679
 
        n_ios_very_old = log_sys->n_log_ios + buf_stat.n_pages_read
2680
 
                + buf_stat.n_pages_written;
 
2384
        n_ios_very_old = log_sys->n_log_ios + buf_pool->stat.n_pages_read
 
2385
                + buf_pool->stat.n_pages_written;
2681
2386
        mutex_enter(&kernel_mutex);
2682
2387
 
2683
2388
        /* Store the user activity counter at the start of this loop */
2694
2399
        when there is database activity */
2695
2400
 
2696
2401
        srv_last_log_flush_time = time(NULL);
2697
 
 
2698
 
        /* Sleep for 1 second on entrying the for loop below the first time. */
2699
 
        next_itr_time = ut_time_ms() + 1000;
 
2402
        skip_sleep = FALSE;
2700
2403
 
2701
2404
        for (i = 0; i < 10; i++) {
2702
 
                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++;
 
2409
 
 
2410
                if (!skip_sleep) {
 
2411
 
 
2412
                        os_thread_sleep(1000000);
 
2413
                        srv_main_sleeps++;
 
2414
                }
 
2415
 
 
2416
                skip_sleep = FALSE;
2703
2417
 
2704
2418
                /* ALTER TABLE in MySQL requires on Unix that the table handler
2705
2419
                can drop tables lazily after there no longer are SELECT
2716
2430
                        goto background_loop;
2717
2431
                }
2718
2432
 
2719
 
                buf_get_total_stat(&buf_stat);
2720
 
 
2721
 
                n_ios_old = log_sys->n_log_ios + buf_stat.n_pages_read
2722
 
                        + buf_stat.n_pages_written;
2723
 
 
2724
 
                srv_main_thread_op_info = "sleeping";
2725
 
                srv_main_1_second_loops++;
2726
 
 
2727
 
                if (next_itr_time > cur_time
2728
 
                    && srv_shutdown_state == SRV_SHUTDOWN_NONE) {
2729
 
 
2730
 
                        /* Get sleep interval in micro seconds. We use
2731
 
                        ut_min() to avoid long sleep in case of
2732
 
                        wrap around. */
2733
 
                        os_thread_sleep(ut_min(1000000,
2734
 
                                        (next_itr_time - cur_time)
2735
 
                                         * 1000));
2736
 
                        srv_main_sleeps++;
2737
 
                }
2738
 
 
2739
 
                /* Each iteration should happen at 1 second interval. */
2740
 
                next_itr_time = ut_time_ms() + 1000;
2741
 
 
2742
2433
                /* Flush logs if needed */
2743
2434
                srv_sync_log_buffer_in_background();
2744
2435
 
2746
2437
                log_free_check();
2747
2438
 
2748
2439
                /* 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. */
 
2440
                capacity, we assume that there is free disk i/o capacity
 
2441
                available, and it makes sense to do an insert buffer merge. */
2751
2442
 
2752
 
                buf_get_total_stat(&buf_stat);
2753
2443
                n_pend_ios = buf_get_n_pending_ios()
2754
2444
                        + log_sys->n_pending_writes;
2755
 
                n_ios = log_sys->n_log_ios + buf_stat.n_pages_read
2756
 
                        + 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;
2757
2447
                if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2758
2448
                    && (n_ios - n_ios_old < SRV_RECENT_IO_ACTIVITY)) {
2759
2449
                        srv_main_thread_op_info = "doing insert buffer merge";
2771
2461
 
2772
2462
                        srv_main_thread_op_info =
2773
2463
                                "flushing buffer pool pages";
2774
 
                        n_pages_flushed = buf_flush_list(
2775
 
                                PCT_IO(100), IB_ULONGLONG_MAX);
2776
 
 
 
2464
                        n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
 
2465
                                                          PCT_IO(100),
 
2466
                                                          IB_ULONGLONG_MAX);
 
2467
 
 
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. */
 
2472
 
 
2473
                        skip_sleep = TRUE;
2777
2474
                } else if (srv_adaptive_flushing) {
2778
2475
 
2779
2476
                        /* Try to keep the rate of flushing of dirty
2786
2483
                                        "flushing buffer pool pages";
2787
2484
                                n_flush = ut_min(PCT_IO(100), n_flush);
2788
2485
                                n_pages_flushed =
2789
 
                                        buf_flush_list(
 
2486
                                        buf_flush_batch(
 
2487
                                                BUF_FLUSH_LIST,
2790
2488
                                                n_flush,
2791
2489
                                                IB_ULONGLONG_MAX);
 
2490
                                skip_sleep = TRUE;
2792
2491
                        }
2793
2492
                }
2794
2493
 
2818
2517
        loop above requests writes for that case. The writes done here
2819
2518
        are not required, and may be disabled. */
2820
2519
 
2821
 
        buf_get_total_stat(&buf_stat);
2822
2520
        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;
 
2521
        n_ios = log_sys->n_log_ios + buf_pool->stat.n_pages_read
 
2522
                + buf_pool->stat.n_pages_written;
2825
2523
 
2826
2524
        srv_main_10_second_loops++;
2827
2525
        if (n_pend_ios < SRV_PEND_IO_THRESHOLD
2828
2526
            && (n_ios - n_ios_very_old < SRV_PAST_IO_ACTIVITY)) {
2829
2527
 
2830
2528
                srv_main_thread_op_info = "flushing buffer pool pages";
2831
 
                buf_flush_list(PCT_IO(100), IB_ULONGLONG_MAX);
 
2529
                buf_flush_batch(BUF_FLUSH_LIST, PCT_IO(100),
 
2530
                                IB_ULONGLONG_MAX);
2832
2531
 
2833
2532
                /* Flush logs if needed */
2834
2533
                srv_sync_log_buffer_in_background();
2843
2542
        /* Flush logs if needed */
2844
2543
        srv_sync_log_buffer_in_background();
2845
2544
 
2846
 
        if (srv_n_purge_threads == 0) {
2847
 
                srv_main_thread_op_info = "master purging";
2848
 
 
2849
 
                srv_master_do_purge();
 
2545
        /* We run a full purge every 10 seconds, even if the server
 
2546
        were active */
 
2547
        do {
2850
2548
 
2851
2549
                if (srv_fast_shutdown && srv_shutdown_state > 0) {
2852
2550
 
2853
2551
                        goto background_loop;
2854
2552
                }
2855
 
        }
 
2553
 
 
2554
                srv_main_thread_op_info = "purging";
 
2555
                n_pages_purged = trx_purge();
 
2556
 
 
2557
                /* Flush logs if needed */
 
2558
                srv_sync_log_buffer_in_background();
 
2559
 
 
2560
        } while (n_pages_purged);
2856
2561
 
2857
2562
        srv_main_thread_op_info = "flushing buffer pool pages";
2858
2563
 
2864
2569
                (> 70 %), we assume we can afford reserving the disk(s) for
2865
2570
                the time it requires to flush 100 pages */
2866
2571
 
2867
 
                n_pages_flushed = buf_flush_list(
2868
 
                        PCT_IO(100), IB_ULONGLONG_MAX);
 
2572
                n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
 
2573
                                                  PCT_IO(100),
 
2574
                                                  IB_ULONGLONG_MAX);
2869
2575
        } else {
2870
2576
                /* Otherwise, we only flush a small number of pages so that
2871
2577
                we do not unnecessarily use much disk i/o capacity from
2872
2578
                other work */
2873
2579
 
2874
 
                n_pages_flushed = buf_flush_list(
2875
 
                          PCT_IO(10), IB_ULONGLONG_MAX);
 
2580
                n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
 
2581
                                                  PCT_IO(10),
 
2582
                                                  IB_ULONGLONG_MAX);
2876
2583
        }
2877
2584
 
2878
2585
        srv_main_thread_op_info = "making checkpoint";
2916
2623
                MySQL tries to drop a table while there are still open handles
2917
2624
                to it and we had to put it to the background drop queue.) */
2918
2625
 
2919
 
                if (srv_shutdown_state == SRV_SHUTDOWN_NONE) {
2920
 
                        os_thread_sleep(100000);
 
2626
                os_thread_sleep(100000);
 
2627
        }
 
2628
 
 
2629
        srv_main_thread_op_info = "purging";
 
2630
 
 
2631
        /* Run a full purge */
 
2632
        do {
 
2633
                if (srv_fast_shutdown && srv_shutdown_state > 0) {
 
2634
 
 
2635
                        break;
2921
2636
                }
2922
 
        }
2923
 
 
2924
 
        if (srv_n_purge_threads == 0) {
2925
 
                srv_main_thread_op_info = "master purging";
2926
 
 
2927
 
                srv_master_do_purge();
2928
 
        }
 
2637
 
 
2638
                srv_main_thread_op_info = "purging";
 
2639
                n_pages_purged = trx_purge();
 
2640
 
 
2641
                /* Flush logs if needed */
 
2642
                srv_sync_log_buffer_in_background();
 
2643
 
 
2644
        } while (n_pages_purged);
2929
2645
 
2930
2646
        srv_main_thread_op_info = "reserving kernel mutex";
2931
2647
 
2943
2659
        } else {
2944
2660
                /* This should do an amount of IO similar to the number of
2945
2661
                dirty pages that will be flushed in the call to
2946
 
                buf_flush_list below. Otherwise, the system favors
 
2662
                buf_flush_batch below. Otherwise, the system favors
2947
2663
                clean pages over cleanup throughput. */
2948
2664
                n_bytes_merged = ibuf_contract_for_n_pages(FALSE,
2949
2665
                                                           PCT_IO(100));
2962
2678
        srv_main_thread_op_info = "flushing buffer pool pages";
2963
2679
        srv_main_flush_loops++;
2964
2680
        if (srv_fast_shutdown < 2) {
2965
 
                n_pages_flushed = buf_flush_list(
2966
 
                          PCT_IO(100), IB_ULONGLONG_MAX);
 
2681
                n_pages_flushed = buf_flush_batch(BUF_FLUSH_LIST,
 
2682
                                                  PCT_IO(100),
 
2683
                                                  IB_ULONGLONG_MAX);
2967
2684
        } else {
2968
2685
                /* In the fastest shutdown we do not flush the buffer pool
2969
2686
                to data files: we set n_pages_flushed to 0 artificially. */
2981
2698
        mutex_exit(&kernel_mutex);
2982
2699
 
2983
2700
        srv_main_thread_op_info = "waiting for buffer pool flush to end";
2984
 
        buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
 
2701
        buf_flush_wait_batch_end(BUF_FLUSH_LIST);
2985
2702
 
2986
2703
        /* Flush logs if needed */
2987
2704
        srv_sync_log_buffer_in_background();
3068
2785
                already when the event wait ends */
3069
2786
 
3070
2787
                os_thread_exit(NULL);
3071
 
 
3072
2788
        }
3073
2789
 
3074
2790
        /* When there is user activity, InnoDB will set the event and the
3077
2793
        goto loop;
3078
2794
 
3079
2795
 
3080
 
#if !defined(__SUNPRO_C)
 
2796
#if (!defined(__SUNPRO_C) && !defined(__SUNPRO_CC))
3081
2797
        OS_THREAD_DUMMY_RETURN; /* Not reached, avoid compiler warning */
3082
2798
#endif
3083
2799
}
3084
 
 
3085
 
/*********************************************************************//**
3086
 
Asynchronous purge thread.
3087
 
@return a dummy parameter */
3088
 
UNIV_INTERN
3089
 
os_thread_ret_t
3090
 
srv_purge_thread(
3091
 
/*=============*/
3092
 
        void*   /*arg __attribute__((unused))*/)        /*!< in: a dummy parameter
3093
 
                                                required by os_thread_create */
3094
 
{
3095
 
        srv_slot_t*     slot;
3096
 
        ulint           slot_no = ULINT_UNDEFINED;
3097
 
        ulint           n_total_purged = ULINT_UNDEFINED;
3098
 
 
3099
 
        ut_a(srv_n_purge_threads == 1);
3100
 
 
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 */
3105
 
 
3106
 
        mutex_enter(&kernel_mutex);
3107
 
 
3108
 
        slot_no = srv_table_reserve_slot(SRV_WORKER);
3109
 
 
3110
 
        slot = srv_table_get_nth_slot(slot_no);
3111
 
 
3112
 
        ++srv_n_threads_active[SRV_WORKER];
3113
 
 
3114
 
        mutex_exit(&kernel_mutex);
3115
 
 
3116
 
        while (srv_shutdown_state != SRV_SHUTDOWN_EXIT_THREADS) {
3117
 
 
3118
 
                ulint   n_pages_purged;
3119
 
 
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) {
3127
 
 
3128
 
                        os_event_t      event;
3129
 
 
3130
 
                        mutex_enter(&kernel_mutex);
3131
 
 
3132
 
                        event = srv_suspend_thread();
3133
 
 
3134
 
                        mutex_exit(&kernel_mutex);
3135
 
 
3136
 
                        os_event_wait(event);
3137
 
                }
3138
 
 
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) {
3143
 
 
3144
 
                        break;
3145
 
                }
3146
 
 
3147
 
                n_total_purged = 0;
3148
 
 
3149
 
                /* Purge until there are no more records to purge and there is
3150
 
                no change in configuration or server state. */
3151
 
                do {
3152
 
                        n_pages_purged = trx_purge(srv_purge_batch_size);
3153
 
 
3154
 
                        n_total_purged += n_pages_purged;
3155
 
 
3156
 
                } while (n_pages_purged > 0 && !srv_fast_shutdown);
3157
 
 
3158
 
                srv_sync_log_buffer_in_background();
3159
 
        }
3160
 
 
3161
 
        mutex_enter(&kernel_mutex);
3162
 
 
3163
 
        ut_ad(srv_table_get_nth_slot(slot_no) == slot);
3164
 
 
3165
 
        /* Decrement the active count. */
3166
 
        srv_suspend_thread();
3167
 
 
3168
 
        slot->in_use = FALSE;
3169
 
 
3170
 
        /* Free the thread local memory. */
3171
 
        thr_local_free(os_thread_get_curr_id());
3172
 
 
3173
 
        mutex_exit(&kernel_mutex);
3174
 
 
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 */
3179
 
 
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);
3183
 
 
3184
 
        OS_THREAD_DUMMY_RETURN; /* Not reached, avoid compiler warning */
3185
 
}
3186
 
 
3187
 
/**********************************************************************//**
3188
 
Enqueues a task to server task queue and releases a worker thread, if there
3189
 
is a suspended one. */
3190
 
UNIV_INTERN
3191
 
void
3192
 
srv_que_task_enqueue_low(
3193
 
/*=====================*/
3194
 
        que_thr_t*      thr)    /*!< in: query thread */
3195
 
{
3196
 
        ut_ad(thr);
3197
 
 
3198
 
        mutex_enter(&kernel_mutex);
3199
 
 
3200
 
        UT_LIST_ADD_LAST(queue, srv_sys->tasks, thr);
3201
 
 
3202
 
        srv_release_threads(SRV_WORKER, 1);
3203
 
 
3204
 
        mutex_exit(&kernel_mutex);
3205
 
}