srv0srv.h

Go to the documentation of this file.

/*****************************************************************************
 
Copyright (c) 1995, 2025, Oracle and/or its affiliates.
Copyright (c) 2008, 2009, Google Inc.
Copyright (c) 2009, Percona Inc.
 
Portions of this file contain modifications contributed and copyrighted by
Google, Inc. Those modifications are gratefully acknowledged and are described
briefly in the InnoDB documentation. The contributions by Google are
incorporated with their permission, and subject to the conditions contained in
the file COPYING.Google.
 
Portions of this file contain modifications contributed and copyrighted
by Percona Inc.. Those modifications are
gratefully acknowledged and are described briefly in the InnoDB
documentation. The contributions by Percona Inc. are incorporated with
their permission, and subject to the conditions contained in the file
COPYING.Percona.
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License, version 2.0, as published by the
Free Software Foundation.
 
This program is designed to work with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation.  The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have either included with
the program or referenced in the documentation.
 
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, version 2.0,
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 St, Fifth Floor, Boston, MA 02110-1301  USA
 
*****************************************************************************/
 
/** @file include/srv0srv.h
 The server main program
 
 Created 10/10/1995 Heikki Tuuri
 *******************************************************/
 
#ifndef srv0srv_h
#define srv0srv_h
 
#include "buf0checksum.h"
#include "fil0fil.h"
#include "mysql/psi/mysql_stage.h"
#include "univ.i"
 
#ifndef UNIV_HOTBACKUP
#include "log0ddl.h"
#include "os0event.h"
#include "os0file.h"
#include "os0thread.h"
#include "que0types.h"
#include "srv0conc.h"
#include "trx0types.h"
#include "ut0counter.h"
 
#include <cstdint>
#include <future>
 
/* Global counters used inside InnoDB. */
struct srv_stats_t {
  typedef ib_counter_t<ulint, 64> ulint_ctr_64_t;
  typedef ib_counter_t<lsn_t, 1, single_indexer_t> lsn_ctr_1_t;
  typedef ib_counter_t<ulint, 1, single_indexer_t> ulint_ctr_1_t;
  typedef ib_counter_t<lint, 1, single_indexer_t> lint_ctr_1_t;
  typedef ib_counter_t<int64_t, 1, single_indexer_t> int64_ctr_1_t;
 
  /** Count the amount of data written in total (in bytes) */
  ulint_ctr_1_t data_written;
 
  /** Number of the log write requests done */
  ulint_ctr_1_t log_write_requests;
 
  /** Number of physical writes to the log performed */
  ulint_ctr_1_t log_writes;
 
  /** Amount of data written to the log files in bytes */
  lsn_ctr_1_t os_log_written;
 
  /** Number of writes being done to the log files */
  lint_ctr_1_t os_log_pending_writes;
 
  /** We increase this counter, when we don't have enough
  space in the log buffer and have to flush it */
  ulint_ctr_1_t log_waits;
 
  /** Count the number of times the doublewrite buffer was flushed */
  ulint_ctr_1_t dblwr_writes;
 
  /** Store the number of pages that have been flushed to the
  doublewrite buffer */
  ulint_ctr_1_t dblwr_pages_written;
 
  /** Store the number of write requests issued */
  ulint_ctr_1_t buf_pool_write_requests;
 
  /** Store the number of times when we had to wait for a free page
  in the buffer pool. It happens when the buffer pool is full and we
  need to make a flush, in order to be able to read or create a page. */
  ulint_ctr_1_t buf_pool_wait_free;
 
  /** Count the number of pages that were written from buffer
  pool to the disk */
  ulint_ctr_1_t buf_pool_flushed;
 
  /** Number of buffer pool reads that led to the reading of
  a disk page */
  ulint_ctr_1_t buf_pool_reads;
 
  /** Number of data read in total (in bytes) */
  ulint_ctr_1_t data_read;
 
  /** Wait time of database locks */
  int64_ctr_1_t n_lock_wait_time;
 
  /** Number of database lock waits */
  ulint_ctr_1_t n_lock_wait_count;
 
  /** Number of threads currently waiting on database locks */
  lint_ctr_1_t n_lock_wait_current_count;
 
  /** Number of rows read. */
  ulint_ctr_64_t n_rows_read;
 
  /** Number of rows updated */
  ulint_ctr_64_t n_rows_updated;
 
  /** Number of rows deleted */
  ulint_ctr_64_t n_rows_deleted;
 
  /** Number of rows inserted */
  ulint_ctr_64_t n_rows_inserted;
 
  /** Number of system rows read. */
  ulint_ctr_64_t n_system_rows_read;
 
  /** Number of system rows updated */
  ulint_ctr_64_t n_system_rows_updated;
 
  /** Number of system rows deleted */
  ulint_ctr_64_t n_system_rows_deleted;
 
  /** Number of system rows inserted */
  ulint_ctr_64_t n_system_rows_inserted;
 
  /** Number of sampled pages read */
  ulint_ctr_64_t n_sampled_pages_read;
 
  /** Number of sampled pages skipped */
  ulint_ctr_64_t n_sampled_pages_skipped;
};
 
/** Structure which keeps shared future objects for InnoDB background
threads. One should use these objects to check if threads exited. */
struct Srv_threads {
  /** Monitor thread (prints info). */
  IB_thread m_monitor;
 
  /** Error monitor thread. */
  IB_thread m_error_monitor;
 
  /** Redo files governor thread. */
  IB_thread m_log_files_governor;
 
  /** Redo checkpointer thread. */
  IB_thread m_log_checkpointer;
 
  /** Redo writer thread. */
  IB_thread m_log_writer;
 
  /** Redo flusher thread. */
  IB_thread m_log_flusher;
 
  /** Redo write notifier thread. */
  IB_thread m_log_write_notifier;
 
  /** Redo flush notifier thread. */
  IB_thread m_log_flush_notifier;
 
  /** Redo log archiver (used by backup). */
  IB_thread m_backup_log_archiver;
 
  /** Buffer pool dump thread. */
  IB_thread m_buf_dump;
 
  /** Buffer pool resize thread. */
  IB_thread m_buf_resize;
 
  /** Dict stats background thread. */
  IB_thread m_dict_stats;
 
  /** Thread detecting lock wait timeouts. */
  IB_thread m_lock_wait_timeout;
 
  /** The master thread. */
  IB_thread m_master;
 
  /** The ts_alter_encrypt thread. */
  IB_thread m_ts_alter_encrypt;
 
  /** Thread doing rollbacks during recovery. */
  IB_thread m_trx_recovery_rollback;
 
  /** Thread writing recovered pages during recovery. */
  IB_thread m_recv_writer;
 
  /** Purge coordinator (also being a worker) */
  IB_thread m_purge_coordinator;
 
  /** Number of purge workers and size of array below. */
  size_t m_purge_workers_n;
 
  /** Purge workers. Note that the m_purge_workers[0] is the same shared
  state as m_purge_coordinator. */
  IB_thread *m_purge_workers;
 
  /** Page cleaner coordinator (also being a worker). */
  IB_thread m_page_cleaner_coordinator;
 
  /** Number of page cleaner workers and size of array below. */
  size_t m_page_cleaner_workers_n;
 
  /** Page cleaner workers. Note that m_page_cleaner_workers[0] is the
  same shared state as m_page_cleaner_coordinator. */
  IB_thread *m_page_cleaner_workers;
 
  /** Archiver's log archiver (used by Clone). */
  IB_thread m_log_archiver;
 
  /** Archiver's page archiver (used by Clone). */
  IB_thread m_page_archiver;
 
  /** Thread doing optimization for FTS index. */
  IB_thread m_fts_optimize;
 
  /** Thread for GTID persistence */
  IB_thread m_gtid_persister;
 
#ifdef UNIV_DEBUG
  /** Used in test scenario to delay threads' cleanup until the pre_dd_shutdown
  is ended and final plugin's shutdown is started (when plugin is DELETED).
  Note that you may only delay the shutdown for threads for which there is no
  waiting procedure used in the pre_dd_shutdown. */
  os_event_t m_shutdown_cleanup_dbg;
#endif /* UNIV_DEBUG */
 
  /** When the master thread notices that shutdown has started (by noticing
  srv_shutdown_state >= SRV_SHUTDOWN_PRE_DD_AND_SYSTEM_TRANSACTIONS), it exits
  its main loop. Then the master thread proceeds with actions related to tasks:
    - which it has been responsible for,
    - and which might depend on DD objects.
  After finishing them, the master thread sets this event.
  @remarks We use this event to wait in srv_pre_dd_shutdown before we enter
  next phase (SRV_SHUTDOWN_PURGE) in which master thread is not allowed to
  use system transactions or touch DD objects. */
  os_event_t m_master_ready_for_dd_shutdown;
};
 
/** Check if given thread is still active. */
bool srv_thread_is_active(const IB_thread &thread);
 
/** Check if given thread is cleaned-up and stopped. */
bool srv_thread_is_stopped(const IB_thread &thread);
 
/** Delay the thread after it discovered that the shutdown_state
is greater or equal to SRV_SHUTDOWN_CLEANUP, before it proceeds
with further clean up. This is used in the tests to see if such
a possible delay does not have impact on the clean shutdown.
@param[in]  wait_for_signal   wait until shutdown phase starts */
void srv_thread_delay_cleanup_if_needed(bool wait_for_signal);
 
struct Srv_cpu_usage {