| Wait | WE_BUF_WAIT | SEC, COUNT | This value is high when multiple sessions make modification and reference requests for the same data block in the buffer cache. If multiple sessions modify a data block in the buffer cache simultaneously, or if one session modifies a data block while another session references its contents, data consistency issues may arise. Therefore, during data block access, if another session is already modifying or referencing the data block, the current session must wait until the previous modification or reference operation completes. This event indicates the time spent waiting during this process. |
| Wait | WE_BUF_WRITE | SEC, COUNT | The DB writer periodically writes modified data blocks from the buffer cache to disk. While the DB writer is performing disk writes, if another session modifies the data block, the DB writer may write the data block to disk in an inconsistent state, i.e., a state where modifications are in progress. Therefore, if the DB writer is in the process of writing, any session attempting to modify the data block must wait until the write is complete. This event indicates the time spent waiting during this process. |
| Wait | WE_BUF_FREE | SEC, COUNT | When loading new data blocks into the buffer cache or creating CR blocks, free buffers must be secured. This event indicates the time spent waiting during the free buffer acquisition process. If the buffer cache size is too small relative to the load using the buffer cache, or if the database writer is slow in writing dirty blocks to disk, the free buffer wait time may be high. |
| Wait | WE_LGWR_ARCHIVE | SEC, COUNT | This indicates the time the log writer waits for the redo log archiving operation to complete before performing a redo log switch. If the I/O speed to the disk designated as the archive directory is slow, this event may be measured at a high level. |
| Wait | WE_LGWR_LNW | SEC, COUNT | When there is a standby instance operating in LGWR SYNC mode, the log writer verifies that the redo log has been written to both the primary and standby instances. This event indicates the time the log writer waited for the redo log to be written to the standby instance. |
| Wait | WE_LOG_FLUSH_COMMIT | SEC, COUNT | This event indicates the time a session waits for a redo log flush request to be completed while performing a commit operation. For a transaction commit to complete, all redo logs left by the transaction must be flushed to the redo log file. The transaction-modified data blocks do not need to be flushed to disk to maintain commit consistency. In the event of a failure, if the server goes down or the machine shuts down while the redo log is flushed, the DB server performs cache recovery and transaction recovery upon subsequent boot. During cache recovery, the redo log is reapplied to restore the buffer cache to its state before it was flushed. During transaction recovery, since the commit itself leaves a redo log, an uncommitted transaction list is created, and the transactions in that list are rolled back. Through these actions, the DB server maintains consistency with just the redo log flush during commit. |
| Wait | WE_TSN_SYNC_COMMIT | SEC, COUNT | The time it takes for a session to request and complete TSN synchronization between nodes while performing a commit operation in the TAC. |
| Wait | WE_LOG_FLUSH_SPACE | SEC, COUNT | When a session modifies a data block, it creates a redo log containing the modified contents and applies it to the data block. During this process, the created redo log is recorded in the redo log buffer located in shared memory. When recording the redo log created in the redo buffer, if there is insufficient space in the redo buffer, the log writer must wait until the log writer flushes the redo log recorded in the redo log buffer to create space in the redo log buffer. This event indicates the time the log writer waits for the log writer to flush the redo log buffer to create free space in the redo buffer so that a new redo log can be written to the redo log buffer. |
| Wait | WE_LOG_FLUSH_REQ | SEC, COUNT | Indicates the time waited until the redo log flush is completed when a request is made to flush the contents of the redo log loaded in the redo buffer to the redo log file. This includes both cases where the user requests a redo log flush through DDL and cases where the DB server internally requests a redo log flush. Even if a redo log flush is not explicitly requested, it occurs when a TX commit occurs, a certain amount of redo log is loaded into the redo buffer, or a certain amount of time has elapsed. |
| Wait | WE_CKPT_WAIT | SEC, COUNT | This event indicates the time elapsed while waiting for a DB checkpoint requested by a specific point in time until the checkpoint is completed. A DB checkpoint refers to the process of writing modified data from the buffer cache to disk up to a specific point in time. When there are many modified data blocks in the buffer cache, a large number of data blocks may be written to disk during the checkpoint process. Therefore, the checkpoint process may occupy a significant amount of disk bandwidth and potentially degrade the performance of the DB instance. |
| Wait | WE_RT_INFLOW_WAIT | SEC, COUNT | When session flow control is enabled, this indicates the time spent waiting to be assigned an available session. |
| Wait | WE_SMR_REPLAY | SEC, COUNT | Indicates the time spent waiting for the Standby Managed Recovery process (SMR) to complete replay up to a specific point in time. |
| Wait | WE_PE_COMM | SEC, COUNT | Indicates the time the Slave Session waits for a message from the QC. When Parallel Execution begins, the QC session that manages the entire query assigns slave sessions to perform parallel processing. This event occurs while waiting for the slave session to be assigned. |
| Wait | WE_PE_ENQ | SEC, COUNT | Indicates the time a producer slave session waits to allocate a buffer from a consumer slave session. During parallel execution, producer slave sessions that generate intermediate results transmit these results to consumer slave sessions that utilize them. If the intermediate result storage buffer of a consumer slave session becomes full during this process, the producer slave session waits until buffer space becomes available, triggering this event. |
| Wait | WE_PE_DEQ | SEC, COUNT | This indicates the time that the consumer slave session waits for the producer slave session to fill the buffer. When parallel execution is performed, the producer slave session that generates intermediate results transmits those results to the consumer slave session that uses them to perform its tasks. During this process, if the intermediate result storage buffer of the consumer slave session is empty, an event occurs where the consumer slave session waits until the producer slave session fills the buffer further. |
| Wait | WE_ACF_MTX_RW | SEC, COUNT | Indicates the time spent waiting for a read/write mutex lock for synchronization in the active cluster. |
| Wait | WE_SVC_TX | SEC, COUNT | Indicates the time spent waiting for the user transaction to complete the index split operation of the service transaction. |
| Wait | WE_TX_RECO_SUSPEND | SEC, COUNT | Indicates the time the user waited until manually forcing a commit or rollback during TX recovery. |
| Wait | WE_CWS_AST | SEC, COUNT | Indicates the time spent waiting for a response to a wait-lock request sent to another node. |
| Wait | WE_CCC_AST_CR | SEC, COUNT | Indicates the time spent waiting for a response to a Consistent Read (CR) block request sent to another node. |
| Wait | WE_CCC_AST_CUR | SEC, COUNT | Indicates the time spent waiting for a response to a Current Block request sent to another node. |
| Wait | WE_CR_BUF_BUSY_LOCAL | SEC, COUNT | Indicates the time spent waiting for the CR block request of the local node to finish. |
| Wait | WE_CR_BUF_BUSY_GLOBAL | SEC, COUNT | Indicates the time to wait for another node's CR block request that is already in progress to finish. |
| Wait | WE_CUR_BUF_BUSY_LOCAL | SEC, COUNT | Indicates the time that the CUR block request waits for other session requests on the same node that are already in progress to finish. |
| Wait | WE_CUR_BUF_BUSY_GLOBAL | SEC, COUNT | Indicates the time to wait for other node requests that are already in progress to finish. |
| Wait | WE_GV_REQ | SEC, COUNT | Indicates the time spent waiting to receive a new global view execution request from another node. |
| Wait | WE_GV_REPLY | SEC, COUNT | Indicates the time spent waiting for the result set from another node in response to a global view request. |
| Wait | WE_SEARCH_SPACE_REPLY | SEC, COUNT | Indicates the time spent waiting for search space results from other nodes. |
| Wait | WE_DDL_CSR_INVAL | SEC, COUNT | deprecated |
| Wait | WE_DDL_CHANGE_UNDO_TS | SEC, COUNT | Indicates the time to wait when changing the undo tablespace. |
| Wait | WE_PEQ | SEC, COUNT | Indicates the time spent waiting in the queue for parallel execution. |
| Wait | WE_ALERT | SEC, COUNT | Indicates the time waiting for an alert. |
| Wait | WE_WLOCK_CF | SEC, COUNT | WLOCK acquired internally during Control File creation/loading/modification operations. |
| Wait | WE_WLOCK_TX | SEC, COUNT | A WLOCK acquired to prevent tx with the same id from starting in multiple sessions |
| Wait | WE_WLOCK_ST_SGMT | SEC, COUNT | WLOCK acquired when allocating/deallocating an extent in a segment. |
| Wait | WE_WLOCK_SPLIT | SEC, COUNT | WLOCK acquired when performing a split operation on a specific index block (WLOCK used before the index split feature was improved). |
| Wait | WE_WLOCK_DML | SEC, COUNT | WLOCK acquired when performing DML/DDL operations on a table or associated object. |
| Wait | WE_WLOCK_USER | SEC, COUNT | WLOCK acquired during profile changes, authentication, etc. for DB users. |
| Wait | WE_WLOCK_DD_OBJ | SEC, COUNT | WLOCK acquired internally during DDL, DD Cache lookup, etc. for DB objects. |
| Wait | WE_WLOCK_DD_USER | SEC, COUNT | WLOCK acquired internally during DDL, DD Cache lookups, etc. for DB users. |
| Wait | WE_WLOCK_DD_SGMT | SEC, COUNT | WLOCK acquired internally during operations such as DD cache lookups for segments within the DB. |
| Wait | WE_WLOCK_DD_TS | SEC, COUNT | WLOCK acquired internally when performing DDL on a tablespace in the DB or when creating an object belonging to the tablespace. |
| Wait | WE_WLOCK_DD_TS_REF | SEC, COUNT | WLOCK acquired internally when creating objects belonging to the DB tablespace. |
| Wait | WE_WLOCK_DD_OBJAUTH | SEC, COUNT | WLOCK internally acquired during object permission checks in SQL within the DB |
| Wait | WE_WLOCK_DD_SYSAUTH | SEC, COUNT | WLOCK obtained internally during system permission checks in SQL within the DB. |
| Wait | WE_WLOCK_DD_PSMIR | SEC, COUNT | WLOCK acquired internally during PSM execution, DD cache lookup, etc., for PSM units in the DB. |
| Wait | WE_WLOCK_DD_PENDING_TX | SEC, COUNT | WLOCK acquired internally to prevent multiple sessions from committing or rolling back the same transaction simultaneously. |
| Wait | WE_WLOCK_DD_PARTOBJ | SEC, COUNT | WLOCK acquired internally in Table, Partition, Index DDL, etc. |
| Wait | WE_WLOCK_SEQ_GET_NEXTVAL | SEC, COUNT | WLOCK acquired internally during value lookups or DDL operations on a sequence. |
| Wait | WE_WLOCK_DDL_CREATE_TS | SEC, COUNT | WLOCK acquired internally during tablespace creation. |
| Wait | WE_WLOCK_DDL_CREATE_DF | SEC, COUNT | WLOCK acquired to protect the exclusive execution of datafile/logfile add/create/drop/status changes. |
| Wait | WE_WLOCK_DDL_CREATE_CON | SEC, COUNT | WLOCK acquired internally during constraint creation. |
| Wait | WE_WLOCK_XA_BUCKET | SEC, COUNT | WLOCK acquired per bucket set when accessing the XA hashtable bucket |
| Wait | WE_WLOCK_XA_GLB | SEC, COUNT | WLOCK acquired when accessing XA global tx information. |
| Wait | WE_WLOCK_XA_BCH | SEC, COUNT | WLOCK acquired when accessing XA branch information. |
| Wait | WE_WLOCK_XA_VT | SEC, COUNT | Acquired to prevent transaction information from being deleted due to commit/rollback during XA-related VT creation. |
| Wait | WE_WLOCK_DX | SEC, COUNT | Acquired to prevent SQL execution from occurring simultaneously between sessions using tightly coupled XA branches. |
| Wait | WE_WLOCK_IR | SEC, COUNT | An internal WLOCK acquired to check whether IR (Instance Recovery) is in progress |
| Wait | WE_WLOCK_TEMP_GRANULE | SEC, COUNT | WLOCK obtained to ensure that the space allocated in the global temp tablespace cannot be used by other nodes. |
| Wait | WE_WLOCK_CLEANUP_DROPPED_SGMT | SEC, COUNT | WLOCK acquired internally when actually cleaning up segments dropped due to DDL |
| Wait | WE_WLOCK_MV_RFSH | SEC, COUNT | WLOCK acquired internally during Mview refresh |
| Wait | WE_WLOCK_DDL_RECOMPILE | SEC, COUNT | WLOCK acquired internally during PSM Recompile |
| Wait | WE_WLOCK_ASYSRECOMPILE | SEC, COUNT | WLOCK acquired internally when Alter system recompile all is executed. |
| Wait | WE_WLOCK_DBMS_PIPE_LIST | SEC, COUNT | WLOCK acquired internally when using the DBMS_PIPE package. |
| Wait | WE_WLOCK_DP_TEMP_SGMT | SEC, COUNT | Acquired to ensure that cleanup operations cannot clean up the temp segment while the PDP is still running. WLOCK |
| Wait | WE_WLOCK_STANDBY | SEC, COUNT | WLOCK acquired to ensure that the Log Network Reader process runs exclusively within the DB. |
| Wait | WE_WLOCK_SMR | SEC, COUNT | WLOCK acquired by the Standby Managed Recovery process to perform independently during standby TAC multinode. |
| Wait | WE_WLOCK_LNR_REVERSE_SYNC | SEC, COUNT | WLOCK acquired for the standby forced reverse synchronization function to be performed independently. |
| Wait | WE_WLOCK_AUTO_COALESCE | SEC, COUNT | WLOCK acquired to perform index auto coalesce per session |
| Wait | WE_WLOCK_XTB_TIMEOUT_CHECK | SEC, COUNT | WLOCK to prevent duplicate timeout checks for XA sessions |
| Wait | WE_WLOCK_REVALIDATE_OBJ | SEC, COUNT | WLOCK acquired internally during revalidation of invalid DB objects |
| Wait | WE_WLOCK_UPDATE_USER_STATUS | SEC, COUNT | WLOCK acquired internally by the Profile processing performed periodically. |
| Wait | WE_WLOCK_L1_LOCAL_CACHE | SEC, COUNT | Acquired to prevent multiple sessions from simultaneously requesting L1 distribution from the same segment master. |
| Wait | WE_WLOCK_SC_LRU_CACHE_OUT | SEC, COUNT | WLOCK acquired when performing shared cache LRU cache out. |
| Wait | WE_WLOCK_DBMS_LOCK | SEC, COUNT | WLOCK used when using the DBMS_LOCK package. |
| Wait | WE_WLOCK_BITMAP_INDEX | SEC, COUNT | WLOCK acquired to add a key (entry) to the bitmap index. |
| Wait | WE_WLOCK_BCT | SEC, COUNT | WLOCK acquired to change the BCT (Block Change Tracker) status. |
| Wait | WE_WLOCK_IMCS | SEC, COUNT | WLOCK acquired for in-memory column store scan or populate operations. |
| Wait | WE_WLOCK_IMCS_PRIORITY_POPULATE | SEC, COUNT | WLOCK acquired for in-memory column store priority populate operations. |
| Wait | WE_WLOCK_LGWR_STATUS | SEC, COUNT | Acquired to wait for completion after requesting to stop/resume I/O operations of the log writer thread and check pointer thread. WLOCK |
| Wait | WE_WLOCK_FB | SEC, COUNT | Acquired to ensure exclusive execution when changing the flashback thread state. |
| Wait | WE_WLOCK_RMGR | SEC, COUNT | A WLOCK used to protect the independence of RMGR jobs in the DB based on their status. |
| Wait | WE_WLOCK_TS_INVALIDATE | SEC, COUNT | Acquired to prevent duplicate execution of global buffer cache invalidation operations during tablespace offline or drop operations. |
| Wait | WE_WLOCK_CF_TS | SEC, COUNT | WLOCK acquired when performing Tablespace create/drop and Tablespace datafile add/rename |
| Wait | WE_WLOCK_JOB | SEC, COUNT | WLOCK acquired to prevent a job from being executed multiple times by different workers. |
| Wait | WE_WLOCK_SESSKEY | SEC, COUNT | WLOCK acquired internally when decrypting connection information received from the client in encrypted form. |
| Wait | WE_WLOCK_CONTEXT_INDEX | SEC, COUNT | WLOCK obtained internally when synchronizing the context index. |
| Wait | WE_WLOCK_RT_STANDBY | SEC, COUNT | WLOCK acquired by the Log Network Writer process to perform synchronization with the standby DB and redo thread that correspond to itself. |
| Wait | WE_WLOCK_USGMT | SEC, COUNT | WLOCK acquired when performing undo segment modification operations such as undo segment creation, ucache load/reload, etc. |
| Wait | WE_WLOCK_RSRC | SEC, COUNT | WLOCK used to protect consumer group information modifications |
| Wait | WE_WLOCK_SETPARAM | SEC, COUNT | WLOCK acquired when using Alter system set parameter |
| Wait | WE_WLOCK_IMT | SEC, COUNT | WLOCK acquired when initializing the in-memory tablespace and loading the in-memory tablespace DD information. |
| Wait | WE_WLOCK_EXPAND_RSB | SEC, COUNT | WLOCK acquired to create additional memory context (rsb) related to the global buffer cache in the TAC environment. |
| Wait | WE_WLOCK_EXPAND_LKBSET | SEC, COUNT | WLOCK acquired to create additional memory context (lkb) related to the global lock of the data block in the TAC environment. |
| Wait | WE_JC_BUF_DISK_READ | SEC, COUNT | Represents the number of times each DB block was read (single). The block disk read time is the time spent waiting to read the block from the disk and load it into the buffer cache. Reads one block from the disk into the buffer. The value indicates the number of reads. |
| Wait | WE_JC_BUF_DISK_READM | SEC, COUNT | Represents the number of DB blocks read (multiple). This occurs when multiple blocks are read into the buffer simultaneously from the disk, such as during a full table scan where many consecutive blocks are read at once. The value indicates the number of times disk read was called, and the size represents the number of blocks read from the disk. The time indicates the duration of the disk read operation. |
| Wait | WE_JC_SSGMT_READ_TIME | SEC, COUNT | Indicates the number of times the temporary segment in the sort segment area was read, the number of extents read, and the time taken. |
| Wait | WE_JC_SSGMT_WRITE_TIME | SEC, COUNT | Indicates the number of times the temporary segment in the Sort Segment area was written, the number of extents used, and the time taken. |
| Wait | WE_JC_BUF_DISK_READM_PGA | SEC, COUNT | Indicates the number of times a multi-block disk read was requested to the PGA, the number of blocks actually read, and the time taken. Occurs when a multi-block disk read is performed on the PGA rather than the buffer cache. |
| Wait | WE_JC_DPBUF_WAIT_WRITE | SEC, COUNT | This statistic indicates the number of times and the write time for writing the contents of blocks loaded into the direct path buffer during Direct Path Load (DPL) or Direct Path Import (DPI) operations. |
| Wait | WE_JC_REDO_SLEEP | SEC, COUNT | When using the redo resource manager feature, this event calculates the redo log generation rate and the amount of redo log generated by each session for flow control purposes, and processes the session to wait for a certain amount of time when the session is accumulating redo logs in the redo buffer. This event indicates the number of times and the duration the session waited during this process. |
| Wait | WE_JC_FDPOOL_INVL | SEC, COUNT | When invalidating a cached fdpool due to a datafile drop, this indicates the number of times and duration that other wthr referencing the same fdpool wait until the fdpool is released. |
| Wait | WE_JC_FARC_WRITE | SEC, COUNT | Indicates the number of times, number of blocks, and time taken for FARC to write to disk when generating a flashback archive logfile. |
| Wait | WE_SPIN_BUF_BUCKET | SEC, COUNT | Displays statistical information related to the spinlock that protects the hash bucket chain in the buffer cache. The buffer cache uses a hash bucket table as a data structure to quickly access requested blocks, and each hash bucket is organized into a chain to resolve hash collisions. When accessing a block, the hash bucket chain is searched, and this spinlock is acquired to protect the chain structure. Due to load characteristics, such as severe hot block contention or a small hash bucket table size, contention for this spinlock may increase. |
| Wait | WE_SPIN_BUF_WS | SEC, COUNT | This indicates statistical information related to the spinlock that protects the working set of the buffer cache. To mitigate contention that occurs when multiple sessions access the buffer cache simultaneously, the buffer cache divides buffers into small units called working sets for management. Each working set manages the same number of buffers, and when a session accesses a working set, it acquires this spinlock to protect the internal management structure of the working set. If the number of working sets is small compared to the buffer cache size, the contention for this spinlock may increase. |
| Wait | WE_SPIN_SHP_ALLOC_LC | SEC, COUNT | This spinlock is for the slave of the shared pool allocator that is shared and written by threads across multiple processes. |
| Wait | WE_SPIN_SHP_ALLOC_DD | SEC, COUNT | This is a spinlock for the slave of the shared pool allocator that is shared and used by threads in multiple processes. |
| Wait | WE_SPIN_SHP_ALLOC_MISC | SEC, COUNT | A spinlock for the slave of a shared pool allocator that is shared and used by threads in multiple processes. |
| Wait | WE_SPIN_SHP_ALLOC_SLAB | SEC, COUNT | A spinlock for the slave of a shared pool allocator that is shared and used by threads in multiple processes. |
| Wait | WE_SPIN_SHP_ALLOC_SUPER | SEC, COUNT | A spinlock for the shared pool allocator shared and used by threads in multiple processes. |
| Wait | WE_SPIN_ALLOC_LRU | SEC, COUNT | A spinlock that protects the LRU list of recreatable chunks that can be reused among the recreatable chunks in the shared pool. |