MySQL 8.0.31
Source Code Documentation
srv0mon.h
Go to the documentation of this file.
1/***********************************************************************
2
3Copyright (c) 2010, 2022, Oracle and/or its affiliates.
4Copyright (c) 2012, Facebook Inc.
5
6This program is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License, version 2.0,
8as published by the Free Software Foundation.
9
10This program is also distributed with certain software (including
11but not limited to OpenSSL) that is licensed under separate terms,
12as designated in a particular file or component or in included license
13documentation. The authors of MySQL hereby grant you an additional
14permission to link the program and your derivative works with the
15separately licensed software that they have included with MySQL.
16
17This program is distributed in the hope that it will be useful,
18but WITHOUT ANY WARRANTY; without even the implied warranty of
19MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20GNU General Public License, version 2.0, for more details.
21
22You should have received a copy of the GNU General Public License
23along with this program; if not, write to the Free Software
24Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25
26***********************************************************************/
27
28/** @file include/srv0mon.h
29 Server monitor counter related defines
30
31 Created 12/15/2009 Jimmy Yang
32 *******************************************************/
33
34#ifndef srv0mon_h
35#define srv0mon_h
36
37#include "univ.i"
38
39#ifndef __STDC_LIMIT_MACROS
40/* Required for FreeBSD so that INT64_MAX is defined. */
41#define __STDC_LIMIT_MACROS
42#endif /* __STDC_LIMIT_MACROS */
43
44#include <stdint.h>
45
46/** Possible status values for "mon_status" in "struct monitor_value" */
48 MONITOR_STARTED = 1, /*!< Monitor has been turned on */
49 MONITOR_STOPPED = 2 /*!< Monitor has been turned off */
50};
51
53
54/** Monitor counter value type */
55typedef int64_t mon_type_t;
56
57/** Two monitor structures are defined in this file. One is
58"monitor_value_t" which contains dynamic counter values for each
59counter. The other is "monitor_info_t", which contains
60static information (counter name, desc etc.) for each counter.
61In addition, an enum datatype "monitor_id_t" is also defined,
62it identifies each monitor with an internally used symbol, whose
63integer value indexes into above two structure for its dynamic
64and static information.
65Developer who intend to add new counters would require to
66fill in counter information as described in "monitor_info_t" and
67create the internal counter ID in "monitor_id_t". */
68
69/** Structure containing the actual values of a monitor counter. */
71 std::chrono::system_clock::time_point
72 mon_start_time; /*!< Start time of monitoring */
73 std::chrono::system_clock::time_point
74 mon_stop_time; /*!< Stop time of monitoring */
75 std::chrono::system_clock::time_point
76 mon_reset_time; /*!< Time counter was reset */
77 std::atomic<mon_type_t> mon_value; /*!< Current counter Value */
78 mon_type_t mon_max_value; /*!< Current Max value */
79 mon_type_t mon_min_value; /*!< Current Min value */
80 mon_type_t mon_value_reset; /*!< value at last reset */
81 mon_type_t mon_max_value_start; /*!< Max value since start */
82 mon_type_t mon_min_value_start; /*!< Min value since start */
83 mon_type_t mon_start_value; /*!< Value at the start time */
84 mon_type_t mon_last_value; /*!< Last set of values */
85 monitor_running_t mon_status; /* whether monitor still running */
86};
87
88/** Following defines are possible values for "monitor_type" field in
89"struct monitor_info" */
91 MONITOR_NONE = 0, /*!< No monitoring */
92 MONITOR_MODULE = 1, /*!< This is a monitor module type,
93 not a counter */
94 MONITOR_EXISTING = 2, /*!< The monitor carries information from
95 an existing system status variable */
96 MONITOR_NO_AVERAGE = 4, /*!< Set this status if we don't want to
97 calculate the average value for the counter */
98 MONITOR_DISPLAY_CURRENT = 8, /*!< Display current value of the
99 counter, rather than incremental value
100 over the period. Mostly for counters
101 displaying current resource usage */
102 MONITOR_GROUP_MODULE = 16, /*!< Monitor can be turned on/off
103 only as a module, but not individually */
104 MONITOR_DEFAULT_ON = 32, /*!< Monitor will be turned on by default at
105 server start up */
106 MONITOR_SET_OWNER = 64, /*!< Owner of "monitor set", a set of
107 monitor counters */
108 MONITOR_SET_MEMBER = 128, /*!< Being part of a "monitor set" */
109 MONITOR_HIDDEN = 256 /*!< Do not display this monitor in the
110 metrics table */
112
113/** Counter minimum value is initialized to be max value of
114 mon_type_t (int64_t) */
115#define MIN_RESERVED INT64_MAX
116#define MAX_RESERVED (~MIN_RESERVED)
117
118/** This enumeration defines internal monitor identifier used internally
119to identify each particular counter. Its value indexes into two arrays,
120one is the "innodb_counter_value" array which records actual monitor
121counter values, the other is "innodb_counter_info" array which describes
122each counter's basic information (name, desc etc.). A couple of
123naming rules here:
1241) If the monitor defines a module, it starts with MONITOR_MODULE
1252) If the monitor uses existing counters from "status variable", its ID
126name shall start with MONITOR_OVLD
127
128Please refer to "innodb_counter_info" in srv/srv0mon.cc for detail
129information for each monitor counter */
130
132 /* This is to identify the default value set by the metrics
133 control global variables */
135
136 /* Start of Metadata counter */
141
142 /* Lock manager related counters */
166
167 /* Buffer and I/O related counters. */
199
203
209
213
216
251
252 /* Buffer Page I/O specific counters. */
291
292 /* OS level counters (I/O) */
303
304 /* Transaction related counters */
322
323 /* Purge related counters */
334
335 /* Undo tablespace truncation */
341
342 /* Recovery related counters */
357
362
370
376
380
384
388
390
405
406 /* Page Manager related counters */
412
413 /* Index related counters */
421
422 /* Adaptive Hash Index related counters */
432
433 /* Tablespace related counters */
436
437 /* InnoDB Change Buffer related counters */
447
448 /* Counters for server operations */
472
473 /* Data DML related counters */
483
484 /* Sampling related counters */
488
489 /* Data DDL related counters */
496
502
503 /* Mutex/RW-Lock related counters */
506
507 /* CPU usage information */
514
520
526
527 /* This is used only for control system to turn
528 on/off and reset all monitor counters */
530
531 /* This must be the last member */
534
535/** This informs the monitor control system to turn
536on/off and reset monitor counters through wild card match */
537#define MONITOR_WILDCARD_MATCH (NUM_MONITOR + 1)
538
539/** Cannot find monitor counter with a specified name */
540#define MONITOR_NO_MATCH (NUM_MONITOR + 2)
541
542/** struct monitor_info describes the basic/static information
543about each monitor counter. */
545 const char *monitor_name; /*!< Monitor name */
546 const char *monitor_module; /*!< Sub Module the monitor
547 belongs to */
548 const char *monitor_desc; /*!< Brief desc of monitor counter */
549 monitor_type_t monitor_type; /*!< Type of Monitor Info */
550 monitor_id_t monitor_related_id; /*!< Monitor ID of counter that
551 related to this monitor. This is
552 set when the monitor belongs to
553 a "monitor set" */
554 monitor_id_t monitor_id; /*!< Monitor ID as defined in enum
555 monitor_id_t */
556};
557
558/** Following are the "set_option" values allowed for
559srv_mon_process_existing_counter() and srv_mon_process_existing_counter()
560functions. To turn on/off/reset the monitor counters. */
562 MONITOR_TURN_ON = 1, /*!< Turn on the counter */
563 MONITOR_TURN_OFF, /*!< Turn off the counter */
564 MONITOR_RESET_VALUE, /*!< Reset current values */
565 MONITOR_RESET_ALL_VALUE, /*!< Reset all values */
566 MONITOR_GET_VALUE /*!< Option for
567 srv_mon_process_existing_counter()
568 function */
570
571#ifndef UNIV_HOTBACKUP
572/** Number of bit in a ulint datatype */
573#define NUM_BITS_ULINT (sizeof(ulint) * CHAR_BIT)
574
575/** This "monitor_set_tbl" is a bitmap records whether a particular monitor
576counter has been turned on or off */
577extern ulint
579
580/** Macros to turn on/off the control bit in monitor_set_tbl for a monitor
581counter option. */
582#define MONITOR_ON(monitor) \
583 (monitor_set_tbl[monitor / NUM_BITS_ULINT] |= \
584 ((ulint)1 << (monitor % NUM_BITS_ULINT)))
585
586#define MONITOR_OFF(monitor) \
587 (monitor_set_tbl[monitor / NUM_BITS_ULINT] &= \
588 ~((ulint)1 << (monitor % NUM_BITS_ULINT)))
589
590/** Check whether the requested monitor is turned on/off */
591#define MONITOR_IS_ON(monitor) \
592 (monitor_set_tbl[monitor / NUM_BITS_ULINT] & \
593 ((ulint)1 << (monitor % NUM_BITS_ULINT)))
594
595/** The actual monitor counter array that records each monitor counter
596value */
598
599/** Following are macro defines for basic monitor counter manipulations.
600Please note we do not provide any synchronization for these monitor
601operations due to performance consideration. Most counters can
602be placed under existing mutex protections in respective code
603module. */
604
605/** Macros to access various fields of a monitor counters */
606#define MONITOR_FIELD(monitor, field) (innodb_counter_value[monitor].field)
607
608#define MONITOR_VALUE(monitor) MONITOR_FIELD(monitor, mon_value)
609
610#define MONITOR_MAX_VALUE(monitor) MONITOR_FIELD(monitor, mon_max_value)
611
612#define MONITOR_MIN_VALUE(monitor) MONITOR_FIELD(monitor, mon_min_value)
613
614#define MONITOR_VALUE_RESET(monitor) MONITOR_FIELD(monitor, mon_value_reset)
615
616#define MONITOR_MAX_VALUE_START(monitor) \
617 MONITOR_FIELD(monitor, mon_max_value_start)
618
619#define MONITOR_MIN_VALUE_START(monitor) \
620 MONITOR_FIELD(monitor, mon_min_value_start)
621
622#define MONITOR_LAST_VALUE(monitor) MONITOR_FIELD(monitor, mon_last_value)
623
624#define MONITOR_START_VALUE(monitor) MONITOR_FIELD(monitor, mon_start_value)
625
626#define MONITOR_VALUE_SINCE_START(monitor) \
627 (MONITOR_VALUE(monitor) + MONITOR_VALUE_RESET(monitor))
628
629#define MONITOR_STATUS(monitor) MONITOR_FIELD(monitor, mon_status)
630
631#define MONITOR_SET_START(monitor) \
632 do { \
633 MONITOR_STATUS(monitor) = MONITOR_STARTED; \
634 MONITOR_FIELD((monitor), mon_start_time) = \
635 std::chrono::system_clock::now(); \
636 } while (0)
637
638#define MONITOR_SET_OFF(monitor) \
639 do { \
640 MONITOR_STATUS(monitor) = MONITOR_STOPPED; \
641 MONITOR_FIELD((monitor), mon_stop_time) = \
642 std::chrono::system_clock::now(); \
643 } while (0)
644
645#define MONITOR_INIT_ZERO_VALUE 0
646
647/** Max and min values are initialized when we first turn on the monitor
648counter, and set the MONITOR_STATUS. */
649#define MONITOR_MAX_MIN_NOT_INIT(monitor) \
650 (MONITOR_STATUS(monitor) == MONITOR_INIT_ZERO_VALUE && \
651 MONITOR_MIN_VALUE(monitor) == MONITOR_INIT_ZERO_VALUE && \
652 MONITOR_MAX_VALUE(monitor) == MONITOR_INIT_ZERO_VALUE)
653
654#define MONITOR_INIT(monitor) \
655 if (MONITOR_MAX_MIN_NOT_INIT(monitor)) { \
656 MONITOR_MIN_VALUE(monitor) = MIN_RESERVED; \
657 MONITOR_MIN_VALUE_START(monitor) = MIN_RESERVED; \
658 MONITOR_MAX_VALUE(monitor) = MAX_RESERVED; \
659 MONITOR_MAX_VALUE_START(monitor) = MAX_RESERVED; \
660 }
661
662#ifdef UNIV_DEBUG_VALGRIND
663#define MONITOR_CHECK_DEFINED(value) \
664 do { \
665 UNIV_MEM_ASSERT_RW(&value, sizeof value); \
666 } while (0)
667#else /* UNIV_DEBUG_VALGRIND */
668#define MONITOR_CHECK_DEFINED(value) (void)0
669#endif /* UNIV_DEBUG_VALGRIND */
670
671/** Macros to increment/decrement the counters. The normal
672monitor counter operation expects appropriate synchronization
673already exists. No additional mutex is necessary when operating
674on the counters */
675#define MONITOR_INC(monitor) monitor_inc_value(monitor, 1)
676#define MONITOR_DEC(monitor) monitor_dec(monitor)
677#define MONITOR_INC_VALUE(monitor, value) monitor_inc_value(monitor, value)
678#define MONITOR_DEC_VALUE(monitor, value) monitor_dec_value(monitor, value)
679
680/* Increment/decrement counter without check the monitor on/off bit, which
681could already be checked as a module group */
682#define MONITOR_INC_NOCHECK(monitor) monitor_inc_value_nocheck(monitor, 1)
683#define MONITOR_DEC_NOCHECK(monitor) monitor_dec_value_nocheck(monitor, 1)
684
685/** Atomically increment a monitor counter.
686Use MONITOR_INC if appropriate mutex protection exists.
687@param monitor monitor to be incremented by 1 */
688#define MONITOR_ATOMIC_INC(monitor) monitor_atomic_inc(monitor, 1)
689
690#define MONITOR_ATOMIC_INC_VALUE(monitor, value) \
691 monitor_atomic_inc(monitor, value)
692
693/** Atomically decrement a monitor counter.
694Use MONITOR_DEC if appropriate mutex protection exists.
695@param monitor monitor to be decremented by 1 */
696#define MONITOR_ATOMIC_DEC(monitor) monitor_atomic_dec(monitor)
697
698inline void monitor_set_max_value(monitor_id_t monitor, mon_type_t value) {
699 if (value > MONITOR_MAX_VALUE(monitor)) {
700 MONITOR_MAX_VALUE(monitor) = value;
701 }
702}
703
704inline void monitor_set_min_value(monitor_id_t monitor, mon_type_t value) {
705 if (value < MONITOR_MIN_VALUE(monitor)) {
706 MONITOR_MIN_VALUE(monitor) = value;
707 }
708}
709
710inline void monitor_atomic_inc(monitor_id_t monitor, mon_type_t inc_value) {
711 if (MONITOR_IS_ON(monitor)) {
712 const mon_type_t value =
713 MONITOR_VALUE(monitor).fetch_add(inc_value) + inc_value;
714 /* Note: This is not 100% accurate because of the inherent race, we ignore
715 it due to performance. */
716 monitor_set_max_value(monitor, value);
717 }
718}
719
720inline void monitor_atomic_dec(monitor_id_t monitor) {
721 if (MONITOR_IS_ON(monitor)) {
722 const mon_type_t value = --MONITOR_VALUE(monitor);
723 /* Note: This is not 100% accurate because of the inherent race, we ignore
724 it due to performance. */
725 monitor_set_min_value(monitor, value);
726 }
727}
728
730 bool set_max = true) {
731 /* We use std::memory_order_relaxed load() and store() as two separate steps,
732 instead of single atomic fetch_add operation, because we want to leave it
733 non-atomic as it was before changing mon_value to std::atomic.*/
734 const auto new_value =
735 MONITOR_VALUE(monitor).load(std::memory_order_relaxed) + value;
736 MONITOR_VALUE(monitor).store(new_value, std::memory_order_relaxed);
737 if (set_max) {
738 monitor_set_max_value(monitor, new_value);
739 }
740}
741
742inline void monitor_inc_value(monitor_id_t monitor, mon_type_t value) {
744 if (MONITOR_IS_ON(monitor)) {
745 monitor_inc_value_nocheck(monitor, value);
746 }
747}
748
750 /* We use std::memory_order_relaxed load() and store() as two separate steps,
751 instead of single atomic fetch_sub operation, because we want to leave it
752 non-atomic as it was before changing mon_value to std::atomic.*/
753 const auto new_value =
754 MONITOR_VALUE(monitor).load(std::memory_order_relaxed) - value;
755 MONITOR_VALUE(monitor).store(new_value, std::memory_order_relaxed);
756 monitor_set_min_value(monitor, new_value);
757}
758
759inline void monitor_dec_value(monitor_id_t monitor, mon_type_t value) {
761 if (MONITOR_IS_ON(monitor)) {
762 ut_ad(MONITOR_VALUE(monitor) >= value);
763 monitor_dec_value_nocheck(monitor, value);
764 }
765}
766
767inline void monitor_dec(monitor_id_t monitor) {
768 if (MONITOR_IS_ON(monitor)) {
769 monitor_dec_value_nocheck(monitor, 1);
770 }
771}
772
773/** Directly set a monitor counter's value */
774#define MONITOR_SET(monitor, value) monitor_set(monitor, value, true, true)
775
776/** Sets a value to the monitor counter
777@param monitor monitor to update
778@param value value to set
779@param set_max says whether to update MONITOR_MAX_VALUE
780@param set_min says whether to update MONITOR_MIN_VALUE */
781inline void monitor_set(monitor_id_t monitor, mon_type_t value, bool set_max,
782 bool set_min) {
784 if (MONITOR_IS_ON(monitor)) {
785 MONITOR_VALUE(monitor).store(value, std::memory_order_relaxed);
786 if (set_max) {
787 monitor_set_max_value(monitor, value);
788 }
789 if (set_min) {
790 monitor_set_min_value(monitor, value);
791 }
792 }
793}
794
795/** Add time difference between now and input "value" to the monitor counter
796@param monitor monitor to update for the time difference
797@param value the start time value */
798#define MONITOR_INC_TIME(monitor, value) monitor_inc_time(monitor, value)
799
800inline void monitor_inc_time(monitor_id_t monitor,
801 std::chrono::steady_clock::time_point value) {
803 if (MONITOR_IS_ON(monitor)) {
804 const mon_type_t new_value =
805 MONITOR_VALUE(monitor).load(std::memory_order_relaxed) +
806 std::chrono::duration_cast<std::chrono::microseconds>(
807 std::chrono::steady_clock::now() - value)
808 .count();
809 MONITOR_VALUE(monitor).store(new_value, std::memory_order_relaxed);
810 }
811}
812
813/** This macro updates 3 counters in one call. However, it only checks the
814main/first monitor counter 'monitor', to see it is on or off to decide
815whether to do the update.
816@param monitor the main monitor counter to update. It accounts for
817 the accumulative value for the counter.
818@param monitor_n_calls counter that counts number of times this macro is
819 called
820@param monitor_per_call counter that records the current and max value of
821 each incremental value
822@param value incremental value to record this time */
823#define MONITOR_INC_VALUE_CUMULATIVE(monitor, monitor_n_calls, \
824 monitor_per_call, value) \
825 monitor_inc_value_cumulative(monitor, monitor_n_calls, monitor_per_call, \
826 value)
827
829 monitor_id_t monitor_n_calls,
830 monitor_id_t monitor_per_call,
831 mon_type_t value) {
833 if (MONITOR_IS_ON(monitor)) {
834 monitor_inc_value_nocheck(monitor_n_calls, 1, false);
835 monitor_set(monitor_per_call, value, true, false);
836 monitor_inc_value_nocheck(monitor, value);
837 }
838}
839
840/** Directly set a monitor counter's value, and if the value
841is monotonically increasing, only max value needs to be updated */
842#define MONITOR_SET_UPD_MAX_ONLY(monitor, value) \
843 monitor_set(monitor, value, true, false)
844
845/** Some values such as log sequence number are monotonically increasing
846number, do not need to record max/min values */
847#define MONITOR_SET_SIMPLE(monitor, value) \
848 monitor_set(monitor, value, false, false)
849
850/** Reset the monitor value and max/min value to zero. The reset
851operation would only be conducted when the counter is turned off */
852#define MONITOR_RESET_ALL(monitor) monitor_reset_all(monitor)
853
854inline void monitor_reset_all(monitor_id_t monitor) {
856 std::memory_order_relaxed);
863 MONITOR_FIELD(monitor, mon_start_time) = {};
864 MONITOR_FIELD(monitor, mon_stop_time) = {};
865 MONITOR_FIELD(monitor, mon_reset_time) = {};
866}
867
868/** Following four macros defines necessary operations to fetch and
869consolidate information from existing system status variables. */
870
871/** Save the passed-in value to mon_start_value field of monitor
872counters */
873#define MONITOR_SAVE_START(monitor, value) \
874 do { \
875 MONITOR_CHECK_DEFINED(value); \
876 (MONITOR_START_VALUE(monitor) = \
877 (mon_type_t)(value)-MONITOR_VALUE_RESET(monitor)); \
878 } while (0)
879
880/** Save the passed-in value to mon_last_value field of monitor
881counters */
882#define MONITOR_SAVE_LAST(monitor) monitor_save_last(monitor)
883
884inline void monitor_save_last(monitor_id_t monitor) {
885 const auto value = MONITOR_VALUE(monitor).load(std::memory_order_relaxed);
886 MONITOR_LAST_VALUE(monitor) = value;
887 MONITOR_START_VALUE(monitor) += value;
888}
889
890/** Set monitor value to the difference of value and mon_start_value
891compensated by mon_last_value if accumulated value is required. */
892#define MONITOR_SET_DIFF(monitor, value) \
893 MONITOR_SET_UPD_MAX_ONLY(monitor, ((value)-MONITOR_VALUE_RESET(monitor) - \
894 MONITOR_FIELD(monitor, mon_start_value) + \
895 MONITOR_FIELD(monitor, mon_last_value)))
896
897/** Get monitor's monitor_info_t by its monitor id (index into the
898 innodb_counter_info array
899 @return Point to corresponding monitor_info_t, or NULL if no such
900 monitor */
902 monitor_id_t monitor_id); /*!< id index into the
903 innodb_counter_info array */
904/** Get monitor's name by its monitor id (index into the
905 innodb_counter_info array
906 @return corresponding monitor name, or NULL if no such
907 monitor */
908const char *srv_mon_get_name(
909 monitor_id_t monitor_id); /*!< id index into the
910 innodb_counter_info array */
911
912/** Turn on/off/reset monitor counters in a module. If module_value
913 is NUM_MONITOR then turn on all monitor counters. */
915 monitor_id_t module_id, /*!< in: Module ID as in
916 monitor_counter_id. If it is
917 set to NUM_MONITOR, this means
918 we shall turn on all the counters */
919 mon_option_t set_option); /*!< in: Turn on/off reset the
920 counter */
921/** This function consolidates some existing server counters used
922 by "system status variables". These existing system variables do not have
923 mechanism to start/stop and reset the counters, so we simulate these
924 controls by remembering the corresponding counter values when the
925 corresponding monitors are turned on/off/reset, and do appropriate
926 mathematics to deduct the actual value. */
928 monitor_id_t monitor_id, /*!< in: the monitor's ID as in
929 monitor_counter_id */
930 mon_option_t set_option); /*!< in: Turn on/off reset the
931 counter */
932/** This function is used to calculate the maximum counter value
933 since the start of monitor counter
934 @return max counter value since start. */
936 monitor_id_t monitor); /*!< in: monitor id */
937/** This function is used to calculate the minimum counter value
938 since the start of monitor counter
939 @return min counter value since start. */
941 monitor_id_t monitor); /*!< in: monitor id*/
942/** Reset a monitor, create a new base line with the current monitor
943 value. This baseline is recorded by MONITOR_VALUE_RESET(monitor) */
944void srv_mon_reset(monitor_id_t monitor); /*!< in: monitor id*/
945/** This function resets all values of a monitor counter */
946static inline void srv_mon_reset_all(
947 monitor_id_t monitor); /*!< in: monitor id*/
948/** Turn on monitor counters that are marked as default ON. */
949void srv_mon_default_on(void);
950
951#include "srv0mon.ic"
952#else /* !UNIV_HOTBACKUP */
953#define MONITOR_INC(x) ((void)0)
954#define MONITOR_DEC(x) ((void)0)
955#endif /* !UNIV_HOTBACKUP */
956
957#define MONITOR_INC_WAIT_STATS_EX(monitor_prefix, monitor_sufix, wait_stats) \
958 if ((wait_stats).wait_loops == 0) { \
959 MONITOR_INC(monitor_prefix##NO_WAITS##monitor_sufix); \
960 } else { \
961 MONITOR_INC(monitor_prefix##WAITS##monitor_sufix); \
962 MONITOR_INC_VALUE(monitor_prefix##WAIT_LOOPS##monitor_sufix, \
963 (wait_stats).wait_loops); \
964 }
965
966#define MONITOR_INC_WAIT_STATS(monitor_prefix, wait_stats) \
967 MONITOR_INC_WAIT_STATS_EX(monitor_prefix, , wait_stats);
968
969#endif
#define MONITOR_MAX_VALUE(monitor)
Definition: srv0mon.h:610
monitor_value_t innodb_counter_value[NUM_MONITOR]
The actual monitor counter array that records each monitor counter value.
Definition: srv0mon.cc:1429
void monitor_dec_value_nocheck(monitor_id_t monitor, mon_type_t value)
Definition: srv0mon.h:749
static void srv_mon_reset_all(monitor_id_t monitor)
This function resets all values of a monitor counter.
int64_t mon_type_t
Monitor counter value type.
Definition: srv0mon.h:55
monitor_type_t
Following defines are possible values for "monitor_type" field in "struct monitor_info".
Definition: srv0mon.h:90
@ MONITOR_NO_AVERAGE
Set this status if we don't want to calculate the average value for the counter.
Definition: srv0mon.h:96
@ MONITOR_HIDDEN
Do not display this monitor in the metrics table.
Definition: srv0mon.h:109
@ MONITOR_EXISTING
The monitor carries information from an existing system status variable.
Definition: srv0mon.h:94
@ MONITOR_NONE
No monitoring.
Definition: srv0mon.h:91
@ MONITOR_GROUP_MODULE
Monitor can be turned on/off only as a module, but not individually.
Definition: srv0mon.h:102
@ MONITOR_SET_OWNER
Owner of "monitor set", a set of monitor counters.
Definition: srv0mon.h:106
@ MONITOR_SET_MEMBER
Being part of a "monitor set".
Definition: srv0mon.h:108
@ MONITOR_MODULE
This is a monitor module type, not a counter.
Definition: srv0mon.h:92
@ MONITOR_DEFAULT_ON
Monitor will be turned on by default at server start up.
Definition: srv0mon.h:104
@ MONITOR_DISPLAY_CURRENT
Display current value of the counter, rather than incremental value over the period.
Definition: srv0mon.h:98
static mon_type_t srv_mon_calc_max_since_start(monitor_id_t monitor)
This function is used to calculate the maximum counter value since the start of monitor counter.
#define MONITOR_IS_ON(monitor)
Check whether the requested monitor is turned on/off.
Definition: srv0mon.h:591
void monitor_inc_value(monitor_id_t monitor, mon_type_t value)
Definition: srv0mon.h:742
void srv_mon_set_module_control(monitor_id_t module_id, mon_option_t set_option)
Turn on/off/reset monitor counters in a module.
Definition: srv0mon.cc:1467
#define MONITOR_MIN_VALUE(monitor)
Definition: srv0mon.h:612
#define MIN_RESERVED
Counter minimum value is initialized to be max value of mon_type_t (int64_t)
Definition: srv0mon.h:115
ulint monitor_set_tbl[(NUM_MONITOR+NUM_BITS_ULINT - 1)/NUM_BITS_ULINT]
This "monitor_set_tbl" is a bitmap records whether a particular monitor counter has been turned on or...
Definition: srv0mon.cc:1433
mon_option_t
Following are the "set_option" values allowed for srv_mon_process_existing_counter() and srv_mon_proc...
Definition: srv0mon.h:561
@ MONITOR_TURN_OFF
Turn off the counter.
Definition: srv0mon.h:563
@ MONITOR_GET_VALUE
Option for srv_mon_process_existing_counter() function.
Definition: srv0mon.h:566
@ MONITOR_RESET_VALUE
Reset current values.
Definition: srv0mon.h:564
@ MONITOR_RESET_ALL_VALUE
Reset all values.
Definition: srv0mon.h:565
@ MONITOR_TURN_ON
Turn on the counter.
Definition: srv0mon.h:562
void monitor_atomic_dec(monitor_id_t monitor)
Definition: srv0mon.h:720
void monitor_inc_time(monitor_id_t monitor, std::chrono::steady_clock::time_point value)
Definition: srv0mon.h:800
#define MONITOR_MIN_VALUE_START(monitor)
Definition: srv0mon.h:619
void monitor_atomic_inc(monitor_id_t monitor, mon_type_t inc_value)
Definition: srv0mon.h:710
void srv_mon_reset(monitor_id_t monitor)
Reset a monitor, create a new base line with the current monitor value.
Definition: srv0mon.cc:2058
void monitor_inc_value_cumulative(monitor_id_t monitor, monitor_id_t monitor_n_calls, monitor_id_t monitor_per_call, mon_type_t value)
Definition: srv0mon.h:828
void monitor_set_min_value(monitor_id_t monitor, mon_type_t value)
Definition: srv0mon.h:704
void monitor_inc_value_nocheck(monitor_id_t monitor, mon_type_t value, bool set_max=true)
Definition: srv0mon.h:729
void monitor_dec(monitor_id_t monitor)
Definition: srv0mon.h:767
#define MONITOR_VALUE_RESET(monitor)
Definition: srv0mon.h:614
const char * srv_mon_get_name(monitor_id_t monitor_id)
Get monitor's name by its monitor id (index into the innodb_counter_info array.
Definition: srv0mon.cc:1453
enum monitor_running_status monitor_running_t
Definition: srv0mon.h:52
void monitor_save_last(monitor_id_t monitor)
Definition: srv0mon.h:884
static mon_type_t srv_mon_calc_min_since_start(monitor_id_t monitor)
This function is used to calculate the minimum counter value since the start of monitor counter.
monitor_running_status
Possible status values for "mon_status" in "struct monitor_value".
Definition: srv0mon.h:47
@ MONITOR_STARTED
Monitor has been turned on.
Definition: srv0mon.h:48
@ MONITOR_STOPPED
Monitor has been turned off.
Definition: srv0mon.h:49
#define MONITOR_CHECK_DEFINED(value)
Definition: srv0mon.h:668
monitor_id_t
This enumeration defines internal monitor identifier used internally to identify each particular coun...
Definition: srv0mon.h:131
@ MONITOR_LRU_UNZIP_SEARCH_SCANNED_NUM_CALL
Definition: srv0mon.h:249
@ MONITOR_OVLD_BUF_POOL_PAGE_TOTAL
Definition: srv0mon.h:176
@ MONITOR_OS_PENDING_WRITES
Definition: srv0mon.h:298
@ MONITOR_OVLD_LSN_CURRENT
Definition: srv0mon.h:346
@ MONITOR_MODULE_ADAPTIVE_HASH
Definition: srv0mon.h:423
@ MONITOR_OVLD_OS_LOG_WRITTEN
Definition: srv0mon.h:299
@ MONITOR_LRU_UNZIP_SEARCH_SCANNED
Definition: srv0mon.h:248
@ NUM_MONITOR
Definition: srv0mon.h:532
@ MONITOR_OVLD_RWLOCK_X_SPIN_ROUNDS
Definition: srv0mon.h:467
@ MONITOR_LOG_FREE_SPACE
Definition: srv0mon.h:368
@ MONITOR_NUM_RECLOCK
Definition: srv0mon.h:156
@ MONITOR_PAD_DECREMENTS
Definition: srv0mon.h:411
@ MONITOR_INDEX_IBUF_LEAF_PAGE_READ
Definition: srv0mon.h:256
@ MONITOR_OVLD_LSN_CHECKPOINT
Definition: srv0mon.h:345
@ MONITOR_MODULE_DBLWR
Definition: srv0mon.h:521
@ MONITOR_OTHER_PAGE_WRITTEN
Definition: srv0mon.h:287
@ MONITOR_MODULE_PAGE_TRACK
Definition: srv0mon.h:515
@ MONITOR_MODULE_OS
Definition: srv0mon.h:293
@ MONITOR_LOG_CHECKPOINTS
Definition: srv0mon.h:367
@ MONITOR_ZBLOB2_PAGE_WRITTEN
Definition: srv0mon.h:285
@ MONITOR_LOG_FLUSHER_NO_WAITS
Definition: srv0mon.h:377
@ MONITOR_UNDO_TRUNCATE_MICROSECOND
Definition: srv0mon.h:340
@ MONITOR_RSEG_HISTORY_LEN
Definition: srv0mon.h:318
@ MONITOR_OVLD_LOCK_WAIT_TIME
Definition: srv0mon.h:161
@ MONITOR_INDEX_REORG_ATTEMPTS
Definition: srv0mon.h:418
@ MONITOR_OVLD_BUF_POOL_WAIT_FREE
Definition: srv0mon.h:173
@ MONITOR_FSP_HDR_PAGE_READ
Definition: srv0mon.h:264
@ MONITOR_RECLOCK_CREATED
Definition: srv0mon.h:154
@ MONITOR_DEADLOCK_FALSE_POSITIVES
Definition: srv0mon.h:145
@ MONITOR_FLUSH_BACKGROUND_TOTAL_PAGE
Definition: srv0mon.h:228
@ MONITOR_OVLD_PAGES_READ
Definition: srv0mon.h:185
@ MONITOR_TRX_ROLLBACK
Definition: srv0mon.h:310
@ MONITOR_OLVD_SYSTEM_ROW_READ
Definition: srv0mon.h:479
@ MONITOR_OVLD_BYTE_WRITTEN
Definition: srv0mon.h:187
@ MONITOR_LOG_WRITE_NOTIFIER_NO_WAITS
Definition: srv0mon.h:381
@ MONITOR_CPU_N
Definition: srv0mon.h:513
@ MONITOR_DBLWR_SYNC_REQUESTS
Definition: srv0mon.h:523
@ MONITOR_FLUSH_AVG_TIME
Definition: srv0mon.h:208
@ MONITOR_DEADLOCK_ROUNDS
Definition: srv0mon.h:146
@ MONITOR_LOG_ON_RECENT_CLOSED_WAIT_LOOPS
Definition: srv0mon.h:398
@ MONITOR_ICP_NO_MATCH
Definition: srv0mon.h:499
@ MONITOR_OTHER_PAGE_READ
Definition: srv0mon.h:270
@ MONITOR_LRU_BATCH_FLUSH_AVG_PASS
Definition: srv0mon.h:211
@ MONITOR_FLUSH_BATCH_SCANNED
Definition: srv0mon.h:188
@ MONITOR_TABLELOCK_REMOVED
Definition: srv0mon.h:158
@ MONITOR_LOG_FLUSH_LSN_AVG_RATE
Definition: srv0mon.h:361
@ MONITOR_PAGE_DECOMPRESS
Definition: srv0mon.h:409
@ MONITOR_OVLD_IBUF_MERGE_PURGE
Definition: srv0mon.h:441
@ MONITOR_TRX_SYSTEM_PAGE_READ
Definition: srv0mon.h:263
@ MONITOR_OVLD_IBUF_MERGES
Definition: srv0mon.h:445
@ MONITOR_PAGE_TRACK_CHECKPOINT_PARTIAL_FLUSH_REQUEST
Definition: srv0mon.h:519
@ MONITOR_FLUSH_AVG_PAGE_RATE
Definition: srv0mon.h:217
@ MONITOR_INDEX_IBUF_LEAF_PAGE_WRITTEN
Definition: srv0mon.h:273
@ MONITOR_FLUSH_N_TO_FLUSH_BY_DIRTY_PAGE
Definition: srv0mon.h:198
@ MONITOR_FLUSH_PCT_FOR_LSN
Definition: srv0mon.h:220
@ MONITOR_FLUSH_N_TO_FLUSH_REQUESTED
Definition: srv0mon.h:197
@ MONITOR_FLUSH_BATCH_SCANNED_NUM_CALL
Definition: srv0mon.h:189
@ MONITOR_INDEX_NON_LEAF_PAGE_READ
Definition: srv0mon.h:255
@ MONITOR_LRU_GET_FREE_WAITS
Definition: srv0mon.h:215
@ MONITOR_FLUSH_ADAPTIVE_TOTAL_PAGE
Definition: srv0mon.h:222
@ MONITOR_LOG_FLUSHER_WAITS
Definition: srv0mon.h:378
@ MONITOR_FLUSH_N_TO_FLUSH_BY_AGE
Definition: srv0mon.h:200
@ MONITOR_ALTER_TABLE_SORT_FILES
Definition: srv0mon.h:494
@ MONITOR_ZBLOB_PAGE_READ
Definition: srv0mon.h:267
@ MONITOR_SAMPLED_PAGES_SKIPPED
Definition: srv0mon.h:487
@ MONITOR_FLUSH_SYNC_PAGES
Definition: srv0mon.h:227
@ MONITOR_OVLD_OS_FILE_WRITE
Definition: srv0mon.h:295
@ MONITOR_PAGE_TRACK_RESETS
Definition: srv0mon.h:516
@ MONITOR_LOCKREC_WAIT
Definition: srv0mon.h:149
@ MONITOR_CPU_UTIME_ABS
Definition: srv0mon.h:509
@ MONITOR_RECLOCK_GRANT_ATTEMPTS
Definition: srv0mon.h:153
@ MONITOR_CPU_UTIME_PCT
Definition: srv0mon.h:511
@ MONITOR_OVLD_RWLOCK_S_SPIN_ROUNDS
Definition: srv0mon.h:466
@ MONITOR_UNDO_TRUNCATE
Definition: srv0mon.h:336
@ MONITOR_PURGE_STOP_COUNT
Definition: srv0mon.h:330
@ MONITOR_OVLD_BUF_POOL_READ_REQUESTS
Definition: srv0mon.h:171
@ MONITOR_OVLD_BUF_POOL_PAGES_FREE
Definition: srv0mon.h:182
@ MONITOR_INDEX_SPLIT
Definition: srv0mon.h:415
@ MONITOR_LRU_SINGLE_FLUSH_FAILURE_COUNT
Definition: srv0mon.h:243
@ MONITOR_UNDO_LOG_PAGE_WRITTEN
Definition: srv0mon.h:275
@ MONITOR_FLUSH_BATCH_PAGES
Definition: srv0mon.h:193
@ MONITOR_ALTER_TABLE_LOG_FILES
Definition: srv0mon.h:495
@ MONITOR_FLUSH_SYNC_TOTAL_PAGE
Definition: srv0mon.h:225
@ MONITOR_SCHEDULE_REFRESHES
Definition: srv0mon.h:165
@ MONITOR_TRX_ROLLBACK_SAVEPOINT
Definition: srv0mon.h:311
@ MONITOR_PAD_INCREMENTS
Definition: srv0mon.h:410
@ MONITOR_OVLD_MAX_AGE_SYNC
Definition: srv0mon.h:353
@ MONITOR_OVLD_BUF_OLDEST_LSN_APPROX
Definition: srv0mon.h:350
@ MONITOR_TRX_ACTIVE
Definition: srv0mon.h:313
@ MONITOR_ADAPTIVE_HASH_PAGE_ADDED
Definition: srv0mon.h:426
@ MONITOR_TABLELOCK_CREATED
Definition: srv0mon.h:157
@ MONITOR_DEADLOCK
Definition: srv0mon.h:144
@ MONITOR_ZBLOB2_PAGE_READ
Definition: srv0mon.h:268
@ MONITOR_MODULE_BUF_PAGE
Definition: srv0mon.h:253
@ MONITOR_INDEX_IBUF_NON_LEAF_PAGE_READ
Definition: srv0mon.h:257
@ MONITOR_OVLD_BUF_POOL_BYTES_DIRTY
Definition: srv0mon.h:181
@ MONITOR_LOG_ON_FLUSH_NO_WAITS
Definition: srv0mon.h:394
@ MONITOR_NUM_TABLELOCK
Definition: srv0mon.h:159
@ MONITOR_LOG_ON_FLUSH_WAIT_LOOPS
Definition: srv0mon.h:396
@ MONITOR_PURGE_TRUNCATE_HISTORY_MICROSECOND
Definition: srv0mon.h:333
@ MONITOR_INDEX_MERGE_ATTEMPTS
Definition: srv0mon.h:416
@ MONITOR_ICP_ATTEMPTS
Definition: srv0mon.h:498
@ MONITOR_INDEX_LEAF_PAGE_WRITTEN
Definition: srv0mon.h:271
@ MONITOR_DBLWR_FLUSH_WAIT_EVENTS
Definition: srv0mon.h:525
@ MONITOR_FLUSH_ADAPTIVE_AVG_PASS
Definition: srv0mon.h:210
@ MONITOR_MASTER_THREAD_SLEEP
Definition: srv0mon.h:450
@ MONITOR_LOG_WRITER_ON_FREE_SPACE_WAITS
Definition: srv0mon.h:374
@ MONITOR_ADAPTIVE_HASH_ROW_ADDED
Definition: srv0mon.h:428
@ MONITOR_SRV_PURGE_MICROSECOND
Definition: srv0mon.h:457
@ MONITOR_SRV_DICT_LRU_EVICT_COUNT
Definition: srv0mon.h:459
@ MONITOR_OVLD_OS_LOG_PENDING_FSYNC
Definition: srv0mon.h:301
@ MONITOR_OVLD_LOG_WAITS
Definition: srv0mon.h:354
@ MONITOR_INDEX_NON_LEAF_PAGE_WRITTEN
Definition: srv0mon.h:272
@ MONITOR_OVLD_ADAPTIVE_HASH_SEARCH_BTREE
Definition: srv0mon.h:425
@ MONITOR_LRU_BATCH_SCANNED_PER_CALL
Definition: srv0mon.h:233
@ MONITOR_INDEX_DISCARD
Definition: srv0mon.h:420
@ MONITOR_IBUF_BITMAP_PAGE_WRITTEN
Definition: srv0mon.h:278
@ MONITOR_SRV_MEM_VALIDATE_MICROSECOND
Definition: srv0mon.h:456
@ MONITOR_LOG_FLUSH_MAX_TIME
Definition: srv0mon.h:359
@ MONITOR_LOG_FLUSHER_WAIT_LOOPS
Definition: srv0mon.h:379
@ MONITOR_OVLD_RWLOCK_SX_OS_WAITS
Definition: srv0mon.h:471
@ MONITOR_OVLD_LSN_CHECKPOINT_AGE
Definition: srv0mon.h:348
@ MONITOR_TABLE_REFERENCE
Definition: srv0mon.h:140
@ MONITOR_PAGE_TRACK_FULL_BLOCK_WRITES
Definition: srv0mon.h:518
@ MONITOR_FLUSH_ADAPTIVE_PAGES
Definition: srv0mon.h:224
@ MONITOR_TRX_NL_RO_COMMIT
Definition: srv0mon.h:308
@ MONITOR_OVLD_BUF_POOL_WRITE_REQUEST
Definition: srv0mon.h:172
@ MONITOR_LOG_WRITE_TO_FILE_REQUESTS_INTERVAL
Definition: srv0mon.h:389
@ MONITOR_OVLD_BUFFER_POOL_SIZE
Definition: srv0mon.h:169
@ MONITOR_LOG_PARTIAL_BLOCK_WRITES
Definition: srv0mon.h:364
@ MONITOR_LOG_FLUSH_NOTIFIER_NO_WAITS
Definition: srv0mon.h:385
@ MONITOR_LOG_FLUSH_TOTAL_TIME
Definition: srv0mon.h:358
@ MONITOR_FLUSH_SYNC_COUNT
Definition: srv0mon.h:226
@ MONITOR_TABLELOCK_WAIT
Definition: srv0mon.h:150
@ MONITOR_FLUSH_LSN_AVG_RATE
Definition: srv0mon.h:218
@ MONITOR_MODULE_BUFFER
Definition: srv0mon.h:168
@ MONITOR_OVLD_PAGE_CREATED
Definition: srv0mon.h:183
@ MONITOR_FLUSH_BATCH_TOTAL_PAGE
Definition: srv0mon.h:191
@ MONITOR_MODULE_TRX
Definition: srv0mon.h:305
@ MONITOR_TRX_SYSTEM_PAGE_WRITTEN
Definition: srv0mon.h:280
@ MONITOR_ADAPTIVE_HASH_ROW_REMOVED
Definition: srv0mon.h:429
@ MONITOR_OVLD_RWLOCK_S_OS_WAITS
Definition: srv0mon.h:469
@ MONITOR_LRU_GET_FREE_LOOPS
Definition: srv0mon.h:214
@ MONITOR_FLUSH_BATCH_SCANNED_PER_CALL
Definition: srv0mon.h:190
@ MONITOR_RECLOCK_RELEASE_ATTEMPTS
Definition: srv0mon.h:152
@ MONITOR_FLUSH_BACKGROUND_PAGES
Definition: srv0mon.h:230
@ MONITOR_MODULE_LOCK
Definition: srv0mon.h:143
@ MONITOR_FLUSH_SYNC_WAITS
Definition: srv0mon.h:221
@ MONITOR_OVLD_ROW_LOCK_WAIT
Definition: srv0mon.h:163
@ MONITOR_INODE_PAGE_WRITTEN
Definition: srv0mon.h:276
@ MONITOR_MODULE_LATCHES
Definition: srv0mon.h:504
@ MONITOR_RECLOCK_REMOVED
Definition: srv0mon.h:155
@ MONITOR_FLUSH_NEIGHBOR_COUNT
Definition: srv0mon.h:195
@ MONITOR_MASTER_IDLE_LOOPS
Definition: srv0mon.h:453
@ MONITOR_MODULE_INDEX
Definition: srv0mon.h:414
@ MONITOR_ICP_OUT_OF_RANGE
Definition: srv0mon.h:500
@ MONITOR_OVLD_LSN_FLUSHDISK
Definition: srv0mon.h:344
@ MONITOR_LOG_ON_WRITE_WAIT_LOOPS
Definition: srv0mon.h:393
@ MONITOR_OVLD_RWLOCK_X_SPIN_WAITS
Definition: srv0mon.h:464
@ MONITOR_BACKGROUND_DROP_TABLE
Definition: srv0mon.h:491
@ MONITOR_OVLD_RWLOCK_SX_SPIN_WAITS
Definition: srv0mon.h:465
@ MONITOR_LRU_BATCH_SCANNED
Definition: srv0mon.h:231
@ MONITOR_OVLD_SERVER_ACTIVITY
Definition: srv0mon.h:451
@ MONITOR_TRX_ROLLBACK_ACTIVE
Definition: srv0mon.h:312
@ MONITOR_OVLD_LOG_WRITES
Definition: srv0mon.h:356
@ MONITOR_UNDO_TRUNCATE_DONE_LOGGING_COUNT
Definition: srv0mon.h:339
@ MONITOR_LOG_ON_WRITE_WAITS
Definition: srv0mon.h:392
@ MONITOR_UNDO_TRUNCATE_COUNT
Definition: srv0mon.h:337
@ MONITOR_OVLD_BUF_POOL_READ_AHEAD
Definition: srv0mon.h:174
@ MONITOR_SYSTEM_PAGE_READ
Definition: srv0mon.h:262
@ MONITOR_SRV_BACKGROUND_DROP_TABLE_MICROSECOND
Definition: srv0mon.h:454
@ MONITOR_OVLD_PAGES_WRITTEN
Definition: srv0mon.h:184
@ MONITOR_ICP_MATCH
Definition: srv0mon.h:501
@ MONITOR_OVLD_ADAPTIVE_HASH_SEARCH
Definition: srv0mon.h:424
@ MONITOR_FLUSH_ADAPTIVE_AVG_TIME_EST
Definition: srv0mon.h:206
@ MONITOR_IBUF_FREELIST_PAGE_READ
Definition: srv0mon.h:260
@ MONITOR_LOG_FLUSH_AVG_TIME
Definition: srv0mon.h:360
@ MONITOR_OVLD_RWLOCK_S_SPIN_WAITS
Definition: srv0mon.h:463
@ MONITOR_CPU_STIME_ABS
Definition: srv0mon.h:510
@ MONITOR_OLVD_SYSTEM_ROW_DELETED
Definition: srv0mon.h:481
@ MONITOR_RSEG_CUR_SIZE
Definition: srv0mon.h:321
@ MONITOR_OVLD_LOCK_MAX_WAIT_TIME
Definition: srv0mon.h:162
@ MONITOR_LOG_FULL_BLOCK_WRITES
Definition: srv0mon.h:363
@ MONITOR_FLUSH_ADAPTIVE_AVG_TIME_SLOT
Definition: srv0mon.h:201
@ MONITOR_LRU_SINGLE_FLUSH_SCANNED
Definition: srv0mon.h:240
@ MONITOR_OLVD_SYSTEM_ROW_INSERTED
Definition: srv0mon.h:480
@ MONITOR_BLOB_PAGE_READ
Definition: srv0mon.h:266
@ MONITOR_LOG_ON_BUFFER_SPACE_NO_WAITS
Definition: srv0mon.h:399
@ MONITOR_LOG_CONCURRENCY_MARGIN
Definition: srv0mon.h:369
@ MONITOR_TRX_COMMIT_UNDO
Definition: srv0mon.h:309
@ MONITOR_DML_PURGE_DELAY
Definition: srv0mon.h:329
@ MONITOR_LRU_BATCH_FLUSH_AVG_TIME_EST
Definition: srv0mon.h:207
@ MONITOR_RSEG_ARRAY_PAGE_WRITTEN
Definition: srv0mon.h:286
@ MONITOR_IBUF_BITMAP_PAGE_READ
Definition: srv0mon.h:261
@ MONITOR_LOG_ON_FILE_SPACE_WAITS
Definition: srv0mon.h:403
@ MONITOR_LRU_BATCH_FLUSH_TOTAL_PAGE
Definition: srv0mon.h:234
@ MONITOR_LRU_SINGLE_FLUSH_SCANNED_PER_CALL
Definition: srv0mon.h:242
@ MONITOR_LRU_SEARCH_SCANNED
Definition: srv0mon.h:245
@ MONITOR_OVLD_RWLOCK_SX_SPIN_ROUNDS
Definition: srv0mon.h:468
@ MONITOR_OVLD_SRV_PAGE_SIZE
Definition: srv0mon.h:462
@ MONITOR_OVLD_OS_FILE_READ
Definition: srv0mon.h:294
@ MONITOR_TRX_ON_LOG_WAITS
Definition: srv0mon.h:316
@ MONITOR_UNDO_TRUNCATE_START_LOGGING_COUNT
Definition: srv0mon.h:338
@ MONITOR_LRU_BATCH_FLUSH_COUNT
Definition: srv0mon.h:235
@ MONITOR_N_DEL_ROW_PURGE
Definition: srv0mon.h:325
@ MONITOR_OVLD_LOG_WRITE_REQUEST
Definition: srv0mon.h:355
@ MONITOR_OVLD_OS_FSYNC
Definition: srv0mon.h:296
@ MONITOR_FLUSH_ADAPTIVE_AVG_TIME_THREAD
Definition: srv0mon.h:204
@ MONITOR_MODULE_REDO_LOG
Definition: srv0mon.h:343
@ MONITOR_OS_PENDING_READS
Definition: srv0mon.h:297
@ MONITOR_LOG_ON_FILE_SPACE_WAIT_LOOPS
Definition: srv0mon.h:404
@ MONITOR_OVLD_BUF_POOL_PAGES_DATA
Definition: srv0mon.h:178
@ MONITOR_OVLD_RWLOCK_X_OS_WAITS
Definition: srv0mon.h:470
@ MONITOR_FLUSH_PCT_FOR_DIRTY
Definition: srv0mon.h:219
@ MONITOR_OVLD_IBUF_MERGE_DISCARD_INSERT
Definition: srv0mon.h:442
@ MONITOR_ON_LOG_NO_WAITS_PAGE_WRITTEN
Definition: srv0mon.h:288
@ MONITOR_MODULE_IBUF_SYSTEM
Definition: srv0mon.h:438
@ MONITOR_CPU_STIME_PCT
Definition: srv0mon.h:512
@ MONITOR_TIMEOUT
Definition: srv0mon.h:148
@ MONITOR_OVLD_IBUF_MERGE_INSERT
Definition: srv0mon.h:439
@ MONITOR_MODULE_CPU
Definition: srv0mon.h:508
@ MONITOR_INDEX_IBUF_NON_LEAF_PAGE_WRITTEN
Definition: srv0mon.h:274
@ MONITOR_PURGE_TRUNCATE_HISTORY_COUNT
Definition: srv0mon.h:332
@ MONITOR_OVLD_LSN_BUF_DIRTY_PAGES_ADDED
Definition: srv0mon.h:349
@ MONITOR_OVLD_BUF_POOL_READS
Definition: srv0mon.h:170
@ MONITOR_OLVD_ROW_DELETED
Definition: srv0mon.h:477
@ MONITOR_ADAPTIVE_HASH_ROW_REMOVE_NOT_FOUND
Definition: srv0mon.h:430
@ MONITOR_LATCHES
Definition: srv0mon.h:505
@ MONITOR_NUM_UNDO_SLOT_CACHED
Definition: srv0mon.h:320
@ MONITOR_OVLD_MAX_AGE_ASYNC
Definition: srv0mon.h:352
@ MONITOR_OVLD_SRV_DBLWR_WRITES
Definition: srv0mon.h:460
@ MONITOR_DEFAULT_START
Definition: srv0mon.h:134
@ MONITOR_LOG_ON_BUFFER_SPACE_WAIT_LOOPS
Definition: srv0mon.h:401
@ MONITOR_NUM_RECLOCK_REQ
Definition: srv0mon.h:151
@ MONITOR_FLUSH_ADAPTIVE_COUNT
Definition: srv0mon.h:223
@ MONITOR_TRX_RO_COMMIT
Definition: srv0mon.h:307
@ MONITOR_MODULE_DDL_STATS
Definition: srv0mon.h:490
@ MONITOR_MASTER_ACTIVE_LOOPS
Definition: srv0mon.h:452
@ MONITOR_LRU_BATCH_SCANNED_NUM_CALL
Definition: srv0mon.h:232
@ MONITOR_LOG_NEXT_FILE
Definition: srv0mon.h:366
@ MONITOR_OLVD_ROW_UPDTATED
Definition: srv0mon.h:478
@ MONITOR_LOG_WRITER_NO_WAITS
Definition: srv0mon.h:371
@ MONITOR_BLOB_PAGE_WRITTEN
Definition: srv0mon.h:283
@ MONITOR_FLUSH_NEIGHBOR_PAGES
Definition: srv0mon.h:196
@ MONITOR_OVLD_LSN_ARCHIVED
Definition: srv0mon.h:347
@ MONITOR_MODULE_METADATA
Definition: srv0mon.h:137
@ MONITOR_OVLD_LOCK_AVG_WAIT_TIME
Definition: srv0mon.h:164
@ MONITOR_OVLD_OS_LOG_FSYNC
Definition: srv0mon.h:300
@ MONITOR_MODULE_SERVER
Definition: srv0mon.h:449
@ MONITOR_ADAPTIVE_HASH_PAGE_REMOVED
Definition: srv0mon.h:427
@ MONITOR_MODULE_PAGE
Definition: srv0mon.h:407
@ MONITOR_OVLD_BUF_OLDEST_LSN_LWM
Definition: srv0mon.h:351
@ MONITOR_RSEG_ARRAY_PAGE_READ
Definition: srv0mon.h:269
@ MONITOR_TRX_ALLOCATIONS
Definition: srv0mon.h:314
@ MONITOR_OVLD_OS_LOG_PENDING_WRITES
Definition: srv0mon.h:302
@ MONITOR_LOG_FLUSH_NOTIFIER_WAITS
Definition: srv0mon.h:386
@ MONITOR_OVLD_SRV_DBLWR_PAGES_WRITTEN
Definition: srv0mon.h:461
@ MONITOR_LRU_BATCH_FLUSH_AVG_TIME_THREAD
Definition: srv0mon.h:205
@ MONITOR_LRU_UNZIP_SEARCH_SCANNED_PER_CALL
Definition: srv0mon.h:250
@ MONITOR_LRU_BATCH_EVICT_PAGES
Definition: srv0mon.h:239
@ MONITOR_LOG_WRITER_ON_ARCHIVER_WAITS
Definition: srv0mon.h:375
@ MONITOR_OLVD_SYSTEM_ROW_UPDATED
Definition: srv0mon.h:482
@ MONITOR_XDES_PAGE_WRITTEN
Definition: srv0mon.h:282
@ MONITOR_MODULE_SAMPLING_STATS
Definition: srv0mon.h:485
@ MONITOR_FLUSH_AVG_PASS
Definition: srv0mon.h:212
@ MONITOR_PAGE_TRACK_PARTIAL_BLOCK_WRITES
Definition: srv0mon.h:517
@ MONITOR_LRU_SEARCH_SCANNED_NUM_CALL
Definition: srv0mon.h:246
@ MONITOR_NUM_UNDO_SLOT_USED
Definition: srv0mon.h:319
@ MONITOR_LOG_ON_BUFFER_SPACE_WAITS
Definition: srv0mon.h:400
@ MONITOR_OVLD_BUF_POOL_READ_AHEAD_EVICTED
Definition: srv0mon.h:175
@ MONITOR_MODULE_ICP
Definition: srv0mon.h:497
@ MONITOR_ON_LOG_WAITS_PAGE_WRITTEN
Definition: srv0mon.h:289
@ MONITOR_INDEX_REORG_SUCCESSFUL
Definition: srv0mon.h:419
@ MONITOR_LOG_WRITE_NOTIFIER_WAIT_LOOPS
Definition: srv0mon.h:383
@ MONITOR_OVLD_N_FILE_OPENED
Definition: srv0mon.h:435
@ MONITOR_PURGE_INVOKED
Definition: srv0mon.h:327
@ MONITOR_FLUSH_NEIGHBOR_TOTAL_PAGE
Definition: srv0mon.h:194
@ MONITOR_OVLD_IBUF_MERGE_DISCARD_PURGE
Definition: srv0mon.h:444
@ MONITOR_OVLD_ROW_LOCK_CURRENT_WAIT
Definition: srv0mon.h:160
@ MONITOR_LRU_GET_FREE_SEARCH
Definition: srv0mon.h:244
@ MONITOR_ON_LOG_WAIT_LOOPS_PAGE_WRITTEN
Definition: srv0mon.h:290
@ MONITOR_ADAPTIVE_HASH_ROW_UPDATED
Definition: srv0mon.h:431
@ MONITOR_LOG_ON_FILE_SPACE_NO_WAITS
Definition: srv0mon.h:402
@ MONITOR_TRX_RW_COMMIT
Definition: srv0mon.h:306
@ MONITOR_INODE_PAGE_READ
Definition: srv0mon.h:259
@ MONITOR_SRV_IBUF_MERGE_MICROSECOND
Definition: srv0mon.h:455
@ MONITOR_LRU_BATCH_FLUSH_AVG_TIME_SLOT
Definition: srv0mon.h:202
@ MONITOR_DBLWR_ASYNC_REQUESTS
Definition: srv0mon.h:522
@ MONITOR_LOG_ON_WRITE_NO_WAITS
Definition: srv0mon.h:391
@ MONITOR_LOG_ON_RECENT_WRITTEN_WAIT_LOOPS
Definition: srv0mon.h:397
@ MONITOR_PURGE_N_PAGE_HANDLED
Definition: srv0mon.h:328
@ MONITOR_TABLE_CLOSE
Definition: srv0mon.h:139
@ MONITOR_LOCK_THREADS_WAITING
Definition: srv0mon.h:147
@ MONITOR_FLUSH_BACKGROUND_COUNT
Definition: srv0mon.h:229
@ MONITOR_INDEX_MERGE_SUCCESSFUL
Definition: srv0mon.h:417
@ MONITOR_ZBLOB_PAGE_WRITTEN
Definition: srv0mon.h:284
@ MONITOR_LRU_BATCH_FLUSH_PAGES
Definition: srv0mon.h:236
@ MONITOR_XDES_PAGE_READ
Definition: srv0mon.h:265
@ MONITOR_OVLD_IBUF_MERGE_DELETE
Definition: srv0mon.h:440
@ MONITOR_OVLD_BUF_POOL_BYTES_DATA
Definition: srv0mon.h:179
@ MONITOR_LRU_SINGLE_FLUSH_SCANNED_NUM_CALL
Definition: srv0mon.h:241
@ MONITOR_TABLE_OPEN
Definition: srv0mon.h:138
@ MONITOR_MODULE_DML_STATS
Definition: srv0mon.h:474
@ MONITOR_DBLWR_FLUSH_REQUESTS
Definition: srv0mon.h:524
@ MONITOR_OLVD_ROW_READ
Definition: srv0mon.h:475
@ MONITOR_PENDING_ALTER_TABLE
Definition: srv0mon.h:493
@ MONITOR_LRU_SEARCH_SCANNED_PER_CALL
Definition: srv0mon.h:247
@ MONITOR_MODULE_PURGE
Definition: srv0mon.h:324
@ MONITOR_SRV_DICT_LRU_MICROSECOND
Definition: srv0mon.h:458
@ MONITOR_ONLINE_CREATE_INDEX
Definition: srv0mon.h:492
@ MONITOR_OVLD_IBUF_SIZE
Definition: srv0mon.h:446
@ MONITOR_MODULE_FIL_SYSTEM
Definition: srv0mon.h:434
@ MONITOR_INDEX_LEAF_PAGE_READ
Definition: srv0mon.h:254
@ MONITOR_PAGE_COMPRESS
Definition: srv0mon.h:408
@ MONITOR_OVLD_IBUF_MERGE_DISCARD_DELETE
Definition: srv0mon.h:443
@ MONITOR_PURGE_RESUME_COUNT
Definition: srv0mon.h:331
@ MONITOR_LRU_BATCH_EVICT_TOTAL_PAGE
Definition: srv0mon.h:237
@ MONITOR_TRX_ON_LOG_WAIT_LOOPS
Definition: srv0mon.h:317
@ MONITOR_LRU_BATCH_EVICT_COUNT
Definition: srv0mon.h:238
@ MONITOR_FSP_HDR_PAGE_WRITTEN
Definition: srv0mon.h:281
@ MONITOR_OVLD_BUF_POOL_PAGES_DIRTY
Definition: srv0mon.h:180
@ MONITOR_IBUF_FREELIST_PAGE_WRITTEN
Definition: srv0mon.h:277
@ MONITOR_ALL_COUNTER
Definition: srv0mon.h:529
@ MONITOR_SYSTEM_PAGE_WRITTEN
Definition: srv0mon.h:279
@ MONITOR_OLVD_ROW_INSERTED
Definition: srv0mon.h:476
@ MONITOR_OVLD_BUF_POOL_PAGE_MISC
Definition: srv0mon.h:177
@ MONITOR_LOG_PADDED
Definition: srv0mon.h:365
@ MONITOR_N_UPD_EXIST_EXTERN
Definition: srv0mon.h:326
@ MONITOR_SAMPLED_PAGES_READ
Definition: srv0mon.h:486
@ MONITOR_UNDO_LOG_PAGE_READ
Definition: srv0mon.h:258
@ MONITOR_LOG_ON_FLUSH_WAITS
Definition: srv0mon.h:395
@ MONITOR_FLUSH_BATCH_COUNT
Definition: srv0mon.h:192
@ MONITOR_LOG_WRITER_WAITS
Definition: srv0mon.h:372
@ MONITOR_LOG_WRITE_NOTIFIER_WAITS
Definition: srv0mon.h:382
@ MONITOR_OVLD_BYTE_READ
Definition: srv0mon.h:186
@ MONITOR_LOG_FLUSH_NOTIFIER_WAIT_LOOPS
Definition: srv0mon.h:387
@ MONITOR_LOG_WRITER_WAIT_LOOPS
Definition: srv0mon.h:373
@ MONITOR_TRX_ON_LOG_NO_WAITS
Definition: srv0mon.h:315
#define MONITOR_VALUE(monitor)
Definition: srv0mon.h:608
#define MAX_RESERVED
Definition: srv0mon.h:116
#define MONITOR_MAX_VALUE_START(monitor)
Definition: srv0mon.h:616
void monitor_set(monitor_id_t monitor, mon_type_t value, bool set_max, bool set_min)
Sets a value to the monitor counter.
Definition: srv0mon.h:781
#define MONITOR_INIT_ZERO_VALUE
Definition: srv0mon.h:645
#define MONITOR_FIELD(monitor, field)
Following are macro defines for basic monitor counter manipulations.
Definition: srv0mon.h:606
#define MONITOR_LAST_VALUE(monitor)
Definition: srv0mon.h:622
void srv_mon_default_on(void)
Turn on monitor counters that are marked as default ON.
Definition: srv0mon.cc:2100
#define MONITOR_START_VALUE(monitor)
Definition: srv0mon.h:624
void monitor_set_max_value(monitor_id_t monitor, mon_type_t value)
Definition: srv0mon.h:698
void monitor_reset_all(monitor_id_t monitor)
Definition: srv0mon.h:854
void monitor_dec_value(monitor_id_t monitor, mon_type_t value)
Definition: srv0mon.h:759
monitor_info_t * srv_mon_get_info(monitor_id_t monitor_id)
Get monitor's monitor_info_t by its monitor id (index into the innodb_counter_info array.
Definition: srv0mon.cc:1439
void srv_mon_process_existing_counter(monitor_id_t monitor_id, mon_option_t set_option)
This function consolidates some existing server counters used by "system status variables".
Definition: srv0mon.cc:1604
#define NUM_BITS_ULINT
Number of bit in a ulint datatype.
Definition: srv0mon.h:573
Server monitoring system.
struct monitor_info describes the basic/static information about each monitor counter.
Definition: srv0mon.h:544
const char * monitor_module
Sub Module the monitor belongs to.
Definition: srv0mon.h:546
const char * monitor_name
Monitor name.
Definition: srv0mon.h:545
monitor_id_t monitor_id
Monitor ID as defined in enum monitor_id_t.
Definition: srv0mon.h:554
const char * monitor_desc
Brief desc of monitor counter.
Definition: srv0mon.h:548
monitor_id_t monitor_related_id
Monitor ID of counter that related to this monitor.
Definition: srv0mon.h:550
monitor_type_t monitor_type
Type of Monitor Info.
Definition: srv0mon.h:549
Two monitor structures are defined in this file.
Definition: srv0mon.h:70
std::chrono::system_clock::time_point mon_stop_time
Stop time of monitoring.
Definition: srv0mon.h:74
mon_type_t mon_max_value
Current Max value.
Definition: srv0mon.h:78
std::chrono::system_clock::time_point mon_reset_time
Time counter was reset.
Definition: srv0mon.h:76
mon_type_t mon_value_reset
value at last reset
Definition: srv0mon.h:80
mon_type_t mon_min_value_start
Min value since start.
Definition: srv0mon.h:82
mon_type_t mon_start_value
Value at the start time.
Definition: srv0mon.h:83
std::atomic< mon_type_t > mon_value
Current counter Value.
Definition: srv0mon.h:77
std::chrono::system_clock::time_point mon_start_time
Start time of monitoring
Definition: srv0mon.h:72
mon_type_t mon_last_value
Last set of values.
Definition: srv0mon.h:84
mon_type_t mon_max_value_start
Max value since start.
Definition: srv0mon.h:81
mon_type_t mon_min_value
Current Min value.
Definition: srv0mon.h:79
monitor_running_t mon_status
Definition: srv0mon.h:85
Version control for database, common definitions, and include files.
unsigned long int ulint
Definition: univ.i:407
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:68