21.4. Performance Schema Instrument Naming Conventions

An instrument name consists of a sequence of components separated by '/' characters. Example names:

wait/io/file/myisam/logwait/io/file/mysys/charsetwait/lock/table/sql/handlerwait/synch/cond/mysys/COND_alarmwait/synch/cond/sql/BINLOG::update_condwait/synch/mutex/mysys/BITMAP_mutexwait/synch/mutex/sql/LOCK_deletewait/synch/rwlock/sql/Query_cache_query::lockstage/sql/closing tablesstage/sql/Sorting resultstatement/com/Executestatement/com/Querystatement/sql/create_tablestatement/sql/lock_tables

The instrument name space has a tree-like structure. The components of an instrument name from left to right provide a progression from more general to more specific. The number of components a name has depends on the type of instrument.

The interpretation of a given component in a name depends on the components to the left of it. For example, myisam appears in both of the following names, but myisam in the first name is related to file I/O, whereas in the second it is related to a synchronization instrument:

wait/io/file/myisam/logwait/synch/cond/myisam/MI_SORT_INFO::cond

Instrument names consist of a prefix with a structure defined by the Performance Schema implementation and a suffix defined by the developer implementing the instrument code. The top-level component of an instrument prefix indicates the type of instrument. This component also determines which event timer in the setup_timers table applies to the instrument. For the prefix part of instrument names, the top level indicates the type of instrument.

The suffix part of instrument names comes from the code for the instruments themselves. Suffixes may include levels such as these:

A name for the major component (a server module such as myisam, innodb, mysys, or sql) or a plugin name.
The name of a variable in the code, in the form XXX (a global variable) or CCC::MMM (a member MMM in class CCC). Examples: COND_thread_cache, THR_LOCK_myisam, BINLOG::LOCK_index.

Top-Level Instrument Components

idle: An instrumented idle event. This instrument has no further components.
stage: An instrumented stage event.
statement: An instrumented statement event.
wait: An instrumented wait event.

Idle Instrument Components

idle

The idle instrument. The Performance Schema generates idle events as discussed in the description of the socket_instances.STATE column in Section 21.9.2.5, "The socket_instances Table".

Stage Instrument Components

Stage instruments have names of the form stage/code_area/stage_name, where code_area is a value such as sql or myisam, and stage_name indicates the stage of statement processing, such as Sorting result or Sending data. Stages correspond to the thread states displayed by SHOW PROCESSLIST or that are visible in the INFORMATION_SCHEMA.PROCESSLIST table.

Statement Instrument Components

statement/com: An instrumented command operation. These have names corresponding to COM_xxx operations (see the mysql_com.h header file and sql/sql_parse.cc. For example, the statement/com/Connect and statement/com/Fetch instruments correspond to the COM_CONNECT and COM_FETCH commands.
statement/sql: An instrumented SQL statement operation. For example, the statement/sql/create_db and statement/sql/select instruments are used for CREATE DATABASE and SELECT statements.

Wait Instrument Components

wait/io

An instrumented I/O operation.
- wait/io/file
  
  An instrumented file I/O operation. For files, the wait is the time waiting for the file operation to complete (for example, a call to fwrite()). Due to caching, the physical file I/O on the disk might not happen within this call.
- wait/io/socket
  
  An instrumented socket operation. Socket instruments have names of the form wait/io/socket/sql/socket_type. The server has a listening socket for each network protocol that it supports. The instruments associated with listening sockets for TCP/IP or Unix socket file connections have a socket_type value of server_tcpip_socket or server_unix_socket, respectively. When a listening socket detects a connection, the server transfers the connection to a new socket managed by a separate thread. The instrument for the new connection thread has a socket_type value of client_connection.
- wait/io/table
  
  An instrumented table I/O operation. These include row-level accesses to persistent base tables or temporary tables. Operations that affect rows are fetch, insert, update, and delete. For a view, waits are associated with base tables referenced by the view.
  
  Unlike most waits, a table I/O wait can include other waits. For example, table I/O might include file I/O or memory operations. Thus, events_waits_current for a table I/O wait usually has two rows. For more information, see Section 21.6, "Performance Schema Atom and Molecule Events".
  
  Some row operations might cause multiple table I/O waits. For example, an insert might activate a trigger that causes an update.
wait/lock

An instrumented lock operation.
- wait/lock/table
  
  An instrumented table lock operation.
wait/synch

An instrumented synchronization object. For synchronization objects, the TIMER_WAIT time includes the amount of time blocked while attempting to acquire a lock on the object, if any.
- wait/synch/cond
  
  A condition is used by one thread to signal to other threads that something they were waiting for has happened. If a single thread was waiting for a condition, it can wake up and proceed with its execution. If several threads were waiting, they can all wake up and compete for the resource for which they were waiting.
- wait/synch/mutex
  
  A mutual exclusion object used to permit access to a resource (such as a section of executable code) while preventing other threads from accessing the resource.
- wait/synch/rwlock
  
  A read/write lock object used to lock a specific variable for access while preventing its use by other threads. A shared read lock can be acquired simultaneously by multiple threads. An exclusive write lock can be acquired by only one thread at a time.