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