From 1409a7b0e513e0aec14fe677d90e8fa90f772906 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Fran=C3=A7ois=20Gagn=C3=A9?= <8471576+jfg956@users.noreply.github.com> Date: Tue, 18 Mar 2025 09:12:08 -0400 Subject: [PATCH] Slow InnoDB Sync Reads Contrib. --- storage/innobase/buf/buf0rea.cc | 39 ++++++++++ storage/innobase/handler/ha_innodb.cc | 103 ++++++++++++++++++++++++-- storage/innobase/include/dict0dd.h | 6 +- storage/innobase/include/sess0sess.h | 6 ++ storage/innobase/include/srv0mon.h | 4 + storage/innobase/include/srv0srv.h | 21 ++++++ storage/innobase/os/os0file.cc | 52 ++++++++++--- storage/innobase/srv/srv0mon.cc | 48 ++++++++++++ storage/innobase/srv/srv0srv.cc | 9 +++ 9 files changed, 270 insertions(+), 18 deletions(-) diff --git a/storage/innobase/buf/buf0rea.cc b/storage/innobase/buf/buf0rea.cc index a255b99fd7ba..c2d0e8ad17b0 100644 --- a/storage/innobase/buf/buf0rea.cc +++ b/storage/innobase/buf/buf0rea.cc @@ -40,6 +40,9 @@ this program; if not, write to the Free Software Foundation, Inc., #include "buf0lru.h" #include "buf0rea.h" #include "fil0fil.h" +#include "dict0dd.h" +#include "current_thd.h" +#include "mysqld.h" #include "ha_prototypes.h" #include "ibuf0ibuf.h" #include "log0recv.h" @@ -288,12 +291,48 @@ ulint buf_read_ahead_random(const page_id_t &page_id, bool buf_read_page(const page_id_t &page_id, const page_size_t &page_size) { ulint count; dberr_t err; + innodb_session_t *innodb_session_tmp = nullptr; + innodb_session_t *&innodb_session = innodb_session_tmp; + + /* We do not know for sure if buf_read_page_low will generate an IO. + * With below assignment to 0, if the value is back as greater than 0, then there was an IO. */ + /* I / JFG am guessing that we can end-up here with current_thd or innodb_session being null, so let's be safe. */ + if (current_thd && (innodb_session = thd_to_innodb_session_null(current_thd))) { + innodb_session->needs_last_io_wait_usec = true; + innodb_session->last_io_wait_usec = 0; + } count = buf_read_page_low(&err, true, 0, BUF_READ_ANY_PAGE, page_id, page_size, false); srv_stats.buf_pool_reads.add(count); + if (innodb_session) { + innodb_session->needs_last_io_wait_usec = false; + ulong usec = innodb_session->last_io_wait_usec; + + /* We need the test to SERVER_OPERATING because of a convoluted reason. + * If the threshold is set with SET PERSIST, the setting of the variable will + * happen after InnoDB initialization. This means that all IOs happening + * before use the value from the conf file or the default. This can + * be confusing for the user, so excluding IOs done before SERVER_OPERATING. + * Obviously, this late setting by SET PERSIST could be considered a bug, + * but I / JFG did not yet find a good way to report this. */ + /* Reminder: there was an io only if usec > 0. */ + if (get_server_state() == SERVER_OPERATING && usec > 0) { + /* We need a counter in addition to srv_stats.buf_pool_reads + * because buf_pool_reads is incremented elsewhere + * (buf_read_ahead_random and buf_read_page_background). */ + srv_stats.buf_pool_reads_sync_io_count.add(count); + srv_stats.buf_pool_reads_sync_io_wait_usec.add(usec); + + if (usec >= srv_buffer_pool_read_sync_slow_io_threshold_usec) { + srv_stats.buf_pool_reads_sync_io_slow_count.add(count); + srv_stats.buf_pool_reads_sync_io_slow_wait_usec.add(usec); + } + } + } + if (err == DB_TABLESPACE_DELETED) { ib::error(ER_IB_MSG_141) << "trying to read page " << page_id << " in nonexisting or being-dropped tablespace"; diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc index 480cb338b449..dbb623cd934c 100644 --- a/storage/innobase/handler/ha_innodb.cc +++ b/storage/innobase/handler/ha_innodb.cc @@ -1178,6 +1178,31 @@ static SHOW_VAR innodb_status_variables[] = { SHOW_SCOPE_GLOBAL}, {"buffer_pool_reads", (char *)&export_vars.innodb_buffer_pool_reads, SHOW_LONG, SHOW_SCOPE_GLOBAL}, + /* Note JFG: + * We could consider not exposing the next four counters as Global Statuses + * and only expose them as InnoDB Metrics. + * IMHO, having both statuses and metrics is complexity that we should fight, + * but out of the scope of my patch. + * If I had a saying on the subject, I think InnoDB Global Statuses should be + * deprecated in favor of InnoDB Metrics (this might need adding metrics which do + * not have statuses, and at the same time, deprecating other counter interfaces + * like I_S.INNODB_CMP in favor of metrics). + * Not exposing the four counters below could nudge people in using the + * good interface (metrics), not the deprecated one, hence considering not adding them. + * But this should NOT be OpenTelemetry only, because I want my patch to be in MySQL Community. */ + {"buffer_pool_reads_sync_io_count", + (char *)&export_vars.buf_pool_reads_sync_io_count, + SHOW_LONG, SHOW_SCOPE_GLOBAL}, + {"buffer_pool_reads_sync_io_wait_usec", + (char *)&export_vars.buf_pool_reads_sync_io_wait_usec, + SHOW_LONG, SHOW_SCOPE_GLOBAL}, + {"buffer_pool_reads_sync_io_slow_count", + (char *)&export_vars.buf_pool_reads_sync_io_slow_count, + SHOW_LONG, SHOW_SCOPE_GLOBAL}, + {"buffer_pool_reads_sync_io_slow_wait_usec", + (char *)&export_vars.buf_pool_reads_sync_io_slow_wait_usec, + SHOW_LONG, SHOW_SCOPE_GLOBAL}, + /* End note JFG, see above for details. */ {"buffer_pool_wait_free", (char *)&export_vars.innodb_buffer_pool_wait_free, SHOW_LONG, SHOW_SCOPE_GLOBAL}, {"buffer_pool_write_requests", @@ -2004,15 +2029,11 @@ const char *thd_innodb_tmpdir(THD *thd) { return tmp_dir; } -/** Obtain the private handler of InnoDB session specific data. -@param[in,out] thd MySQL thread handler. -@return reference to private handler */ - -[[nodiscard]] innodb_session_t *&thd_to_innodb_session(THD *thd) { +[[nodiscard]] static inline innodb_session_t *&thd_to_innodb_session(THD *thd, bool return_null) { innodb_session_t *&innodb_session = *(innodb_session_t **)thd_ha_data(thd, innodb_hton_ptr); - if (innodb_session != nullptr) { + if (innodb_session != nullptr || return_null) { return (innodb_session); } @@ -2020,6 +2041,20 @@ const char *thd_innodb_tmpdir(THD *thd) { return (innodb_session); } +/** Obtain the private handler of InnoDB session specific data. +@param[in,out] thd MySQL thread handler. +@return reference to private handler */ +[[nodiscard]] innodb_session_t *&thd_to_innodb_session(THD *thd) { + return thd_to_innodb_session(thd, false); +} + +/** Same as thd_to_innodb_session, but returns null if the handler does not exist (without allocating memory). +@param[in,out] thd MySQL thread handler. +@return reference to private handler */ +[[nodiscard]] innodb_session_t *&thd_to_innodb_session_null(THD *thd) { + return thd_to_innodb_session(thd, true); +} + /** Obtain the InnoDB transaction of a MySQL thread. @param[in,out] thd MySQL thread handler. @return reference to transaction pointer */ @@ -5359,6 +5394,38 @@ static PSI_metric_info_v1 buffer_metrics[] = { "Number of reads directly from disk (innodb_buffer_pool_reads)", MetricOTELType::ASYNC_COUNTER, export_vars.innodb_buffer_pool_reads), + + /* I / JFG do not fully understand this, + * so I am blindly copying from above (innodb_buffer_pool_reads). + * I am guessing this is related to OpenTelemetry, + * and I opened a bug about this: https://bugs.mysql.com/bug.php?id=117659. + * If it is indeed related to OpenTelemetry, I cannot test this + * because it is an Enterprise feature, which I do not have a license to use. */ + simple("reads_sync_io_count", + "", + "Number of sync reads directly from disk (innodb_buffer_pool_reads_sync_io_count) " + "(sync reads exclude read-ahead and read-ahead random)", + MetricOTELType::ASYNC_COUNTER, + export_vars.buf_pool_reads_sync_io_count), + simple("reads_sync_io_wait_usec", + "", + "Total wait time, in microseconds, for buf_pool_reads_sync_io_count " + "(innodb_buffer_pool_reads_sync_io_wait_usec)", + MetricOTELType::ASYNC_COUNTER, + export_vars.buf_pool_reads_sync_io_wait_usec), + simple("reads_sync_io_slow_count", + "", + "Number of sync reads directly from disk greater than or equal to innodb_buffer_pool_read_slow_io_threshold_usec " + "(innodb_buffer_pool_reads_sync_io_slow_count)", + MetricOTELType::ASYNC_COUNTER, + export_vars.buf_pool_reads_sync_io_slow_count), + simple("reads_sync_io_slow_wait_use", + "", + "Total wait time, in microseconds, for buf_pool_reads_sync_io_slow_count " + "(innodb_buffer_pool_reads_sync_io_slow_wait_usec)", + MetricOTELType::ASYNC_COUNTER, + export_vars.buf_pool_reads_sync_io_slow_wait_usec), + simple("wait_free", "", "Number of times waited for free buffer (innodb_buffer_pool_wait_free)", @@ -22730,6 +22797,29 @@ static MYSQL_SYSVAR_BOOL( "Load the buffer pool from a file named @@innodb_buffer_pool_filename", nullptr, nullptr, true); +/* I / JFG chose these names... + * - variable: buffer_pool_read_sync_slow_io_threshold_usec + * - metrics: buf_pool_reads_sync_io_{count,wait_usec,slow_count,slow_wait_usec} + * ...over these... + * - io_read_sync_page_slow_threshold_usec + * - io_read_sync_page_slow_{count,wait_usec,slow_count,slow_wait_usec} + * ...because I thought these belongs in buf instead of os + * (most of the accounting logic is in buf, more precisely buf_read_page), + * but I could be convinced of doing it the other way around. */ +/* Below, max is set to 1 hour: IOs longer than that would be catastrophic ! */ +static MYSQL_SYSVAR_ULONG(buffer_pool_read_sync_slow_io_threshold_usec, srv_buffer_pool_read_sync_slow_io_threshold_usec, + PLUGIN_VAR_RQCMDARG, + "The threshold, in microseconds, from which IOs for sync buffer pool reads " + "are considered slow and accounted as such " + "(in global statuses innodb_buffer_pool_reads_sync_io_slow_{count,wait_usec} " + "and InnoDB Metrics buf_pool_reads_sync_io_slow_{count,wait_usec}) " + "(sync reads exclude read-ahead and read-ahead random)", + nullptr, nullptr, /* check, update */ + (((ulong)1000)*1000*60*60), 0, (((ulong)1000)*1000*60*60), /* def (same as max), min, max (1 hour) */ + 0 /* blk, unclear what this is, doc (link below) not helpful, copied from others */); +/* doc link for blk above: + * https://dev.mysql.com/doc/extending-mysql/8.0/en/plugin-status-system-variables.html */ + static MYSQL_SYSVAR_ULONG(lru_scan_depth, srv_LRU_scan_depth, PLUGIN_VAR_RQCMDARG, "How deep to scan LRU to keep it clean", nullptr, @@ -23510,6 +23600,7 @@ static SYS_VAR *innobase_system_variables[] = { MYSQL_SYSVAR(buffer_pool_load_now), MYSQL_SYSVAR(buffer_pool_load_abort), MYSQL_SYSVAR(buffer_pool_load_at_startup), + MYSQL_SYSVAR(buffer_pool_read_sync_slow_io_threshold_usec), MYSQL_SYSVAR(lru_scan_depth), MYSQL_SYSVAR(flush_neighbors), MYSQL_SYSVAR(checksum_algorithm), diff --git a/storage/innobase/include/dict0dd.h b/storage/innobase/include/dict0dd.h index a790bfd71e35..09f5b6a069e9 100644 --- a/storage/innobase/include/dict0dd.h +++ b/storage/innobase/include/dict0dd.h @@ -1311,9 +1311,13 @@ bool dd_drop_tablespace(dd::cache::Dictionary_client *dd_client, /** Obtain the private handler of InnoDB session specific data. @param[in,out] thd MySQL thread handler. @return reference to private handler */ - [[nodiscard]] innodb_session_t *&thd_to_innodb_session(THD *thd); +/** Same as thd_to_innodb_session, but returns null if the handler does not exist (without allocating memory). +@param[in,out] thd MySQL thread handler. +@return reference to private handler */ +[[nodiscard]] innodb_session_t *&thd_to_innodb_session_null(THD *thd); + /** Look up a column in a table using the system_charset_info collation. @param[in] dd_table data dictionary table @param[in] name column name diff --git a/storage/innobase/include/sess0sess.h b/storage/innobase/include/sess0sess.h index ed72e5d33684..a7a7c2eb0ddf 100644 --- a/storage/innobase/include/sess0sess.h +++ b/storage/innobase/include/sess0sess.h @@ -157,6 +157,12 @@ class innodb_session_t { Currently, limited to intrinsic temporary tables only. */ table_cache_t m_open_tables; + /* I / JFG wished there was a better way to carry this from os_aio_func to buf_read_page. + * And yes, I agree this is ugly, but I did not think of a better way. + * If you know / find a better way, let me know and I will improve the patch. */ + bool needs_last_io_wait_usec = false; + ulong last_io_wait_usec = 0; + private: /** Current session's user temp tablespace */ ibt::Tablespace *m_usr_temp_tblsp; diff --git a/storage/innobase/include/srv0mon.h b/storage/innobase/include/srv0mon.h index 52b98513a1d9..f93fb0288ad2 100644 --- a/storage/innobase/include/srv0mon.h +++ b/storage/innobase/include/srv0mon.h @@ -170,6 +170,10 @@ enum monitor_id_t { MONITOR_MODULE_BUFFER, MONITOR_OVLD_BUFFER_POOL_SIZE, MONITOR_OVLD_BUF_POOL_READS, + MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_COUNT, + MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_WAIT_USEC, + MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_SLOW_COUNT, + MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_SLOW_WAIT_USEC, MONITOR_OVLD_BUF_POOL_READ_REQUESTS, MONITOR_OVLD_BUF_POOL_WRITE_REQUEST, MONITOR_OVLD_BUF_POOL_WAIT_FREE, diff --git a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h index b6bf10810e00..3ede81dff774 100644 --- a/storage/innobase/include/srv0srv.h +++ b/storage/innobase/include/srv0srv.h @@ -117,6 +117,13 @@ struct srv_stats_t { a disk page */ ulint_ctr_1_t buf_pool_reads; + /* Documented in srv0mon.cc. */ + /* It looks pointless to duplicate documentation; if needed, let me / JFG know and I will fix it. */ + ulint_ctr_1_t buf_pool_reads_sync_io_count; + ulint_ctr_1_t buf_pool_reads_sync_io_wait_usec; + ulint_ctr_1_t buf_pool_reads_sync_io_slow_count; + ulint_ctr_1_t buf_pool_reads_sync_io_slow_wait_usec; + /** Number of data read in total (in bytes) */ ulint_ctr_1_t data_read; @@ -327,6 +334,10 @@ and/or load it during startup. */ extern bool srv_buffer_pool_dump_at_shutdown; extern bool srv_buffer_pool_load_at_startup; +/* Documented in ha_innodb.cc. */ +/* It looks pointless to duplicate comments; if needed, let me / JFG know and I will fix it. */ +extern ulong srv_buffer_pool_read_sync_slow_io_threshold_usec; + /* Whether to disable file system cache if it is defined */ extern bool srv_disable_sort_file_cache; @@ -1152,6 +1163,16 @@ struct export_var_t { #endif /* UNIV_DEBUG */ ulint innodb_buffer_pool_read_requests; /*!< buf_pool->stat.n_page_gets */ ulint innodb_buffer_pool_reads; /*!< srv_buf_pool_reads */ + /* To me / JFG, it looks like above "srv_buf_pool_reads" should be "srv_stats.buf_pool_reads", + * but I might be missing something (or I am right and above is a relic of a refactor). + * If I am wrong, below four comments need to be adjusted. + * Also, I do not like these variable names, so I am suggesting something + * I like better, if this is unwelcome, feel free to adjust when merging + * (or asking me to fix the patch) */ + ulint buf_pool_reads_sync_io_count; /*!< srv_stats.buf_pool_reads_sync_io_count */ + ulint buf_pool_reads_sync_io_wait_usec; /*!< srv_stats.buf_pool_reads_sync_io_wait_usec */ + ulint buf_pool_reads_sync_io_slow_count; /*!< srv_stats.buf_pool_reads_sync_io_slow_count */ + ulint buf_pool_reads_sync_io_slow_wait_usec; /*!< srv_stats.buf_pool_reads_sync_io_slow_wait_usec */ ulint innodb_buffer_pool_wait_free; /*!< srv_buf_pool_wait_free */ ulint innodb_buffer_pool_pages_flushed; /*!< srv_buf_pool_flushed */ ulint innodb_buffer_pool_write_requests; /*!< srv_buf_pool_write_requests */ diff --git a/storage/innobase/os/os0file.cc b/storage/innobase/os/os0file.cc index c40c43fb466b..1b7f26bbec17 100644 --- a/storage/innobase/os/os0file.cc +++ b/storage/innobase/os/os0file.cc @@ -41,15 +41,17 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include "os0file.h" #include "fil0fil.h" +#include "dict0dd.h" +#include "current_thd.h" #include "ha_prototypes.h" #include "log0write.h" #include "my_dbug.h" #include "my_io.h" -#include "fil0fil.h" -#include "ha_prototypes.h" +#include "fil0fil.h" /* I / JFG do not understand this duplicate include with above, maybe should be removed, but out of scope of my patch. */ +#include "ha_prototypes.h" /* I / JFG do not understand this duplicate include with above, maybe should be removed, but out of scope of my patch. */ #include "my_macros.h" -#include "os0file.h" +#include "os0file.h" /* I / JFG do not understand this duplicate include with above, maybe should be removed, but out of scope of my patch. */ #include "sql_const.h" #include "srv0srv.h" #include "srv0start.h" @@ -6802,6 +6804,20 @@ dberr_t os_aio_func(IORequest &type, AIO_mode aio_mode, const char *name, ut_ad((n & 0xFFFFFFFFUL) == n); #endif /* _WIN32 */ + dberr_t ret; + + innodb_session_t *innodb_session_tmp = nullptr; + innodb_session_t *&innodb_session = innodb_session_tmp; + bool needs_now = false; + std::chrono::steady_clock::time_point start; + + /* I / JFG am guessing that we can end-up here with current_thd or innodb_session being null, so let's be safe. */ + if (current_thd + && (innodb_session = thd_to_innodb_session_null(current_thd)) + && (needs_now = innodb_session->needs_last_io_wait_usec)) { + start = std::chrono::steady_clock::now(); + } + if (aio_mode == AIO_mode::SYNC) { /* This is actually an ordinary synchronous read or write: no need to use an i/o-handler thread. NOTE that if we use @@ -6815,13 +6831,18 @@ dberr_t os_aio_func(IORequest &type, AIO_mode aio_mode, const char *name, os_file_write(). Instead, we should use os_file_read_func() and os_file_write_func() */ if (type.is_read()) { - return (os_file_read_func(type, name, file.m_file, buf, offset, n)); - } - + ret = os_file_read_func(type, name, file.m_file, buf, offset, n); + } else { + /* Below is poorly indented to make the diff easier to understand. + * It can be reformatted when merging, maybe in a different merge commit. + * I left this comment for clarity of the patch, it can be removed when merging. */ ut_ad(type.is_write()); - return (os_file_write_func(type, name, file.m_file, buf, offset, n)); - } - + ret = os_file_write_func(type, name, file.m_file, buf, offset, n); + } + } else { + /* This block is poorly indented to make the diff easier to understand. + * It can be reformatted when merging, maybe in a different merge commit. + * I left this comment for clarity of the patch, it can be removed when merging. */ const auto array = AIO::select_slot_array(type, read_only, aio_mode); bool io_dispatched = false; while (!io_dispatched) { @@ -6912,10 +6933,19 @@ dberr_t os_aio_func(IORequest &type, AIO_mode aio_mode, const char *name, return DB_IO_ERROR; } } + } /* End of poorly indented block. */ + + /* AIO request was dispatched successfully! */ + ret = DB_SUCCESS; } - /* AIO request was dispatched successfully! */ - return (DB_SUCCESS); + if (needs_now) { + auto end = std::chrono::steady_clock::now(); + auto time_us = std::chrono::duration_cast(end - start).count(); + innodb_session->last_io_wait_usec = time_us; + } + + return ret; } /** Simulated AIO handler for reaping IO requests */ diff --git a/storage/innobase/srv/srv0mon.cc b/storage/innobase/srv/srv0mon.cc index acb36b2d7fc6..d861d43b28b6 100644 --- a/storage/innobase/srv/srv0mon.cc +++ b/storage/innobase/srv/srv0mon.cc @@ -235,6 +235,30 @@ static monitor_info_t innodb_counter_info[] = { static_cast(MONITOR_EXISTING | MONITOR_DEFAULT_ON), MONITOR_DEFAULT_START, MONITOR_OVLD_BUF_POOL_READS}, + {"buf_pool_reads_sync_io_count", "buffer", + "Number of sync reads directly from disk (innodb_buffer_pool_reads_sync_io_count) " + "(sync reads exclude read-ahead and read-ahead random)", + static_cast(MONITOR_EXISTING | MONITOR_DEFAULT_ON), + MONITOR_DEFAULT_START, MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_COUNT}, + + {"buf_pool_reads_sync_io_wait_usec", "buffer", + "Total wait time, in microseconds, for buf_pool_reads_sync_io_count " + "(innodb_buffer_pool_reads_sync_io_wait_usec)", + static_cast(MONITOR_EXISTING | MONITOR_DEFAULT_ON), + MONITOR_DEFAULT_START, MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_WAIT_USEC}, + + {"buf_pool_reads_sync_io_slow_count", "buffer", + "Number of sync reads directly from disk greater than or equal to innodb_buffer_pool_read_slow_io_threshold_usec " + "(innodb_buffer_pool_reads_sync_io_slow_count)", + static_cast(MONITOR_EXISTING | MONITOR_DEFAULT_ON), + MONITOR_DEFAULT_START, MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_SLOW_COUNT}, + + {"buf_pool_reads_sync_io_slow_wait_usec", "buffer", + "Total wait time, in microseconds, for buf_pool_reads_sync_io_slow_count " + "(innodb_buffer_pool_reads_sync_io_slow_wait_usec)", + static_cast(MONITOR_EXISTING | MONITOR_DEFAULT_ON), + MONITOR_DEFAULT_START, MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_SLOW_WAIT_USEC}, + {"buffer_pool_read_requests", "buffer", "Number of logical read requests (innodb_buffer_pool_read_requests)", static_cast(MONITOR_EXISTING | MONITOR_DEFAULT_ON), @@ -1635,6 +1659,30 @@ void srv_mon_process_existing_counter( value = srv_stats.buf_pool_reads; break; + /* Documented in "static monitor_info_t innodb_counter_info[]" above. */ + /* It looks pointless to duplicate documentation; if needed, let me / JFG know and I will fix it. */ + case MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_COUNT: + value = srv_stats.buf_pool_reads_sync_io_count; + break; + + /* Documented in "static monitor_info_t innodb_counter_info[]"" above. */ + /* It looks pointless to duplicate documentation; if needed, let me / JFG know and I will fix it. */ + case MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_WAIT_USEC: + value = srv_stats.buf_pool_reads_sync_io_wait_usec; + break; + + /* Documented in "static monitor_info_t innodb_counter_info[]"" above. */ + /* It looks pointless to duplicate documentation; if needed, let me / JFG know and I will fix it. */ + case MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_SLOW_COUNT: + value = srv_stats.buf_pool_reads_sync_io_slow_count; + break; + + /* Documented in "static monitor_info_t innodb_counter_info[]"" above. */ + /* It looks pointless to duplicate documentation; if needed, let me / JFG know and I will fix it. */ + case MONITOR_OVLD_BUF_POOL_READS_SYNC_IO_SLOW_WAIT_USEC: + value = srv_stats.buf_pool_reads_sync_io_slow_wait_usec; + break; + /* innodb_buffer_pool_read_requests, the number of logical read requests */ case MONITOR_OVLD_BUF_POOL_READ_REQUESTS: diff --git a/storage/innobase/srv/srv0srv.cc b/storage/innobase/srv/srv0srv.cc index b4f61eb13fe3..60bc70f715ba 100644 --- a/storage/innobase/srv/srv0srv.cc +++ b/storage/innobase/srv/srv0srv.cc @@ -797,6 +797,10 @@ and/or load it during startup. */ bool srv_buffer_pool_dump_at_shutdown = true; bool srv_buffer_pool_load_at_startup = true; +/* Documented in ha_innodb.cc. */ +/* It looks pointless to duplicate documentation; if needed, let me / JFG know and I will fix it. */ +ulong srv_buffer_pool_read_sync_slow_io_threshold_usec; + /** Slot index in the srv_sys->sys_threads array for the purge thread. */ static const ulint SRV_PURGE_SLOT = 1; @@ -1615,6 +1619,11 @@ void srv_export_innodb_status(void) { export_vars.innodb_buffer_pool_reads = srv_stats.buf_pool_reads; + export_vars.buf_pool_reads_sync_io_count = srv_stats.buf_pool_reads_sync_io_count; + export_vars.buf_pool_reads_sync_io_wait_usec = srv_stats.buf_pool_reads_sync_io_wait_usec; + export_vars.buf_pool_reads_sync_io_slow_count = srv_stats.buf_pool_reads_sync_io_slow_count; + export_vars.buf_pool_reads_sync_io_slow_wait_usec = srv_stats.buf_pool_reads_sync_io_slow_wait_usec; + export_vars.innodb_buffer_pool_read_ahead_rnd = stat.n_ra_pages_read_rnd; export_vars.innodb_buffer_pool_read_ahead = stat.n_ra_pages_read;