Wait Statistics

Occurs when a task waits for asynchronous I/O operations to complete. Covers a broad range of I/O operations including checkpoint writes, lazy writer,

Occurs when the task is waiting for the network to send data to the client. High values often indicate the client application is not consuming results

Occurs when a backup task waits for I/O on the backup device. High values indicate slow backup target (tape, network share, slow disk) or compression

Occurs when a Service Broker conversation endpoint waits for messages to arrive. Normal part of Service Broker asynchronous messaging.

Occurs when the Service Broker transmitter is waiting to send messages across the network. Normal at low levels; high values indicate network issues b

Occurs when waiting on a thread-safe memory allocation object. High values indicate memory object contention, often from frequent ad-hoc query compila

Occurs when a parallel thread consumer waits for a producer thread to send rows. Related to CXPACKET but from the consumer side — indicates producer-c

Occurs when waiting for parallel query execution to complete. Caused by skewed parallelism, exchange buffers filling up, or uneven row distribution ac

Occurs when waiting for a DTC abort operation. Indicates distributed transactions that are failing to abort cleanly, often leading to lingering transa

Occurs when waiting for a Distributed Transaction Coordinator (DTC) operation. High values indicate distributed transaction latency or cross-database

Occurs during parallel query synchronization phases such as exchange iterator completion and batching. Normal part of parallel execution and rarely ac

Occurs when waiting for a File Control Block replica operation — part of the database startup and recovery process. Rarely performance-relevant.

Occurs when waiting to access availability group internal state. Indicates AG metadata contention, often during failover or replica state transitions.

Occurs when waiting for a database-level operation to start in the availability group context. Typically seen during database joins or role transition

Occurs on the primary replica when waiting for a secondary replica to acknowledge a transaction commit. High values indicate network latency between A

Occurs when waiting for the AG transport session to become available. Indicates network connectivity issues or AG communication bottlenecks between re

Occurs when AG work items are queued waiting for worker threads. Indicates the AG worker pool is saturated — often during large redo operations or fai

Occurs when the instance-level log rate governor throttles log generation. Azure SQL DB only. Indicates the log generation rate exceeds the service ti

Occurs when waiting for synchronous I/O operations to finish. Often related to network I/O, backup/restore, or bulk insert operations.

Occurs when waiting for an exclusive latch on an in-memory structure. Unlike PAGEIOLATCH, this is pure memory contention — no disk I/O involved. Typic

Occurs when waiting for a shared latch on an in-memory structure. Normal at low levels; high values indicate contention on frequently accessed interna

Occurs when waiting for an intent shared (IS) lock. Typical in hierarchy locking scenarios where a table-level IS lock is blocked by an existing X or

Occurs when waiting for an intent update (IU) lock. Common during index operations where the intent update at the table level is blocked by concurrent

Occurs when waiting for an intent exclusive (IX) lock. Frequently observed during DML operations (INSERT/UPDATE/DELETE) on pages blocked by other tran

Occurs when a task waits to acquire a shared (S) lock on a resource. Typical of read operations blocked by write operations. High duration indicates b

Occurs when waiting for a schema modification (Sch-M) lock. Blocks nearly everything. Typically from DDL operations (ALTER TABLE, CREATE INDEX) runnin

Occurs when waiting for a schema stability (Sch-S) lock. Normally very short; used when compiling queries to ensure the schema doesn't change during c

Occurs when a task waits to acquire an update (U) lock. Update locks are used during the initial phase of a modification to prevent concurrent modific

Occurs when a task waits to acquire an exclusive (X) lock. High durations indicate write-write contention, often from long-running DDL or DML in seria

Occurs when the log manager is flushing dirty pages to make log buffer space available. Related to WRITELOG but at the internal log manager level.

Occurs when waiting for log file space — either waiting for log growth to complete or waiting for VLFs to be truncated. High values indicate oversized

Occurs when allocating memory from the extended memory manager. Can indicate large page allocations or memory pressure at the OS level.

Occurs when SQL Server is waiting on OLE DB calls to a linked server or remote data source. High values indicate slow remote queries, network latency

Occurs when a task waits for a data page to be written from the buffer pool to disk (exclusive latch). High durations indicate write latency on the st

Occurs when a task waits for a data page to be read from disk into the buffer pool (shared latch). High durations indicate disk I/O subsystem latency

Occurs when a task waits for a data page I/O operation with an update latch. Less common than SH/EX variants; indicates pages being read for update op

Occurs when waiting for an exclusive latch on a buffer pool page already in memory — no I/O is involved. Classic symptom of page-level contention, oft

Occurs when waiting for a shared latch on a buffer pool page already in memory. Usually transient; high values indicate contention on frequently read

Occurs when waiting for an update latch on a buffer pool page in memory. The classic 'last-page insert contention' signal on index leaf pages — common

Occurs during preemptive OS operations where SQL Server calls Windows API GetProcAddress to resolve DLL function addresses. Typically a startup or con

Occurs during preemptive OS write operations. Related to FileStream/FileTable operations or custom assembly I/O using Win32 WriteFile API.

Occurs when a query cannot start execution because it is waiting for memory grant. High values indicate the server is out of query memory — queries ar

Occurs when waiting for memory to compile queries. High values indicate the compile memory lock is contended, often from a high rate of ad-hoc query c

Occurs when a task voluntarily sleeps while waiting for an event such as WAITFOR, query timeout, or connection sleep. High counts are normal — this is

Occurs when a task voluntarily yields the scheduler for other tasks to execute. High counts indicate CPU pressure or inefficient query plans that refu

Occurs when waiting for SQL Trace buffer flushes. Extended Events is the modern replacement. High values indicate trace bottlenecks that may be mitiga

Occurs when a task is waiting for an available worker thread. Indicates all worker threads are busy — typically from blocker chains, excessive paralle

Occurs when the SQL Trace writer thread waits for the trace buffer to flush. Similar to SQLTRACE_WAIT_ENTRIES — consider migrating to Extended Events.

Occurs when a session executes the WAITFOR command (DELAY or TIME). This is intentional application-level waiting and is almost never a performance pr

Occurs when waiting for the transaction log to be flushed to disk. One of the most important I/O signals. High WRITELOG indicates log drive latency, e