path: root/storage/innobase/include/srv0mon.h

/***********************************************************************

Copyright (c) 2010, 2015, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2012, Facebook Inc.
Copyright (c) 2013, 2023, MariaDB Corporation.

This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA

***********************************************************************/

/**************************************************//**
@file include/srv0mon.h
Server monitor counter related defines

Created 12/15/2009	Jimmy Yang
*******************************************************/

#ifndef srv0mon_h
#define srv0mon_h

#include "univ.i"

#ifndef __STDC_LIMIT_MACROS
/* Required for FreeBSD so that INT64_MAX is defined. */
#define __STDC_LIMIT_MACROS
#endif /* __STDC_LIMIT_MACROS */

#include <cstdint>
#include "my_atomic.h"
#include "my_atomic_wrapper.h"

/** Possible status values for "mon_status" in "struct monitor_value" */
enum monitor_running_status {
	MONITOR_STARTED = 1,	/*!< Monitor has been turned on */
	MONITOR_STOPPED = 2	/*!< Monitor has been turned off */
};

typedef enum monitor_running_status	monitor_running_t;

/** Monitor counter value type */
typedef	int64_t				mon_type_t;

/** Two monitor structures are defined in this file. One is
"monitor_value_t" which contains dynamic counter values for each
counter. The other is "monitor_info_t", which contains
static information (counter name, desc etc.) for each counter.
In addition, an enum datatype "monitor_id_t" is also defined,
it identifies each monitor with an internally used symbol, whose
integer value indexes into above two structure for its dynamic
and static information.
Developer who intend to add new counters would require to
fill in counter information as described in "monitor_info_t" and
create the internal counter ID in "monitor_id_t". */

/** Structure containing the actual values of a monitor counter. */
struct monitor_value_t {
	time_t	mon_start_time;	/*!< Start time of monitoring  */
	time_t	mon_stop_time;	/*!< Stop time of monitoring */
	time_t	mon_reset_time;	/*!< Time of resetting the counter */
	mon_type_t	mon_value;	/*!< Current counter Value */
	mon_type_t	mon_max_value;	/*!< Current Max value */
	mon_type_t	mon_min_value;	/*!< Current Min value */
	mon_type_t	mon_value_reset;/*!< value at last reset */
	mon_type_t	mon_max_value_start; /*!< Max value since start */
	mon_type_t	mon_min_value_start; /*!< Min value since start */
	mon_type_t	mon_start_value;/*!< Value at the start time */
	mon_type_t	mon_last_value;	/*!< Last set of values */
	monitor_running_t mon_status;	/* whether monitor still running */
};

/** Follwoing defines are possible values for "monitor_type" field in
"struct monitor_info" */
enum monitor_type_t {
	MONITOR_NONE = 0,	/*!< No monitoring */
	MONITOR_MODULE = 1,	/*!< This is a monitor module type,
				not a counter */
	MONITOR_EXISTING = 2,	/*!< The monitor carries information from
				an existing system status variable */
	MONITOR_NO_AVERAGE = 4,	/*!< Set this status if we don't want to
				calculate the average value for the counter */
	MONITOR_DISPLAY_CURRENT = 8, /*!< Display current value of the
				counter, rather than incremental value
				over the period. Mostly for counters
				displaying current resource usage */
	MONITOR_GROUP_MODULE = 16, /*!< Monitor can be turned on/off
				only as a module, but not individually */
	MONITOR_DEFAULT_ON = 32,/*!< Monitor will be turned on by default at
				server start up */
	MONITOR_SET_OWNER = 64,	/*!< Owner of "monitor set", a set of
				monitor counters */
	MONITOR_SET_MEMBER = 128,/*!< Being part of a "monitor set" */
	MONITOR_HIDDEN = 256	/*!< Do not display this monitor in the
				metrics table */
};

/** Counter minimum value is initialized to be max value of
 mon_type_t (int64_t) */
#ifndef INT64_MAX
#define INT64_MAX		(9223372036854775807LL)
#endif
#ifndef INT64_MIN
#define INT64_MIN		(-9223372036854775807LL-1)
#endif
#define	MIN_RESERVED		INT64_MAX
#define	MAX_RESERVED		INT64_MIN

/** This enumeration defines internal monitor identifier used internally
to identify each particular counter. Its value indexes into two arrays,
one is the "innodb_counter_value" array which records actual monitor
counter values, the other is "innodb_counter_info" array which describes
each counter's basic information (name, desc etc.). A couple of
naming rules here:
1) If the monitor defines a module, it starts with MONITOR_MODULE
2) If the monitor uses exisitng counters from "status variable", its ID
name shall start with MONITOR_OVLD

Please refer to "innodb_counter_info" in srv/srv0mon.cc for detail
information for each monitor counter */

enum monitor_id_t {
	/* This is to identify the default value set by the metrics
	control global variables */
	MONITOR_DEFAULT_START = 0,

	/* Start of Metadata counter */
	MONITOR_MODULE_METADATA,
	MONITOR_TABLE_OPEN,

	/* Lock manager related counters */
	MONITOR_MODULE_LOCK,
	MONITOR_DEADLOCK,
	MONITOR_TIMEOUT,
	MONITOR_LOCKREC_WAIT,
	MONITOR_TABLELOCK_WAIT,
	MONITOR_NUM_RECLOCK_REQ,
	MONITOR_RECLOCK_CREATED,
	MONITOR_RECLOCK_REMOVED,
	MONITOR_NUM_RECLOCK,
	MONITOR_TABLELOCK_CREATED,
	MONITOR_TABLELOCK_REMOVED,
	MONITOR_NUM_TABLELOCK,
	MONITOR_OVLD_ROW_LOCK_CURRENT_WAIT,
	MONITOR_OVLD_LOCK_WAIT_TIME,
	MONITOR_OVLD_LOCK_MAX_WAIT_TIME,
	MONITOR_OVLD_ROW_LOCK_WAIT,
	MONITOR_OVLD_LOCK_AVG_WAIT_TIME,

	/* Buffer and I/O realted counters. */
	MONITOR_MODULE_BUFFER,
	MONITOR_OVLD_BUFFER_POOL_SIZE,
	MONITOR_OVLD_BUF_POOL_READS,
	MONITOR_OVLD_BUF_POOL_READ_REQUESTS,
	MONITOR_OVLD_BUF_POOL_WRITE_REQUEST,
	MONITOR_OVLD_BUF_POOL_WAIT_FREE,
	MONITOR_OVLD_BUF_POOL_READ_AHEAD,
	MONITOR_OVLD_BUF_POOL_READ_AHEAD_EVICTED,
	MONITOR_OVLD_BUF_POOL_PAGE_TOTAL,
	MONITOR_OVLD_BUF_POOL_PAGE_MISC,
	MONITOR_OVLD_BUF_POOL_PAGES_DATA,
	MONITOR_OVLD_BUF_POOL_BYTES_DATA,
	MONITOR_OVLD_BUF_POOL_PAGES_DIRTY,
	MONITOR_OVLD_BUF_POOL_BYTES_DIRTY,
	MONITOR_OVLD_BUF_POOL_PAGES_FREE,
	MONITOR_OVLD_PAGE_CREATED,
	MONITOR_OVLD_PAGES_WRITTEN,
	MONITOR_OVLD_PAGES_READ,
	MONITOR_OVLD_BYTE_READ,
	MONITOR_OVLD_BYTE_WRITTEN,
	MONITOR_FLUSH_BATCH_SCANNED,
	MONITOR_FLUSH_BATCH_SCANNED_NUM_CALL,
	MONITOR_FLUSH_BATCH_SCANNED_PER_CALL,
	MONITOR_FLUSH_BATCH_TOTAL_PAGE,
	MONITOR_FLUSH_BATCH_COUNT,
	MONITOR_FLUSH_BATCH_PAGES,
	MONITOR_FLUSH_NEIGHBOR_TOTAL_PAGE,
	MONITOR_FLUSH_NEIGHBOR_COUNT,
	MONITOR_FLUSH_NEIGHBOR_PAGES,
	MONITOR_FLUSH_N_TO_FLUSH_REQUESTED,

	MONITOR_FLUSH_N_TO_FLUSH_BY_AGE,
	MONITOR_FLUSH_ADAPTIVE_AVG_TIME,

	MONITOR_FLUSH_ADAPTIVE_AVG_PASS,

	MONITOR_LRU_GET_FREE_LOOPS,

	MONITOR_FLUSH_AVG_PAGE_RATE,
	MONITOR_FLUSH_LSN_AVG_RATE,
	MONITOR_FLUSH_PCT_FOR_DIRTY,
	MONITOR_FLUSH_PCT_FOR_LSN,
	MONITOR_FLUSH_SYNC_WAITS,
	MONITOR_FLUSH_ADAPTIVE_TOTAL_PAGE,
	MONITOR_FLUSH_ADAPTIVE_COUNT,
	MONITOR_FLUSH_ADAPTIVE_PAGES,
	MONITOR_FLUSH_SYNC_TOTAL_PAGE,
	MONITOR_FLUSH_SYNC_COUNT,
	MONITOR_FLUSH_SYNC_PAGES,
	MONITOR_FLUSH_BACKGROUND_TOTAL_PAGE,
	MONITOR_FLUSH_BACKGROUND_COUNT,
	MONITOR_FLUSH_BACKGROUND_PAGES,
	MONITOR_LRU_BATCH_SCANNED,
	MONITOR_LRU_BATCH_SCANNED_NUM_CALL,
	MONITOR_LRU_BATCH_SCANNED_PER_CALL,
	MONITOR_LRU_BATCH_FLUSH_TOTAL_PAGE,
	MONITOR_LRU_BATCH_EVICT_TOTAL_PAGE,
	MONITOR_LRU_GET_FREE_SEARCH,
	MONITOR_LRU_SEARCH_SCANNED,
	MONITOR_LRU_SEARCH_SCANNED_NUM_CALL,
	MONITOR_LRU_SEARCH_SCANNED_PER_CALL,
	MONITOR_LRU_UNZIP_SEARCH_SCANNED,
	MONITOR_LRU_UNZIP_SEARCH_SCANNED_NUM_CALL,
	MONITOR_LRU_UNZIP_SEARCH_SCANNED_PER_CALL,

	/* Buffer Page I/O specific counters. */
	MONITOR_MODULE_BUF_PAGE,
	MONITOR_INDEX_LEAF_PAGE_READ,
	MONITOR_INDEX_NON_LEAF_PAGE_READ,
	MONITOR_UNDO_LOG_PAGE_READ,
	MONITOR_INODE_PAGE_READ,
	MONITOR_SYSTEM_PAGE_READ,
	MONITOR_TRX_SYSTEM_PAGE_READ,
	MONITOR_FSP_HDR_PAGE_READ,
	MONITOR_XDES_PAGE_READ,
	MONITOR_BLOB_PAGE_READ,
	MONITOR_ZBLOB_PAGE_READ,
	MONITOR_ZBLOB2_PAGE_READ,
	MONITOR_OTHER_PAGE_READ,
	MONITOR_INDEX_LEAF_PAGE_WRITTEN,
	MONITOR_INDEX_NON_LEAF_PAGE_WRITTEN,
	MONITOR_UNDO_LOG_PAGE_WRITTEN,
	MONITOR_INODE_PAGE_WRITTEN,
	MONITOR_SYSTEM_PAGE_WRITTEN,
	MONITOR_TRX_SYSTEM_PAGE_WRITTEN,
	MONITOR_FSP_HDR_PAGE_WRITTEN,
	MONITOR_XDES_PAGE_WRITTEN,
	MONITOR_BLOB_PAGE_WRITTEN,
	MONITOR_ZBLOB_PAGE_WRITTEN,
	MONITOR_ZBLOB2_PAGE_WRITTEN,
	MONITOR_OTHER_PAGE_WRITTEN,

	/* OS level counters (I/O) */
	MONITOR_MODULE_OS,
	MONITOR_OVLD_OS_FILE_READ,
	MONITOR_OVLD_OS_FILE_WRITE,
	MONITOR_OVLD_OS_FSYNC,
	MONITOR_OS_PENDING_READS,
	MONITOR_OS_PENDING_WRITES,
	MONITOR_OVLD_OS_LOG_WRITTEN,

	/* Transaction related counters */
	MONITOR_MODULE_TRX,
	MONITOR_TRX_RW_COMMIT,
	MONITOR_TRX_RO_COMMIT,
	MONITOR_TRX_NL_RO_COMMIT,
	MONITOR_TRX_COMMIT_UNDO,
	MONITOR_TRX_ROLLBACK,
	MONITOR_TRX_ROLLBACK_SAVEPOINT,
	MONITOR_RSEG_HISTORY_LEN,
	MONITOR_NUM_UNDO_SLOT_USED,
	MONITOR_NUM_UNDO_SLOT_CACHED,
	MONITOR_RSEG_CUR_SIZE,

	/* Purge related counters */
	MONITOR_MODULE_PURGE,
	MONITOR_N_DEL_ROW_PURGE,
	MONITOR_N_UPD_EXIST_EXTERN,
	MONITOR_PURGE_INVOKED,
	MONITOR_PURGE_N_PAGE_HANDLED,
	MONITOR_DML_PURGE_DELAY,
	MONITOR_PURGE_STOP_COUNT,
	MONITOR_PURGE_RESUME_COUNT,

	/* Recovery related counters */
	MONITOR_MODULE_RECOVERY,
	MONITOR_OVLD_CHECKPOINTS,
	MONITOR_OVLD_LSN_FLUSHDISK,
	MONITOR_OVLD_LSN_CHECKPOINT,
	MONITOR_OVLD_LSN_CURRENT,
	MONITOR_LSN_CHECKPOINT_AGE,
	MONITOR_OVLD_BUF_OLDEST_LSN,
	MONITOR_OVLD_MAX_AGE_ASYNC,
	MONITOR_OVLD_LOG_WAITS,
	MONITOR_OVLD_LOG_WRITE_REQUEST,
	MONITOR_OVLD_LOG_WRITES,

	/* Page Manager related counters */
	MONITOR_MODULE_PAGE,
	MONITOR_PAGE_COMPRESS,
	MONITOR_PAGE_DECOMPRESS,
	MONITOR_PAD_INCREMENTS,
	MONITOR_PAD_DECREMENTS,
	/* New monitor variables for page compression */
	MONITOR_OVLD_PAGE_COMPRESS_SAVED,
	MONITOR_OVLD_PAGES_PAGE_COMPRESSED,
	MONITOR_OVLD_PAGE_COMPRESSED_TRIM_OP,
	MONITOR_OVLD_PAGES_PAGE_DECOMPRESSED,
	MONITOR_OVLD_PAGES_PAGE_COMPRESSION_ERROR,

	/* New monitor variables for page encryption */
	MONITOR_OVLD_PAGES_ENCRYPTED,
	MONITOR_OVLD_PAGES_DECRYPTED,

	/* Index related counters */
	MONITOR_MODULE_INDEX,
	MONITOR_INDEX_SPLIT,
	MONITOR_INDEX_MERGE_ATTEMPTS,
	MONITOR_INDEX_MERGE_SUCCESSFUL,
	MONITOR_INDEX_REORG_ATTEMPTS,
	MONITOR_INDEX_REORG_SUCCESSFUL,
	MONITOR_INDEX_DISCARD,

#ifdef BTR_CUR_HASH_ADAPT
	/* Adaptive Hash Index related counters */
	MONITOR_MODULE_ADAPTIVE_HASH,
	MONITOR_OVLD_ADAPTIVE_HASH_SEARCH,
	MONITOR_OVLD_ADAPTIVE_HASH_SEARCH_BTREE,
	MONITOR_ADAPTIVE_HASH_PAGE_ADDED,
	MONITOR_ADAPTIVE_HASH_PAGE_REMOVED,
	MONITOR_ADAPTIVE_HASH_ROW_ADDED,
	MONITOR_ADAPTIVE_HASH_ROW_REMOVED,
	MONITOR_ADAPTIVE_HASH_ROW_REMOVE_NOT_FOUND,
	MONITOR_ADAPTIVE_HASH_ROW_UPDATED,
#endif /* BTR_CUR_HASH_ADAPT */

	/* Tablespace related counters */
	MONITOR_MODULE_FIL_SYSTEM,
	MONITOR_OVLD_N_FILE_OPENED,

	/* Counters for server operations */
	MONITOR_MODULE_SERVER,
	MONITOR_MASTER_THREAD_SLEEP,
	MONITOR_OVLD_SERVER_ACTIVITY,
	MONITOR_MASTER_ACTIVE_LOOPS,
	MONITOR_MASTER_IDLE_LOOPS,
	MONITOR_SRV_LOG_FLUSH_MICROSECOND,
	MONITOR_SRV_DICT_LRU_MICROSECOND,
	MONITOR_SRV_DICT_LRU_EVICT_COUNT_ACTIVE,
	MONITOR_SRV_DICT_LRU_EVICT_COUNT_IDLE,
	MONITOR_OVLD_SRV_DBLWR_WRITES,
	MONITOR_OVLD_SRV_DBLWR_PAGES_WRITTEN,
	MONITOR_OVLD_SRV_PAGE_SIZE,

	/* Data DDL related counters */
	MONITOR_MODULE_DDL_STATS,
	MONITOR_BACKGROUND_DROP_INDEX,
	MONITOR_ONLINE_CREATE_INDEX,
	MONITOR_PENDING_ALTER_TABLE,
	MONITOR_ALTER_TABLE_SORT_FILES,
	MONITOR_ALTER_TABLE_LOG_FILES,

	MONITOR_MODULE_ICP,
	MONITOR_ICP_ATTEMPTS,
	MONITOR_ICP_NO_MATCH,
	MONITOR_ICP_OUT_OF_RANGE,
	MONITOR_ICP_MATCH,

	/* This is used only for control system to turn
	on/off and reset all monitor counters */
	MONITOR_ALL_COUNTER,

	/* This must be the last member */
	NUM_MONITOR
};

/** This informs the monitor control system to turn
on/off and reset monitor counters through wild card match */
#define	MONITOR_WILDCARD_MATCH		(NUM_MONITOR + 1)

/** Cannot find monitor counter with a specified name */
#define	MONITOR_NO_MATCH		(NUM_MONITOR + 2)

/** struct monitor_info describes the basic/static information
about each monitor counter. */
struct monitor_info_t {
	const char*	monitor_name;	/*!< Monitor name */
	const char*	monitor_module;	/*!< Sub Module the monitor
					belongs to */
	const char*	monitor_desc;	/*!< Brief desc of monitor counter */
	monitor_type_t	monitor_type;	/*!< Type of Monitor Info */
	monitor_id_t	monitor_related_id;/*!< Monitor ID of counter that
					related to this monitor. This is
					set when the monitor belongs to
					a "monitor set" */
	monitor_id_t	monitor_id;	/*!< Monitor ID as defined in enum
					monitor_id_t */
};

/** Following are the "set_option" values allowed for
srv_mon_process_existing_counter() and srv_mon_process_existing_counter()
functions. To turn on/off/reset the monitor counters. */
enum mon_option_t {
	MONITOR_TURN_ON = 1,		/*!< Turn on the counter */
	MONITOR_TURN_OFF,		/*!< Turn off the counter */
	MONITOR_RESET_VALUE,		/*!< Reset current values */
	MONITOR_RESET_ALL_VALUE,	/*!< Reset all values */
	MONITOR_GET_VALUE		/*!< Option for
					srv_mon_process_existing_counter()
					function */
};

/** Number of bit in a ulint datatype */
#define	NUM_BITS_ULINT	(sizeof(ulint) * CHAR_BIT)

/** This "monitor_set_tbl" is a bitmap records whether a particular monitor
counter has been turned on or off */
extern Atomic_relaxed<ulint>
    monitor_set_tbl[(NUM_MONITOR + NUM_BITS_ULINT - 1) / NUM_BITS_ULINT];

/** Macros to turn on/off the control bit in monitor_set_tbl for a monitor
counter option. */
#define MONITOR_ON(monitor)                                                   \
  (monitor_set_tbl[unsigned(monitor) / NUM_BITS_ULINT].fetch_or(              \
      (ulint(1) << (unsigned(monitor) % NUM_BITS_ULINT))))

#define MONITOR_OFF(monitor)                                                  \
  (monitor_set_tbl[unsigned(monitor) / NUM_BITS_ULINT].fetch_and(             \
      ~(ulint(1) << (unsigned(monitor) % NUM_BITS_ULINT))))

/** Check whether the requested monitor is turned on/off */
#define MONITOR_IS_ON(monitor)                                                \
  (monitor_set_tbl[unsigned(monitor) / NUM_BITS_ULINT] &                      \
   (ulint(1) << (unsigned(monitor) % NUM_BITS_ULINT)))

/** The actual monitor counter array that records each monintor counter
value */
extern monitor_value_t	 innodb_counter_value[NUM_MONITOR];

/** Following are macro defines for basic montior counter manipulations.
Please note we do not provide any synchronization for these monitor
operations due to performance consideration. Most counters can
be placed under existing mutex protections in respective code
module. */

/** Macros to access various fields of a monitor counters */
#define MONITOR_FIELD(monitor, field)			\
		(innodb_counter_value[monitor].field)

#define MONITOR_VALUE(monitor)				\
		MONITOR_FIELD(monitor, mon_value)

#define MONITOR_MAX_VALUE(monitor)			\
		MONITOR_FIELD(monitor, mon_max_value)

#define MONITOR_MIN_VALUE(monitor)			\
		MONITOR_FIELD(monitor, mon_min_value)

#define MONITOR_VALUE_RESET(monitor)			\
		MONITOR_FIELD(monitor, mon_value_reset)

#define MONITOR_MAX_VALUE_START(monitor)		\
		MONITOR_FIELD(monitor, mon_max_value_start)

#define MONITOR_MIN_VALUE_START(monitor)		\
		MONITOR_FIELD(monitor, mon_min_value_start)

#define MONITOR_LAST_VALUE(monitor)			\
		MONITOR_FIELD(monitor, mon_last_value)

#define MONITOR_START_VALUE(monitor)			\
		MONITOR_FIELD(monitor, mon_start_value)

#define MONITOR_VALUE_SINCE_START(monitor)		\
		(MONITOR_VALUE(monitor) + MONITOR_VALUE_RESET(monitor))

#define MONITOR_STATUS(monitor)				\
		MONITOR_FIELD(monitor, mon_status)

#define MONITOR_SET_START(monitor)					\
	do {								\
		MONITOR_STATUS(monitor) = MONITOR_STARTED;		\
		MONITOR_FIELD((monitor), mon_start_time) = time(NULL);	\
	} while (0)

#define MONITOR_SET_OFF(monitor)					\
	do {								\
		MONITOR_STATUS(monitor) = MONITOR_STOPPED;		\
		MONITOR_FIELD((monitor), mon_stop_time) = time(NULL);	\
	} while (0)

#define	MONITOR_INIT_ZERO_VALUE		0

/** Max and min values are initialized when we first turn on the monitor
counter, and set the MONITOR_STATUS. */
#define MONITOR_MAX_MIN_NOT_INIT(monitor)				\
		(MONITOR_STATUS(monitor) == MONITOR_INIT_ZERO_VALUE	\
		 && MONITOR_MIN_VALUE(monitor) == MONITOR_INIT_ZERO_VALUE \
		 && MONITOR_MAX_VALUE(monitor) == MONITOR_INIT_ZERO_VALUE)

#define MONITOR_INIT(monitor)						\
	if (MONITOR_MAX_MIN_NOT_INIT(monitor)) {			\
		MONITOR_MIN_VALUE(monitor) = MIN_RESERVED;		\
		MONITOR_MIN_VALUE_START(monitor) = MIN_RESERVED;	\
		MONITOR_MAX_VALUE(monitor) = MAX_RESERVED;		\
		MONITOR_MAX_VALUE_START(monitor) = MAX_RESERVED;	\
	}

/** Macros to increment/decrement the counters. The normal
monitor counter operation expects appropriate synchronization
already exists. No additional mutex is necessary when operating
on the counters */
#define	MONITOR_INC(monitor)						\
	if (MONITOR_IS_ON(monitor)) {					\
		MONITOR_VALUE(monitor)++;				\
		if (MONITOR_VALUE(monitor) > MONITOR_MAX_VALUE(monitor)) {  \
			MONITOR_MAX_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
	}

/** Atomically increment a monitor counter.
Use MONITOR_INC if appropriate mutex protection exists.
@param monitor	monitor to be incremented by 1
@param enabled	whether the monitor is enabled */
#define MONITOR_ATOMIC_INC_LOW(monitor, enabled)			\
	if (enabled) {							\
		ib_uint64_t	value;					\
		value  = my_atomic_add64_explicit(			\
			(int64*) &MONITOR_VALUE(monitor), 1,		\
			MY_MEMORY_ORDER_RELAXED) + 1;			\
		/* Note: This is not 100% accurate because of the	\
		inherent race, we ignore it due to performance. */	\
		if (value > (ib_uint64_t) MONITOR_MAX_VALUE(monitor)) {	\
			MONITOR_MAX_VALUE(monitor) = value;		\
		}							\
	}

/** Atomically decrement a monitor counter.
Use MONITOR_DEC if appropriate mutex protection exists.
@param monitor	monitor to be decremented by 1
@param enabled	whether the monitor is enabled */
#define MONITOR_ATOMIC_DEC_LOW(monitor, enabled)			\
	if (enabled) {							\
		ib_uint64_t	value;					\
		value = my_atomic_add64_explicit(			\
			(int64*) &MONITOR_VALUE(monitor), -1,		\
			MY_MEMORY_ORDER_RELAXED) - 1;			\
		/* Note: This is not 100% accurate because of the	\
		inherent race, we ignore it due to performance. */	\
		if (value < (ib_uint64_t) MONITOR_MIN_VALUE(monitor)) {	\
			MONITOR_MIN_VALUE(monitor) = value;		\
		}							\
	}

/** Atomically increment a monitor counter if it is enabled.
Use MONITOR_INC if appropriate mutex protection exists.
@param monitor	monitor to be incremented by 1 */
#define MONITOR_ATOMIC_INC(monitor)				\
	MONITOR_ATOMIC_INC_LOW(monitor, MONITOR_IS_ON(monitor))
/** Atomically decrement a monitor counter if it is enabled.
Use MONITOR_DEC if appropriate mutex protection exists.
@param monitor	monitor to be decremented by 1 */
#define MONITOR_ATOMIC_DEC(monitor)				\
	MONITOR_ATOMIC_DEC_LOW(monitor, MONITOR_IS_ON(monitor))

#define	MONITOR_DEC(monitor)						\
	if (MONITOR_IS_ON(monitor)) {					\
		MONITOR_VALUE(monitor)--;				\
		if (MONITOR_VALUE(monitor) < MONITOR_MIN_VALUE(monitor)) {  \
			MONITOR_MIN_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
	}

#ifdef HAVE_MEM_CHECK
# define MONITOR_CHECK_DEFINED(value) do {	\
    mon_type_t m __attribute__((unused))= value;        \
	MEM_CHECK_DEFINED(&m, sizeof m);	\
} while (0)
#else /* HAVE_MEM_CHECK */
# define MONITOR_CHECK_DEFINED(value) (void) 0
#endif /* HAVE_MEM_CHECK */

#define	MONITOR_INC_VALUE(monitor, value)				\
	MONITOR_CHECK_DEFINED(value);					\
	if (MONITOR_IS_ON(monitor)) {					\
		MONITOR_VALUE(monitor) += (mon_type_t) (value);		\
		if (MONITOR_VALUE(monitor) > MONITOR_MAX_VALUE(monitor)) {  \
			MONITOR_MAX_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
	}

#define	MONITOR_DEC_VALUE(monitor, value)				\
	MONITOR_CHECK_DEFINED(value);					\
	if (MONITOR_IS_ON(monitor)) {					\
		ut_ad(MONITOR_VALUE(monitor) >= (mon_type_t) (value);	\
		MONITOR_VALUE(monitor) -= (mon_type_t) (value);		\
		if (MONITOR_VALUE(monitor) < MONITOR_MIN_VALUE(monitor)) {  \
			MONITOR_MIN_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
	}

/* Increment/decrement counter without check the monitor on/off bit, which
could already be checked as a module group */
#define	MONITOR_INC_NOCHECK(monitor)					\
	do {								\
		MONITOR_VALUE(monitor)++;				\
		if (MONITOR_VALUE(monitor) > MONITOR_MAX_VALUE(monitor)) {  \
			MONITOR_MAX_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
	} while (0)							\

#define	MONITOR_DEC_NOCHECK(monitor)					\
	do {								\
		MONITOR_VALUE(monitor)--;				\
		if (MONITOR_VALUE(monitor) < MONITOR_MIN_VALUE(monitor)) {  \
			MONITOR_MIN_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
	} while (0)

/** Directly set a monitor counter's value */
#define	MONITOR_SET(monitor, value)					\
	MONITOR_CHECK_DEFINED(value);					\
	if (MONITOR_IS_ON(monitor)) {					\
		MONITOR_VALUE(monitor) = (mon_type_t) (value);		\
		if (MONITOR_VALUE(monitor) > MONITOR_MAX_VALUE(monitor)) {  \
			MONITOR_MAX_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
		if (MONITOR_VALUE(monitor) < MONITOR_MIN_VALUE(monitor)) {  \
			MONITOR_MIN_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
	}

/** Add time difference between now and input "value" (in seconds) to the
monitor counter
@param monitor monitor to update for the time difference
@param value the start time value */
#define	MONITOR_INC_TIME_IN_MICRO_SECS(monitor, value)			\
	MONITOR_CHECK_DEFINED(value);					\
	if (MONITOR_IS_ON(monitor)) {					\
		uintmax_t	old_time = value;			\
		value = microsecond_interval_timer();			\
		MONITOR_VALUE(monitor) += (mon_type_t) (value - old_time);\
	}

/** This macro updates 3 counters in one call. However, it only checks the
main/first monitor counter 'monitor', to see it is on or off to decide
whether to do the update.
@param monitor the main monitor counter to update. It accounts for
			the accumulative value for the counter.
@param monitor_n_calls counter that counts number of times this macro is
			called
@param monitor_per_call counter that records the current and max value of
			each incremental value
@param value incremental value to record this time */
#define MONITOR_INC_VALUE_CUMULATIVE(					\
		monitor, monitor_n_calls, monitor_per_call, value)	\
	MONITOR_CHECK_DEFINED(value);					\
	if (MONITOR_IS_ON(monitor)) {					\
		MONITOR_VALUE(monitor_n_calls)++;			\
		MONITOR_VALUE(monitor_per_call) = (mon_type_t) (value);	\
		if (MONITOR_VALUE(monitor_per_call)			\
		    > MONITOR_MAX_VALUE(monitor_per_call)) {		\
			MONITOR_MAX_VALUE(monitor_per_call) =		\
				 (mon_type_t) (value);			\
		}							\
		MONITOR_VALUE(monitor) += (mon_type_t) (value);		\
		if (MONITOR_VALUE(monitor) > MONITOR_MAX_VALUE(monitor)) {  \
			MONITOR_MAX_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
	}

/** Directly set a monitor counter's value, and if the value
is monotonically increasing, only max value needs to be updated */
#define	MONITOR_SET_UPD_MAX_ONLY(monitor, value)			\
	MONITOR_CHECK_DEFINED(value);					\
	if (MONITOR_IS_ON(monitor)) {					\
		MONITOR_VALUE(monitor) = (mon_type_t) (value);		\
		if (MONITOR_VALUE(monitor) > MONITOR_MAX_VALUE(monitor)) {  \
			MONITOR_MAX_VALUE(monitor) = MONITOR_VALUE(monitor);\
		}							\
	}

/** Some values such as log sequence number are montomically increasing
number, do not need to record max/min values */
#define MONITOR_SET_SIMPLE(monitor, value)				\
	MONITOR_CHECK_DEFINED(value);					\
	if (MONITOR_IS_ON(monitor)) {					\
		MONITOR_VALUE(monitor) = (mon_type_t) (value);		\
	}

/** Reset the monitor value and max/min value to zero. The reset
operation would only be conducted when the counter is turned off */
#define MONITOR_RESET_ALL(monitor)					\
	do {								\
		MONITOR_VALUE(monitor) = MONITOR_INIT_ZERO_VALUE;	\
		MONITOR_MAX_VALUE(monitor) = MAX_RESERVED;		\
		MONITOR_MIN_VALUE(monitor) = MIN_RESERVED;		\
		MONITOR_VALUE_RESET(monitor) = MONITOR_INIT_ZERO_VALUE;	\
		MONITOR_MAX_VALUE_START(monitor) = MAX_RESERVED;	\
		MONITOR_MIN_VALUE_START(monitor) = MIN_RESERVED;	\
		MONITOR_LAST_VALUE(monitor) = MONITOR_INIT_ZERO_VALUE;	\
		MONITOR_FIELD(monitor, mon_start_time) =		\
					MONITOR_INIT_ZERO_VALUE;	\
		MONITOR_FIELD(monitor, mon_stop_time) =			\
					MONITOR_INIT_ZERO_VALUE;	\
		MONITOR_FIELD(monitor, mon_reset_time) =		\
					MONITOR_INIT_ZERO_VALUE;	\
	} while (0)

/** Following four macros defines necessary operations to fetch and
consolidate information from existing system status variables. */

/** Save the passed-in value to mon_start_value field of monitor
counters */
#define MONITOR_SAVE_START(monitor, value) do {				\
	MONITOR_CHECK_DEFINED(value);					\
	(MONITOR_START_VALUE(monitor) =					\
		(mon_type_t) (value) - MONITOR_VALUE_RESET(monitor));	\
	} while (0)

/** Save the passed-in value to mon_last_value field of monitor
counters */
#define MONITOR_SAVE_LAST(monitor)					\
	do {								\
		MONITOR_LAST_VALUE(monitor) = MONITOR_VALUE(monitor);	\
		MONITOR_START_VALUE(monitor) += MONITOR_VALUE(monitor);	\
	} while (0)

/** Set monitor value to the difference of value and mon_start_value
compensated by mon_last_value if accumulated value is required. */
#define MONITOR_SET_DIFF(monitor, value)				\
	MONITOR_SET_UPD_MAX_ONLY(monitor, ((value)			\
	- MONITOR_VALUE_RESET(monitor)					\
	- MONITOR_FIELD(monitor, mon_start_value)			\
	+ MONITOR_FIELD(monitor, mon_last_value)))

/****************************************************************//**
Get monitor's monitor_info_t by its monitor id (index into the
innodb_counter_info array
@return Point to corresponding monitor_info_t, or NULL if no such
monitor */
monitor_info_t*
srv_mon_get_info(
/*=============*/
	monitor_id_t	monitor_id);	/*!< id index into the
					innodb_counter_info array */
/****************************************************************//**
Get monitor's name by its monitor id (index into the
innodb_counter_info array
@return corresponding monitor name, or NULL if no such
monitor */
const char*
srv_mon_get_name(
/*=============*/
	monitor_id_t	monitor_id);	/*!< id index into the
					innodb_counter_info array */

/****************************************************************//**
Turn on/off/reset monitor counters in a module. If module_value
is NUM_MONITOR then turn on all monitor counters.
@return 0 if successful, or the first monitor that cannot be
turned on because it is already turned on. */
void
srv_mon_set_module_control(
/*=======================*/
	monitor_id_t	module_id,	/*!< in: Module ID as in
					monitor_counter_id. If it is
					set to NUM_MONITOR, this means
					we shall turn on all the counters */
	mon_option_t	set_option);	/*!< in: Turn on/off reset the
					counter */
/****************************************************************//**
This function consolidates some existing server counters used
by "system status variables". These existing system variables do not have
mechanism to start/stop and reset the counters, so we simulate these
controls by remembering the corresponding counter values when the
corresponding monitors are turned on/off/reset, and do appropriate
mathematics to deduct the actual value. */
void
srv_mon_process_existing_counter(
/*=============================*/
	monitor_id_t	monitor_id,	/*!< in: the monitor's ID as in
					monitor_counter_id */
	mon_option_t	set_option);	/*!< in: Turn on/off reset the
					counter */
/*************************************************************//**
This function is used to calculate the maximum counter value
since the start of monitor counter
@return max counter value since start. */
UNIV_INLINE
mon_type_t
srv_mon_calc_max_since_start(
/*=========================*/
	monitor_id_t	monitor);	/*!< in: monitor id */
/*************************************************************//**
This function is used to calculate the minimum counter value
since the start of monitor counter
@return min counter value since start. */
UNIV_INLINE
mon_type_t
srv_mon_calc_min_since_start(
/*=========================*/
	monitor_id_t	monitor);	/*!< in: monitor id*/
/*************************************************************//**
Reset a monitor, create a new base line with the current monitor
value. This baseline is recorded by MONITOR_VALUE_RESET(monitor) */
void
srv_mon_reset(
/*==========*/
	monitor_id_t	monitor);	/*!< in: monitor id*/
/*************************************************************//**
This function resets all values of a monitor counter */
UNIV_INLINE
void
srv_mon_reset_all(
/*==============*/
	monitor_id_t	monitor);	/*!< in: monitor id*/
/*************************************************************//**
Turn on monitor counters that are marked as default ON. */
void
srv_mon_default_on(void);
/*====================*/

#include "srv0mon.inl"

#endif