| SQL*Net break/reset to client |
The server sends a break or reset message to the client.
The session running on the server waits for a reply from the client.
Wait Time : The actual time it takes for the break or reset message to return from the client
Parameters:
driver id
break?
|
| SQL*Net break/reset to dblink |
Same as SQL*Net break/reset to client, but in this case, the break/reset
message is sent to another server process over a database link.
Wait Time : The actual time it takes for the break or reset message to return from the other server process
Parameters:
driver id
break?
|
| SQL*Net message from client |
The server process (foreground process) waits for a message from the client process to arrive.
Wait Time : The time it took for a message to arrive from the client since the last message was sent to the client
Parameters:
driver id
#bytes The number of bytes received by the server
(foreground process) from the client.
|
| SQL*Net message from dblink |
The session waits while the server process (foreground process)
receives messages over a database link from another server process.
Wait Time : The time it took for a message to arrive from another server
(foreground process) since a message was sent to the other foreground process.
Parameters:
driver id
#bytes The number of bytes received by the server (foreground process)
from another foreground process over a database link.
|
| SQL*Net message to client |
The server (foreground process) is sending a message to the client.
Wait Time : The actual time the send takes
Parameters:
driver id
#bytes
The number of bytes sent by the server process to the client
|
| SQL*Net message to dblink |
The server process (foreground process) is sending a message
over a database link to another server process.
Wait Time : The actual time the send takes
Parameters:
driver id
#bytes The number of bytes sent by the server process to another
server process over a database link
|
| SQL*Net more data from client |
The server is performing another send to the client.
The previous operation was also a send to the client.
Wait Time : The time waited depends on the time it took to receive the data
(including the waiting time)
Parameters:
driver id
#bytes The number of bytes received from the client
|
| SQL*Net more data from dblink |
The foreground process is expecting more data from a data base link.
Wait Time : The total time it takes to read the data from the database link
(including the waiting time for the data to arrive)
Parameters
driver id
#bytes The number of bytes received
|
| SQL*Net more data to client |
The server process is sending more data/messages to the client.
The previous operation to the client was also a send.
Wait Time : The actual time it took for the send to complete
Parameters:
driver id
#bytes The number of bytes that are being sent to the client
|
| SQL*Net more data to dblink |
The event indicates that the server is sending data over a database link again.
The previous operation over this database link was also a send.
Wait Time : The actual time it takes to send the data to the other server
Parameters:
driver id
#bytes The number of bytes that are sent over the database link to the other server process
|
| alter system set dispatchers |
A session has issued a statement
ALTER SYSTEM SET DISPATCHERS = string
and is waiting for the dispatchers to get started.
Wait Time : The session will wait 1 / 100 of a second and check to see if the
new dispatchers have started else the session will wait again
waited Number of times that the session has waited 1 / 100 of a second
|
| dispatcher shutdown |
During shutdown immediate or normal, the shutdown process must wait for all the
dispatchers to shutdown. As each dispatcher is signaled, the session that
causes the shutdown is waits on this event until the requested dispatcher is no longer alive.
Wait Time : 1 second
Parameter:
waited Indicates the cumulative wait time. After 5 minutes, the session writes to the
alert and trace files to indicate that there might be a problem.
|
| dispatcher timer |
This basically means that the dispatcher is idle and waiting for some work to arrive.
Wait Time : 60 seconds
Parameter:
sleep time The intended sleep time. The dispatcher will return to work sooner if it is
posted by either data arriving on the network or by a post from a
shared server process to send data back to the client.
|
| duplicate cluster key |
It is possible for a race condition to occur when creating a new cluster key.
If it is found that another process has put the cluster key into the data/index block,
then the session waits and retries. The retry should then find a valid cluster key.
Wait Time : 0.01 seconds
Parameter:
dba The dba of the block into which the session is trying to insert a cluster key
|
| batched allocate scn lock request |
A session is waiting on another process to allocate a system change number (SCN).
If the foreground timed out waiting on a process to get the SCN, the foreground will get the SCN.
Wait Time : The wait time is 1 second on the assumption that an SCN allocation should normally need much less than that
Parameters: None
|
| enqueue |
The session is waiting for a local enqueue.
The wait is dependent on the name of the enqueue
(see Appendix B, "Oracle Enqueue Names").
Wait Time : Depends on the enqueue name
Parameters:
name
mode
file identify The time it takes to identify a file so that
it can be opened later.
file open The time it takes to open the file.
|
| Lock recovery |
Initializing the locks (start up)
Finalizing the locks (shut down)
Wait Time : 10 seconds
Parameters
count The number of LCK processes that have finished
loops The number times the process had to wait for the
LCK processes to finish what they were doing
|
| latch activity |
This event is used as part of the process of determining whether a latch needs to be cleaned.
Wait Time : 0.05 to 0.1 seconds
Parameters:
address The address of the latch that is being checked
number The latch number of the latch that has activity.
To find more information on the latch, use
the following SQL statement:
select * from v$latchname where latch# = number;
process# If this is 0, it is the first phase of the in-flux tests
|
| latch free |
The process waits for a latch that is currently busy (held by another process).
Wait Time : The wait time increases exponentially and does not include
spinning on the latch (active waiting). The maximum wait time also depends
on the number of latches that the process is holding. There is an incremental wait of up to 2 seconds.
Parameters:
address The address of the latch for which the process is waiting
number
The latch number that indexes in the V$LATCHNAME view.
To find more information on the latch, use the following SQL statement:
select * from v$latchname where latch# = number;
tries
A count of the number of times the process tried to get the latch
(slow with spinning) and the process has to sleep
|
| library cache load lock |
The session tries to find the load lock for the database object so that it
can load the object. The load lock is always obtained in Exclusive mode,
so that no other process can load the same object.
If the load lock is busy the session will wait on this event until the lock becomes available.
Wait Time : 3 seconds (1 second for PMON)
Parameters:
object address Address of the object being loaded
lock address Address of load lock being used
mask Indicates which data pieces of the object that needs to be loaded
|
| library cache lock |
This event controls the concurrency between clients of the
library cache. It acquires a lock on the object handle so that either:
One client can prevent other clients from accessing the same object
The client can maintain a dependency for a long time
(for example, no other client can change the object)
This lock is also obtained to locate an object in the library cache.
Wait Time : 3 seconds (1 second for PMON)
Parameters:
handle address Address of the object being loaded
lock address
Address of the load lock being used.
This is not the same thing as a latch or an enqueue, it is a State Object.
mode Indicates the data pieces of the object which need to be loaded
namespace
|
| lock manager wait for remote message |
The lock manager waits for a message from a remote lock manager in the same configuration.
Wait Time : The elapsed time of the wait
Parameter:
waittime The elapsed time of the actual wait
|
| row cache lock |
The session is trying to get a data dictionary lock.
Wait Time : Wait up to 60 seconds.
Parameters:
cache id The CACHE# column value in the V$ROWCACHE view
mode See "mode"
request The pipe timer set by the user
|
| BFILE check if exists |
The session waits to check if an external large object (LOB) exists.
Wait Time : The total elapsed time for the exists call
Parameters: session#, waited
|
| BFILE check if open |
The session waits to check if an external large object (LOB) has already been opened.
Wait Time : The total elapsed time for the isopen call
Parameters: session#, waited
|
| BFILE closure |
The session waits for an external large object (LOB) to close.
Wait Time : The total elapsed time for the close call
Parameters: session#, waited
|
| BFILE get length |
The session waits on a call to check the size of an external large object (LOB).
Wait Time : The total elapsed time for the call to check the LOB size
Parameters: session#, waited
|
| BFILE get name object |
The session waits on a call to find or generate the external name of a external large object.
Wait Time : The total elapse time for make external file name to complete
Parameters: session#, waited
|
| BFILE get path object |
The session is waiting on a call to find or generate the external path name
of an external large object (LOB).
Wait Time : The total elapsed time for make external path to complete
Parameters: session#, waited
|
| BFILE internal seek |
The session waits for a positioning call within the
external large object (LOB) to complete.
Wait Time : The total elapse time for the seek to complete
Parameters: session#, waited
|
| BFILE open |
The session waits to check if an external large object (LOB)
has already been opened.
Wait Time : The total elapsed time for the isopen call
Parameters: session#, waited
|
| BFILE read |
The session waits for a read from a
external large object (LOB) to complete.
Wait Time : The total elapse time for the read to complete
Parameters: session#, waited
|
| checkpoint completed |
A session waits for a checkpoint to complete. This could happen,
for example, during a close database or a local checkpoint.
Wait Time : 5 seconds
Parameters: None
checkpoint range buffer not saved
During a range checkpoint operation a buffer was found that was not saved or written. Either:
The session will wait on this event if the write batch is empty and it is
the first time that the session waited on this event in the range checkpoint operation
The current range checkpoint operation will be aborted and a new one
will be started to complete the operation
Wait Time : 10 milliseconds
Parameters: None
|
| control file parallel write |
This event occurs while the session is writing physical blocks to all control files.
This happens when:
1) The session starts a control file transaction
(to make sure that the control files are up to date in case the session
crashes before committing the control file transaction)
2) The session commits a transaction to a control file
Changing a generic entry in the control file,
the new value is being written to all control files
Wait Time : The wait time is the time it takes to finish all writes to all control files
Parameters:
files The number of control files to which the session is writing
blocks The number of blocks that the session is writing to the control file
requests The number of I/O requests which the session wants to write
|
| control file sequential read |
Reading from the control file. This happens in many cases. For example, while:
Making a backup of the controlfiles
Sharing information (between instances) from the controlfile
Reading other blocks from the controlfiles
Reading the header block
Wait Time : The wait time is the elapsed time of the read
Parameters:
file# The controlfile from which the session is reading
block# Block number in the controlfile from where the session starts to read.
The block size is the physical block size of the port (usually 512 bytes,
some UNIX ports have 1 or 2 Kilobytes).
blocks The number of blocks that the session is trying to read
|
| control file single write |
This wait is signaled while the control file's shared information is written to disk.
This is an atomic operation protected by an enqueue (CF),
so that only one session at a time can write to the entire database.
Wait Time : The wait time is the elapsed time of the write
Parameters:
file# This identifies the control file to which the session is currently writing
block# Block number in the control file where the write begins.
The block size is the as the physical block size of the port
(usually 512 bytes, some UNIX ports have 1 or 2 Kilobytes).
blocks The number of blocks that the session is trying to read
|
| conversion file read |
This event occurs during the creation of a Version 7 controlfile as part of
converting a database to Version 7 from Version 6.
Wait Time : The wait time is the elapsed time of the read
Parameters
block# Block number in the control file where the write begins.
The block size is the as the physical block size of the port
(usually 512 bytes, some UNIX ports have 1 or 2 Kilobytes).
blocks The number of blocks that the session is trying to read
|
| on-going SCN fetch to complete |
Another session is fetching the SCN (system change number).
This session waits for the other session finish fetching the SCN.
Wait Time : 1 second
Parameters: None
|
| buffer deadlock |
Oracle does not really wait on this event; the foreground only yields the CPU.
Thus, the chances of catching this event are very low. This is not an
application induced deadlock, but an assumed deadlock by the cache layer. The cache layer cannot get a buffer in a certain mode
within a certain amount of time.
Wait Time : 0 seconds. The foreground process only yields the CPU and will
usually be placed at the end of the CPU run queue.
Parameters:
class, mode
flag The flag points to the internal flags used by the session to get this block
dba
|
| buffer for checkpoint |
The buffer could not be checkpointed, because some process is modifying it.
This means that after the wait, the DBWR will scan the whole buffer cache again.
This could happen during a database close or after a user does a local checkpoint.
During this situation the database cannot be closed.
Wait Time : 1 second
Parameters:
dba
state State refers to the status of the buffer contents
mode
buffer# This is the index of the block in the buffer cache (V$BH)
|
| buffer latch |
The session waits on the buffer hash chain latch.
Primarily used in the dump routines.
Wait Time : 1 second
Parameters:
latch addr
The virtual address in the SGA where this latch is located.
Use the following statement to find the name of this latch:
select * from v$latch a, v$latchname b where addr = latch addr and a.latch# = b.latch#;
chain#
The index into array of buffer hash chains. When the chain
is 0xfffffff, the foreground waits on the LRU latch.
|
| buffer read retry |
This event occurs only if the instance is mounted in shared mode
(Oracle Real Application Cluster).
During the read of the buffer, the contents changed. This means that either:
The version number, dba, or the incarnation and sequence number
stored in the block no longer match
The checksum on the block does not match the checksum in the block
The block will be re-read (this may fail up to 3 times),
then corruption is assumed and the corrupt block is dumped in the trace file.
Wait Time : The wait time is the elapsed time of the read
Parameters: file#, block#
|
| buffer busy waits |
Wait until a buffer becomes available.
This event happens because a buffer is either being read into
the buffer cache by another session (and the session is waiting
for that read to complete) or the buffer is the buffer cache, but in a incompatible mode
(that is, some other session is changing the buffer).
Wait Time : Normal wait time is 1 second. If the session was waiting for a
buffer during the last wait, then the next wait will be 3 seconds.
Parameters: file#, block#
id The buffer busy wait event is called from different places in the session
|
| free buffer waits |
This will happen if: All buffer gets have been suspended.
This could happen when a file was read-only and is now read-write.
All the existing buffers need to be invalidated since they are not linked to
lock elements (needed when mounted parallel (shared)).
So cache buffers are not assigned to data block addresses until the
invalidation is finished. The session moved some dirty buffers to the dirty
queue and now this dirty queue is full. The dirty queue needs to be
written first. The session will wait on this event and try again to find
a free buffer This also happens after inspecting free buffer inspected
buffers. If no free buffer is found, Oracle waits for one second, and
then tries to get the buffer again (depends on the context).
For more information, see free buffer inspected.
Wait Time : 1 second
Parameters: file#, block#
|
| library cache pin |
This event manages library cache concurrency.
Pinning an object causes the heaps to be loaded into memory.
If a client wants to modify or examine the object,
the client must acquire a pin after the lock.
Wait Time : 3 seconds (1 second for PMON)
Parameters:
handle address
Address of the object being loaded
pin address
Address of the load lock being used. This is not the same
thing as a latch or an enqueue, it is basically a State Object.
mode
Indicates which data pieces of the object that needs to be loaded
namespace
See "namespace"
|
| db file parallel read |
This happens during recovery. Database blocks that need to be changed as
part of recovery are read in parallel from the database.
Wait Time : Wait until all of the I/Os are completed
Parameters:
files This indicates the number of files to which the session is reading
blocks This indicates the total number of blocks to be read
requests This indicates the total number of I/O requests, which will be the same as blocks
|
| db file parallel write |
This event occurs in the DBWR. It indicates that the DBWR is
performing a parallel write to files and blocks. The parameter
requests indicates the real number of I/Os that are being performed.
When the last I/O has gone to disk, the wait ends.
Wait Time : Wait until all of the I/Os are completed
Parameters:
files This indicates the number of files to which the session is writing
blocks This indicates the total number of blocks to be written
requests This indicates the total number of I/O requests, which will be the same as blocks
|
| db file scattered read |
Similar to db file sequential read, except that the session is reading multiple data blocks.
Wait Time : The wait time is the actual time it takes to do all of the I/Os
Parameters: file#, block#
blocks The number of blocks that the session is trying to read
from the file# starting at block#
|
| db file sequential read |
The session waits while a sequential read from the database is performed.
This event is also used for rebuilding the control file, dumping datafile headers, and getting the database file headers.
Wait Time : The wait time is the actual time it takes to do the I/O
Parameters: file#, block#
blocks This is the number of blocks that the session is trying to read (should be 1)
|
| db file single write |
This event is used to wait for the writing of the file headers.
Wait Time : The wait time is the actual time it takes to do the I/O
Parameters: file#, block#
blocks This is the number of blocks that the session is trying to write in file# starting at block#
|
| DFS db file lock |
This event occurs only for the DBWR in the Oracle Real Application Cluster.
Each DBWR of every instance holds a global lock on each file in shared mode.
The instance that is trying to offline the file will escalate the global lock from
shared to exclusive. This signals the other instances to synchronize their SGAs
with the controlfile before the file can be taken offline. The name of this lock is
DF (see Appendix B, "Oracle Enqueue Names" for more information).
Wait Time : 1 second in loop. The DBWR is waiting in a loop (sleep, check) for the other
instances to downgrade to NULL mode. During this time, the DBWR cannot
perform other tasks such as writing buffers.
Parameter: file
|
| DFS lock handle |
The session waits for the lock handle of a global lock request.
The lock handle identifies a global lock. With this lock handle,
other operations can be performed on this global lock
(to identify the global lock in future operations such as
conversions or release). The global lock is maintained by the DLM.
Wait Time : The session waits in a loop until it has obtained the lock handle from the DLM.
Inside the loop there is a wait of 0.5 seconds.
Parameters
name
mode
id1
id2
The session needs to get the lock handle.
|
| direct path read |
During Direct Path operations the data is asynchronously read from the database files.
At some stage the session needs to make sure that all outstanding asynchronous I/O
have been completed to disk. This can also happen if during a direct read no more
slots are available to store outstanding load requests (a load request could consist of multiple I/Os).
Wait Time : 10 seconds. The session will be posted by the completing asynchronous I/O.
It will never wait the entire 10 seconds.
The session waits in a tight loop until all outstanding I/Os have completed.
Parameters:
descriptor address This is a pointer to the I/O context of outstanding direct
I/Os on which the session is currently waiting
first dba The dba of the oldest I/O in the context referenced by the descriptor address
block cnt Number of valid buffers in the context referenced by the descriptor address
|
| direct path write |
During Direct Path operations, the data is asynchronously written to the database files.
At some stage the session needs to make sure that all outstanding
asynchronous I/O have been completed to disk. This can also happen if,
during a direct write, no more slots are available to store
outstanding load requests (a load request could consist of multiple I/Os).
Wait Time : 10 seconds. The session will be posted by the completing asynchronous I/O.
It will never wait the entire 10 seconds.
The session waits in a tight loop until all outstanding I/Os have completed.
Parameters:
descriptor address This is a pointer to the I/O context of outstanding direct I/Os on
which the session is currently waiting first dba
The dba of the oldest I/O in the context referenced by the descriptor address
block cnt Number of valid buffers in the context referenced by the descriptor address
|
| io done |
The session waits for an I/O to complete or it waits for a slave process to become
available to submit the I/O request. This event occurs on platforms that do not
support asynchronous I/O.
Wait Time : 50 milliseconds
Parameter:
msg ptr
A pointer to the I/O request
kcl bg acks
The session waits for the background LCK process(es) to finish what they are doing. For example:
|
| log buffer space |
Waiting for space in the log buffer because the session is writing data
into the log buffer faster than LGWR can write it out. Consider making
the log buffer bigger if it is small, or moving the log files to faster disks such as striped disks.
Wait Time : Usually 1 second, but 5 seconds if it is waiting for a Switch Logfile to complete
Parameters: None
|
| log file parallel write |
Writing redo records to the redo log files from the log buffer.
Wait Time : Time it takes for the I/Os to complete.
Even though redo records are written in parallel, the
parallel write is not complete until the last I/O is on disk.
Parameters:
files Number of files to be written
blocks Number of blocks to be written
requests Number of I/O requests
|
| log file sequential read |
Waiting for the read from this logfile to return.
This is used to read redo records from the log file.
Wait Time : Time it takes to complete the physical I/O (read)
Parameters:
log# The relative sequence number of the logfiles within a log
group (used only when dumping the logfiles)
block#
blocks The number of blocks to read
|
| log file single write |
Waiting for the write to this logfile to complete.
This event is used while updating the header of the logfile.
It is signaled when adding a log file member and when
incrementing sequence numbers.
Wait Time : Time it takes for the physical I/O (write) to complete
Parameters:
log# This is the number of the group/log to which the session is currently writing
block#
blocks The number of blocks to write
|
| log file switch (archiving needed) |
Waiting for a log switch because the log that the LGWR will be
switching into has not been archived yet. Check the alert file to
make sure that archiving has not stopped due to a failed archive write.
To speed archiving, consider adding more archive processes or
putting the archive files on striped disks.
Wait Time : 1 second
Parameters: None
|
| log file switch (checkpoint incomplete) |
Waiting for a log switch because the session cannot wrap into
the next log. Wrapping cannot be performed because the
checkpoint for that log has not completed.
Wait Time : 1 second
Parameters: None
|
| log file switch (clearing log file) |
Waiting for a log switch because the log is being cleared due to a
CLEAR LOGFILE command or implicit clear logfile executed by recovery.
Wait Time : 1 second
Parameters: None
|
| log file switch completion |
Waiting for a log switch to complete.
Wait Time : 1 second
Parameters: None
|
| log file sync |
When a user session commits, the session's redo information needs
to be flushed to the redo logfile. The user session will post the LGWR
to write the log buffer to the redo log file. When the LGWR has finished writing, it will post the user session.
Wait Time : The wait time includes the writing of the log buffer and the post.
Parameter:
buffer# The number of the physical buffer in the redo
log buffer that needs to be synchronized
|
| log switch/archive |
Used as part of the ALTER SYSTEM ARCHIVE LOG CHANGE scn statement.
The session waits for the current log from all open threads to be archived.
Wait Time : Wait for up to 10 seconds
Parameter:
thread# The thread number of the thread that is
currently archiving its current log
|
| switch logfile command |
The session waits on the user command SWITCH LOGFILE to complete.
Wait Time : 5 seconds
Parameters: None
|
| free global transaction table entry |
The session is waiting for a free slot in the global transaction table
(used by the Distributed Database option). It will wait for 1 second and try again.
Wait Time : 1 second
Parameter:
tries The number of times the session tried to find a free
slot in the global transaction table
|
| free process state object |
Used during the creation of a process.
The session will scan the process table and look for a free
process slot. If none can be found, PMON is posted to
check if all the processes currently in the process table are still alive. If there are dead processes, then PMON will
clean them and make the process slot available to new
processes. The waiting process will then rescan the process
table to find the new slot.
Wait Time : 1 second
Parameters: None
|
| global cache busy |
The session waits to convert a buffer from
Shared Current to Exclusive Current status.
Wait Time : 1 second
Parameters: file#, block#
le
|
| global cache lock cleanup |
PMON is waiting for an LCK process to cleanup the lock context after a
foreground process died while doing a global cache lock operation.
Wait Time : 1 second
Parameters: file#, block#
lenum
|
| global cache freelist wait |
All releasable locks are used and a new one has been requested.
To make a resource element available, a resource element is pinged.
Wait Time : The duration of the resource get operation to ping the resource element
Parameters: None
|
| global cache null to s |
The session waits for a resource convert from NULL to
SHARED mode on the block identified by file# and block#.
Wait Time : 1 second
Parameters: file#, block#
class
|
| global cache null to x |
The session waits for a resource convert from NULL to
EXCLUSIVE mode on the block identified by file# and block#.
Wait Time : 1 second
Parameters: file#, block#
lenum
|
| global cache open s |
The session waits for a resource get in SHARED mode on the
block identified by file# and block#.
Wait Time : 1 second
Parameters: file#, block#
|
| global cache open x |
The session waits for a resource get in EXCLUSIVE mode
on the block identified by file# and block#.
Wait Time : 1 second
Parameters: file#, block#
lenum
|
| global cache s to x |
The session waits for a resource convert from SHARED to
EXCLUSIVE mode on the block identified by file# and block#.
Wait Time : 1 second
Parameters: file#, block#
lenum
|
| pending global transaction(s) |
This event should happen only during testing.
The session waits for pending transactions to clear.
Wait Time : 30 seconds
Parameter:
scans
Number of times the session has scanned the PENDING_TRANS$ table
|
| parallel execution create server |
Used when creating or starting a parallel execution slave.
Wait Time : The time it takes to start all of the requested parallel execution slaves
Parameters:
nservers The number of parallel execution slaves that are being started
sleeptime Time it takes to get the processes started. The process should be started within sleeptime
enqueue The number of blocks to read
|
| parallel execution dequeue wait |
The process is waiting for a message during a parallel execute.
Wait Time : The wait time depends on how quickly the message arrives.
Wait times can vary, but it will normally be a short period of time.
Parameters:
reason The reason for dequeuing
sleeptime The amount of time that the session slept
loop The total number of times that the session has slept
|
| parallel execution qref latch |
Each parallel execution process has a parallel execution qref latch,
which needs to be acquired before the queue buffers can be manipulated.
Wait Time : Wait up to 1 second
Parameters
function Indicates the type of wait that the session is doing
sleeptime The amount of time that the session waits (in hundredths of a second)
qref The address of the process queue for which the session is waits
|
| parallel execution server shutdown |
During normal or immediate shutdown the parallel execution slaves are
posted to shutdown cleanly. If any parallel execution slaves
are still alive after 10 seconds, they are killed.
Wait Time : Wait up to 0.5 seconds
Parameters:
nalive The number of parallel execution slaves that are still running
sleeptime The total sleeptime since the session started to wait on this event
loop The number of times the session waited for this event
|
| parallel execution signal server |
This event occurs only in Exclusive mode.
The query coordinator is signalling the Query Slaves that an error has occurred.
Wait Time : 0.5 seconds
Parameters:
serial The serial number of the slave process queue
error The error that has occurred
nbusy The number of slave processes that are still busy
|
| rdbms ipc message |
The background processes (LGWR, DBWR, LMS0) use this event to indicate that they are idle
and are waiting for the foreground processes to send them an IPC message to do some work.
Wait Time : Up to 3 seconds. The parameter timeout shows the true sleep time.
Parameter:
timeout The amount of time that the session waits for an IPC message
|
| rdbms ipc message block |
This event indicates that all message blocks are in use and that the
session had to wait for a message block to become available.
Wait Time : Wait up to 60 seconds
Parameters: None
|
| rdbms ipc reply |
This event is used to wait for a reply from one of the background processes.
Wait Time : The wait time is specified by the user and is indicated by the parameter timeout.
Parameters:
from_process The background process for which the session is waiting.
The wait is for a reply to an IPC message sent by the session.
timeout The amount of time in seconds that this process will wait for a reply
redo wait
Defined but not used by the code.
|
| inactive session |
This event is used for two purposes:
Switching sessions
If a time-out period has been specified, then wait that amount of time for the session to be detached.
Killing sessions
From either KILL SESSION or internal request.
Having posted a session that it should kill itself,
wait for up to 1 minute for the session to terminate.
Wait Time : 1 second
Parameters: session#, waited
|
| inactive transaction branch |
The session waits for a transaction branch that is currently used by another session.
Wait Time : 1 second
Parameters:
branch# The serial number of the transaction for which the session is waiting
waited
|
| index block split |
While trying to find an index key in an index block,
Oracle noticed that the index block was being split.
Oracle will wait for the split to finish and try to find the key again.
Wait Time : The session will yield the CPU, so there is no actual waiting time
Parameters:
rootdba
The root of the index
level
This is the level of the block that the session is trying to split in the index.
The leaf blocks are level 0. If the level is > 0, it is a branch block.
(The root block can be considered a special branch block).
childdba
The block that the session is trying to split
|
| instance recovery |
The session waits for SMON to finish the instance,
transaction recovery, or sort segment cleanup.
Wait Time : The wait time can vary and depends on the amount of recovery needed
Parameter:
undo segment#
If the value is 0, SMON is probably performing instance recovery.
If P1 > 0, use this query to find the undo segment:
select * from v$rollstat where usn = undo segment#;
|
| instance state change |
The session waits for SMON to enable or disable cache or transaction recovery.
This usually happens during ALTER DATABASE OPEN or CLOSE.
Wait Time : Wait time depends on the amount of time the action takes (that is, the amount of recovery needed)
Parameters:
layer
This value can be 1 or 2. If 1, it means that the transaction layer wants
transaction recovery to be performed.
If 2, it means that cache recovery will be performed.
value This value can be 0 (disable) or 1 (enable)
waited The number of seconds waited so far
|
| pipe get |
The session waits for a message to be received on the pipe or for the pipe timer to expire.
Wait Time : There is a 5 second wake up (check) and the pipe timer set by the user
Parameters:
handle address The library cache object handle for this pipe
buffer length The length of the buffer
timeout The pipe timer set by the user
|
| pipe put |
The session waits for the pipe send timer to expire or for space to be made available in the pipe.
Wait Time : There is the 5 second wakeup (check) and the user-supplied timeout value
Parameters:
handle address
The library cache object handle for this pipe
record length
The length of the record or buffer that has been put into the pipe
timeout
The pipe timer set by the user
|
| PL/SQL lock timer |
This event is called through the DBMSLOCK.SLEEP procedure
or USERLOCK.SLEEP procedure.
This event will most likely originate from procedures written by a user.
Wait Time : The wait time is in hundredths of seconds and is dependent on the user context
Parameter:
duration The duration that the user specified in the DBMS_LOCK.SLEEP
or USER_LOCK.SLEEP procedures
pmon rdomain attach This is the main wait event for PMON.
When PMON is idle, it is waiting on this event.
|
| pmon timer |
This is the main wait event for PMON. When PMON is idle, it is waiting on this event.
Wait Time : Up to 3 seconds, if not posted before
Parameter:
duration The actual amount of time that the PMON is trying to sleep
|
| process startup |
Wait for a shared server, Dispatcher, or other background process to start.
Wait Time : Wait up to 1 second for a background process to start.
If timed out, then re-wait until 5 minutes have passed and signal an error.
If the process has started, the event will acknowledge this.
Parameters:
type The process type that was started
process# The process number of the process being started
waited Cumulative time waited for the process to start
|
| queue messages |
The session is waiting on an empty OLTP queue (Advanced Queuing)
for a message to arrive so that the session can dequeue that message.
Wait Time : The amount of time that the session wants to wait is determined by the parameter wait time
Parameters:
queue id The ID of the OLTP queue for which this session is waiting
process# The process number of the process in which this session runs
wait time The intended wait time for this session
|
| scginq AST call |
Called by the session to find the highest lock mode that is held on a resource.
Wait Time : Wait up to 0.2 seconds, but the wait will continue until the NULL mode Acquisition AST has fired.
Parameters: None
|
| single-task message |
When running single task, this event indicates that the session waits for the client side of the executable.
Wait Time : Total elapsed time that this session spent in the user application
Parameters: None
|
| smon timer |
This is the main idle event for SMON. SMON will be waiting on this event most
of the time until it times out or is posted by another process.
Wait Time : 5 minutes (300 seconds)
Parameters:
sleeptime The amount of time that SMON tries to wait on this event in seconds
failed The number of times SMON was posted when there some kind of error
|
| timer in sksawat |
The session waits for the Archiver (ARCH) asynchronous I/O to complete.
Wait Time : 0.01 seconds
Parameters: None
|
| transaction |
Wait for a blocking transaction to be rolled back.
Continue waiting until the transaction has been rolled back.
Wait Time : 1 second
Parameters:
undo seg# The rollback segment ID
slot# The slot ID inside the rollback segment
wrap# The sequence number that is incremented for each transaction
count The number of times that the session has waited on this transaction
|
| unbound tx |
The session waits to see if there are any transactions that have been started but do not have a Rollback Segment associated with them.
Wait Time : 1 second
Parameters: None
|
| virtual circuit status |
The session waits for a virtual circuit to return a message type indicated by status.
Wait Time : 30 seconds
Parameters
circuit# Indicates the virtual circuit# being waited on
status Indicates what the session is waiting for
|
| WMON goes to sleep |
WMON is the UNIX-specific Wait Monitor, that can be used to
reduce the number of system calls related to setting timers for
posting or waiting in Oracle. You need to set an initialization parameter
that enables the WMON process.
Wait Time : Depends on the next timeout
Parameters: None
|
| write complete waits |
The session waits for a buffer to be written.
The write is caused by normal aging or by a cross-instance call.
Wait Time : 1 second
Parameters:
file# The rollback segment id that contains the transaction that is being rolled back
block# The transaction flags (options) set for the transaction that is being rolled back
id Identifies the reason for waiting
|
| writes stopped by instance recovery or database suspension |
The session is blocked until the instance that started Instance Recovery is finished.
Wait Time : 5 seconds
Parameters
bythread# The rollback segment id that contains the transaction that is being rolled back
ourthread# The current instance thread number
|