An instrument name consists of a sequence of components separated
'/' characters. Example names:
wait/io/file/myisam/log wait/io/file/mysys/charset wait/lock/table/sql/handler wait/synch/cond/mysys/COND_alarm wait/synch/cond/sql/BINLOG::update_cond wait/synch/mutex/mysys/BITMAP_mutex wait/synch/mutex/sql/LOCK_delete wait/synch/rwlock/sql/Query_cache_query::lock stage/sql/closing tables stage/sql/Sorting result statement/com/Execute statement/com/Query statement/sql/create_table statement/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,
myisam in the first name is related to file
I/O, whereas in the second it is related to a synchronization
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
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
sql) or a
The name of a variable in the code, in the form
XXX (a global variable) or
MMM in class
Top-Level Instrument Components
idle: An instrumented idle event. This
instrument has no further components.
memory: An instrumented memory event.
stage: An instrumented stage event.
statement: An instrumented statement event.
transaction: An instrumented transaction
event. This instrument has no further components.
wait: An instrumented wait event.
Idle Instrument Components
The idle instrument. The Performance Schema generates idle
events as discussed in the description of the
socket_instances.STATE column in
Section 126.96.36.199, “The socket_instances Table”.
Memory Instrument Components
Memory instrumentation is disabled by default, and can be enabled
or disabled dynamically by updating the
column of the relevant instruments in the
setup_instruments table. Memory
instruments have names of the form
code_area is a value such as
instrument_name is the instrument
Instruments named with the prefix
memory/performance_schema/ expose how much
memory is allocated for internal buffers in the Performance
Schema. These instruments are displayed in the
table. For more information, see
Section 21.14, “The Performance Schema Memory-Allocation Model”.
Stage Instrument Components
Stage instruments have names of the form
code_area is a value such as
stage_name indicates the stage of
statement processing, such as
Sorting result or
Sending data. Stages correspond to the thread
states displayed by
PROCESSLIST or that are visible in the
Statement Instrument Components
statement/abstract/*: An abstract
instrument for statement operations. Abstract instruments are
used during the early stages of statement classification
before the exact statement type is known, then changed to a
more specific statement instrument when the type is known. For
a description of this process, see
Section 21.9.6, “Performance Schema Statement Event Tables”.
statement/com: An instrumented command
operation. These have names corresponding to
operations (see the
sql/sql_parse.cc. For example,
statement/com/Init DB instruments
correspond to the
statement/scheduler/event: A single
instrument to track all events executed by the Event
Scheduler. This instrument comes into play when a scheduled
event begins executing.
statement/sp: An instrumented internal
instruction executed by a stored program. For example, the
statement/sp/freturn instruments are used
cursor fetch and function return instructions.
Wait Instrument Components
An instrumented I/O operation.
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.
An instrumented socket operation. Socket instruments have
names of the form
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
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
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,
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.
An instrumented lock operation.
An instrumented table lock operation.
An instrumented metadata lock operation (disabled by default).
An instrumented synchronization object. For synchronization
TIMER_WAIT time includes the
amount of time blocked while attempting to acquire a lock on
the object, if any.
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.
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.
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.
A shared-exclusive (SX) lock is a type of
rwlock lock object
that provides write access to a common resource while
permitting inconsistent reads by other threads.
sxlocks were introduced in MySQL 5.7 to
optimize concurrency and improve scalability for