ENQUEUE TYPE ORACLE

EQ_NAME              EQ_TYPE              REQ_REASON           REQ_DESCRIPTION                                                                                                                          
-------------------- -------------------- -------------------- --------------------                                                                                                                     
WLM Plan Operations  WM                   WLM Plan activation  Synchronizes new WLM                                                                                                                     
                                                                Plan activation                                                                                                                         
                                                                                                                                                                                                        
Cross-Instance Call  CI                   contention           Coordinates cross-in                                                                                                                     
Invocation                                                     stance function invo                                                                                                                     
                                                               cations                                                                                                                                  
                                                                                                                                                                                                        
Process Startup      PR                   contention           Synchronizes process                                                                                                                     
                                                                startup                                                                                                                                 
                                                                                                                                                                                                        
Planned Draining RAC DE                   Update Draining Test contention                                                                                                                               
 enqueue                                                                                                                                                                                                
                                                                                                                                                                                                        
Parameter            PE                   contention           Synchronizes system                                                                                                                      
                                                               parameter updates                                                                                                                        
                                                                                                                                                                                                        
Global Parameter     PG                   contention           Synchronizes global                                                                                                                      
                                                               system parameter upd                                                                                                                     
                                                               ates                                                                                                                                     
                                                                                                                                                                                                        
File Object          FP                   global fob contentio Synchronizes various                                                                                                                     
                                          n                     File Object(FOB) op                                                                                                                     
                                                               erations                                                                                                                                 
                                                                                                                                                                                                        
Block Repair/Resilve RE                   block repair content Synchronize block re                                                                                                                     
ring                                      ion                  pair/resilvering ope                                                                                                                     
                                                               rations                                                                                                                                  
                                                                                                                                                                                                        
clonedb bitmap file  BM                   clonedb bitmap file  synchronizes clonedb                                                                                                                     
access                                    write                 bitmap file operati                                                                                                                     
                                                               ons                                                                                                                                      
                                                                                                                                                                                                        
Oracle File System O FO                   file system operatio Synchronizes various                                                                                                                     
peration                                  n contention          Oracle File system                                                                                                                      
                                                               operations                                                                                                                               
                                                                                                                                                                                                        
Scheduler            KM                   contention           Synchronizes various                                                                                                                     
                                                                Resource Manager op                                                                                                                     
                                                               erations                                                                                                                                 
                                                                                                                                                                                                        
Scheduler Plan       KT                   contention           Synchronizes accesse                                                                                                                     
                                                               s to the current Res                                                                                                                     
                                                               ource Manager plan                                                                                                                       
                                                                                                                                                                                                        
Calibration          CA                   contention           Synchronizes various                                                                                                                     
                                                                IO calibration runs                                                                                                                     
                                                                                                                                                                                                        
Scheduler Master DBR KD                   determine DBRM maste Determine DBRM maste                                                                                                                     
M                                         r                    r                                                                                                                                        
                                                                                                                                                                                                        
KSV slave startup    PV                   syncstart            Synchronizes slave s                                                                                                                     
                                                               tart_shutdown                                                                                                                            
                                                                                                                                                                                                        
KSV slave startup    PV                   syncshut             Synchronizes instanc                                                                                                                     
                                                               e shutdown_slvstart                                                                                                                      
                                                                                                                                                                                                        
Spare Enqueue 0      SP                   contention 1         (1) due to one-off p                                                                                                                     
                                                               atch                                                                                                                                     
                                                                                                                                                                                                        
Spare Enqueue 0      SP                   contention 2         (2) due to one-off p                                                                                                                     
                                                               atch                                                                                                                                     
                                                                                                                                                                                                        
Spare Enqueue 0      SP                   contention 3         (3) due to one-off p                                                                                                                     
                                                               atch                                                                                                                                     
                                                                                                                                                                                                        
Spare Enqueue 0      SP                   contention 4         (4) due to one-off p                                                                                                                     
                                                               atch                                                                                                                                     
                                                                                                                                                                                                        
Spare Enqueue 1      SX                   contention 5         (5) due to one-off p                                                                                                                     
                                                               atch                                                                                                                                     
                                                                                                                                                                                                        
Spare Enqueue 1      SX                   contention 6         (6) due to one-off p                                                                                                                     
                                                               atch                                                                                                                                     
                                                                                                                                                                                                        
File Mapping         FM                   contention           Synchronizes access                                                                                                                      
                                                               to global file mappi                                                                                                                     
                                                               ng state                                                                                                                                 
                                                                                                                                                                                                        
Internal Test        XY                   contention           Lock used for intern                                                                                                                     
                                                               al testing                                                                                                                               
                                                                                                                                                                                                        
Service Operations   AS                   service activation   Synchronizes new ser                                                                                                                     
                                                               vice activation                                                                                                                          
                                                                                                                                                                                                        
Property Lock        PD                   contention           Prevents others from                                                                                                                     
                                                                updating the same p                                                                                                                     
                                                               roperty                                                                                                                                  
                                                                                                                                                                                                        
Rolling Migration    RU                   contention           Serializes rolling m                                                                                                                     
                                                               igration operations                                                                                                                      
                                                                                                                                                                                                        
Rolling Migration    RU                   waiting              Results of rolling m                                                                                                                     
                                                               igration CIC                                                                                                                             
                                                                                                                                                                                                        
ksz synch            MX                   sync storage server  Lock held to generat                                                                                                                     
                                          info                 e a response to the                                                                                                                      
                                                               storage server infor                                                                                                                     
                                                               mation request when                                                                                                                      
                                                               an instance is start                                                                                                                     
                                                               ing up                                                                                                                                   
                                                                                                                                                                                                        
read_write_snapshot  WN                   rw snapshot synchron Synchronizes snapsho                                                                                                                     
                                          ization              t file creation                                                                                                                          
                                                                                                                                                                                                        
repopulation file ac ZX                   repopulation file wr synchronizes file op                                                                                                                     
cess                                      ite                  erations during repo                                                                                                                     
                                                               pulation                                                                                                                                 
                                                                                                                                                                                                        
Kernel Service ACL   KA                   ACL control status   Get ACL control stat                                                                                                                     
                                                               us lock                                                                                                                                  
                                                                                                                                                                                                        
Reader Farm SQL Isol RI                   Reader Farm SQL Isol Reader Farm                                                                                                                              
ation                                     ation                                                                                                                                                         
                                                                                                                                                                                                        
KJCI Serialization E KI                   contention           Synchronizes Cross-I                                                                                                                     
nqueue                                                         nstance Calls                                                                                                                            
                                                                                                                                                                                                        
Application Continui AC                   acquiring partition  Synchronizes partiti                                                                                                                     
ty                                        id                   on id                                                                                                                                    
                                                                                                                                                                                                        
Controlfile Transact CF                   contention           Synchronizes accesse                                                                                                                     
ion                                                            s to the controlfile                                                                                                                     
                                                                                                                                                                                                        
Suspend Writes       SW                   contention           Coordinates the 'alt                                                                                                                     
                                                               er system suspend' o                                                                                                                     
                                                               peration                                                                                                                                 
                                                                                                                                                                                                        
Database Suspend     DS                   contention           Prevents a database                                                                                                                      
                                                               suspend during LMON                                                                                                                      
                                                               reconfiguration                                                                                                                          
                                                                                                                                                                                                        
Tablespace Checkpoin TC                   contention           Lock held to guarant                                                                                                                     
t                                                              ee uniqueness of a t                                                                                                                     
                                                               ablespace checkpoint                                                                                                                     
                                                                                                                                                                                                        
Tablespace Checkpoin TC                   contention2          Lock of setup of a u                                                                                                                     
t                                                              nqiue tablespace che                                                                                                                     
                                                               ckpoint in null mode                                                                                                                     
                                                                                                                                                                                                        
Buffer Cache PreWarm PW                   perwarm status in db DBWR 0 holds enqueue                                                                                                                     
                                          w0                    indicating prewarme                                                                                                                     
                                                               d buffers present in                                                                                                                     
                                                                cache                                                                                                                                   
                                                                                                                                                                                                        
Buffer Cache PreWarm PW                   flush prewarm buffer Direct Load needs to                                                                                                                     
                                          s                     flush prewarmed buf                                                                                                                     
                                                               fers if DBWR 0 holds                                                                                                                     
                                                                enqueue                                                                                                                                 
                                                                                                                                                                                                        
Multiple Object Reus RO                   contention           Coordinates flushing                                                                                                                     
e                                                               of multiple objects                                                                                                                     
                                                                                                                                                                                                        
Multiple Object Reus RO                   fast object reuse    Coordinates fast obj                                                                                                                     
e                                                              ect reuse                                                                                                                                
                                                                                                                                                                                                        
Multiple Object Chec KO                   fast object checkpoi Coordinates fast obj                                                                                                                     
kpoint                                    nt                   ect checkpoint                                                                                                                           
                                                                                                                                                                                                        
Reuse Block Range    CR                   block range reuse ck Coordinates fast blo                                                                                                                     
                                          pt                   ck range reuse ckpt                                                                                                                      
                                                                                                                                                                                                        
Tablespace Rekey     TR                   serialize TS rekeys  Performing online ta                                                                                                                     
                                                               blespace rekey                                                                                                                           
                                                                                                                                                                                                        
Tablespace Rekey     TR                   database key open ch Database encryption                                                                                                                      
                                          eck                  key open check                                                                                                                           
                                                                                                                                                                                                        
Tablespace Rekey     TR                   serialize system rek Performing online ta                                                                                                                     
                                          eys                  blespace rekey with                                                                                                                      
                                                               db key                                                                                                                                   
                                                                                                                                                                                                        
Buddy Instance Conte BU                   recovery set constru RMS0 constructing rc                                                                                                                     
xt                                        ct                   overy set                                                                                                                                
                                                                                                                                                                                                        
Buddy Instance Conte BU                   recovery set takeove instance recovery ta                                                                                                                     
xt                                        r                    king-over recovery s                                                                                                                     
                                                               et                                                                                                                                       
                                                                                                                                                                                                        
Being Written Redo L WL                   Test access/locking  Testing redo transpo                                                                                                                     
og                                                             rt access/locking                                                                                                                        
                                                                                                                                                                                                        
Being Written Redo L WL                   RAC-wide SGA initial krsh_rsga_initialize                                                                                                                     
og                                        ize                   access to RAC-wide                                                                                                                      
                                                               SGA                                                                                                                                      
                                                                                                                                                                                                        
Being Written Redo L WL                   RAC-wide SGA write   krsh_rsga_write acce                                                                                                                     
og                                                             ss to RAC-wide SGA                                                                                                                       
                                                                                                                                                                                                        
Being Written Redo L WL                   RAC-wide SGA dump    krsh_dump_rsga acces                                                                                                                     
og                                                             s to RAC-wide SGA                                                                                                                        
                                                                                                                                                                                                        
Purge SRL            SA                   standby redo logfile Coordinates access t                                                                                                                     
                                          s                    o SRL by RFS and rec                                                                                                                     
                                                               overy process                                                                                                                            
                                                                                                                                                                                                        
Being Written Redo L WL                   Far Sync Fail Over   Exclude multiple sim                                                                                                                     
og                                                             ultaneous failovers                                                                                                                      
                                                                                                                                                                                                        
Purge SRL            SA                   MRP SRL access       Coordinates access t                                                                                                                     
                                                               o SRL by RFS and rec                                                                                                                     
                                                               overy process                                                                                                                            
                                                                                                                                                                                                        
Being Written Redo L WL                   redo_db table update Serialize update to                                                                                                                      
og                                                             redo_db table                                                                                                                            
                                                                                                                                                                                                        
Being Written Redo L WL                   redo_log table updat Serialize update to                                                                                                                      
og                                        e                    redo_log table                                                                                                                           
                                                                                                                                                                                                        
Being Written Redo L WL                   Switchover To Primar One and only one pro                                                                                                                     
og                                        y                    cess executing switc                                                                                                                     
                                                               hover to primary                                                                                                                         
                                                                                                                                                                                                        
Being Written Redo L WL                   RFS global state con Serialize access to                                                                                                                      
og                                        tention              RFS global state                                                                                                                         
                                                                                                                                                                                                        
Being Written Redo L WL                   SNA access/locking   Sync NoAffirm access                                                                                                                     
og                                                             /locking                                                                                                                                 
                                                                                                                                                                                                        
Being Written Redo L WL                   Network Throttle     Coordinate network t                                                                                                                     
og                                                             hrottle SGA access                                                                                                                       
                                                                                                                                                                                                        
LNS archiving log    WR                   contention           Coordinates access t                                                                                                                     
                                                               o logs by Async LNS                                                                                                                      
                                                               and ARCH/FG                                                                                                                              
                                                                                                                                                                                                        
RFS Logminer FLC     RZ                   add element          Synchronizes access                                                                                                                      
                                                               to the foreign log c                                                                                                                     
                                                               ache while a structu                                                                                                                     
                                                               re is being inserted                                                                                                                     
                                                                                                                                                                                                        
RFS Logminer FLC     RZ                   remove element       Synchronizes access                                                                                                                      
                                                               to the foreign log c                                                                                                                     
                                                               ache while a structu                                                                                                                     
                                                               re is being removed                                                                                                                      
                                                                                                                                                                                                        
Being Written Redo L WL                   contention           Coordinates access t                                                                                                                     
og                                                             o redo log files and                                                                                                                     
                                                                archive logs                                                                                                                            
                                                                                                                                                                                                        
Redo Log Nab Computa RN                   contention           Coordinates nab comp                                                                                                                     
tion                                                           utations of online l                                                                                                                     
                                                               ogs during recovery                                                                                                                      
                                                                                                                                                                                                        
Datafile Online in R DF                   contention           Enqueue held by fore                                                                                                                     
AC                                                             ground or DBWR when                                                                                                                      
                                                               a datafile is brough                                                                                                                     
                                                               t online in RAC                                                                                                                          
                                                                                                                                                                                                        
Instance State       IS                   contention           Enqueue used to sync                                                                                                                     
                                                               hronize instance sta                                                                                                                     
                                                               te changes                                                                                                                               
                                                                                                                                                                                                        
PDB Instance State   IP                   open/close PDB       Enqueue used to sync                                                                                                                     
                                                               hronize instance sta                                                                                                                     
                                                               te changes for PDBs                                                                                                                      
                                                                                                                                                                                                        
PDB Recovery Operati PX                   PDB instance recover Enqueue used to sync                                                                                                                     
ons                                       y                    hronize PDB shutdown                                                                                                                     
                                                                abort and PDB insta                                                                                                                     
                                                               nce recovery                                                                                                                             
                                                                                                                                                                                                        
File Set / Dictionar FS                   contention           Enqueue used to sync                                                                                                                     
y Check                                                        hronize recovery and                                                                                                                     
                                                                file operations or                                                                                                                      
                                                               synchronize dictiona                                                                                                                     
                                                               ry check                                                                                                                                 
                                                                                                                                                                                                        
File Set / Dictionar FS                   online log operation Enqueue used to sync                                                                                                                     
y Check                                                        hronize LGWR cached                                                                                                                      
                                                               open online logs and                                                                                                                     
                                                                online log clear/dr                                                                                                                     
                                                               op                                                                                                                                       
                                                                                                                                                                                                        
Database Mount/Open  DM                   contention           Enqueue held by fore                                                                                                                     
                                                               ground or DBWR to sy                                                                                                                     
                                                               nchronize database m                                                                                                                     
                                                               ount/open or pluggab                                                                                                                     
                                                               le database open wit                                                                                                                     
                                                               h other operations                                                                                                                       
                                                                                                                                                                                                        
Database Mount/Open  DM                   access control       Enqueue held by fore                                                                                                                     
                                                               ground or GEN0 to sy                                                                                                                     
                                                               nchronizepluggable d                                                                                                                     
                                                               atabase open/close a                                                                                                                     
                                                               mong all HARIM insta                                                                                                                     
                                                               nces                                                                                                                                     
                                                                                                                                                                                                        
Resilver / Repair    RP                   contention           Enqueue held when re                                                                                                                     
                                                               silvering is needed                                                                                                                      
                                                               or when datablock is                                                                                                                     
                                                                repaired from mirro                                                                                                                     
                                                               r                                                                                                                                        
                                                                                                                                                                                                        
Online Datafile Move MV                   datafile move        Held during online d                                                                                                                     
                                                               atafile move operati                                                                                                                     
                                                               on or cleanup                                                                                                                            
                                                                                                                                                                                                        
Redo Thread          RT                   contention           Thread locks held by                                                                                                                     
                                                                LGWR, DBW0, and RVW                                                                                                                     
                                                               R to indicate mounte                                                                                                                     
                                                               d or open status                                                                                                                         
                                                                                                                                                                                                        
Redo Thread          RT                   thread internal enab Thread locks held by                                                                                                                     
                                          le/disable            CKPT to synchronize                                                                                                                     
                                                                thread enable and d                                                                                                                     
                                                               isable                                                                                                                                   
                                                                                                                                                                                                        
Instance Recovery    IR                   contention           Synchronizes instanc                                                                                                                     
                                                               e recovery                                                                                                                               
                                                                                                                                                                                                        
Instance Recovery    IR                   contention2          Synchronizes paralle                                                                                                                     
                                                               l instance recovery                                                                                                                      
                                                               and shutdown immedia                                                                                                                     
                                                               te                                                                                                                                       
                                                                                                                                                                                                        
Instance Recovery    IR                   global serialization serialize instance r                                                                                                                     
                                                               ecovery globally                                                                                                                         
                                                                                                                                                                                                        
Instance Recovery    IR                   local serialization  serialize instance r                                                                                                                     
                                                               ecovery with local d                                                                                                                     
                                                               ismount                                                                                                                                  
                                                                                                                                                                                                        
Instance Recovery    IR                   arbitrate instance r arbitrate parallel i                                                                                                                     
                                          ecovery              nstance recovery                                                                                                                         
                                                                                                                                                                                                        
Media Recovery       MR                   contention           Lock used to coordin                                                                                                                     
                                                               ate media recovery w                                                                                                                     
                                                               ith other uses of da                                                                                                                     
                                                               tafiles                                                                                                                                  
                                                                                                                                                                                                        
Media Recovery       MR                   standby role transit Lock used to disallo                                                                                                                     
                                          ion                  w concurrent standby                                                                                                                     
                                                                role transition att                                                                                                                     
                                                               empt                                                                                                                                     
                                                                                                                                                                                                        
Media Recovery       MR                   multi instance redo  Lock used to disallo                                                                                                                     
                                          apply                w concurrent recover                                                                                                                     
                                                               y attempt when MIRA                                                                                                                      
                                                               active                                                                                                                                   
                                                                                                                                                                                                        
Media Recovery       MR                   any role transition  Lock used to disallo                                                                                                                     
                                                               w any concurrent rol                                                                                                                     
                                                               e transition attempt                                                                                                                     
                                                                                                                                                                                                        
Media Recovery       MR                   PDB open             Lock used to coordin                                                                                                                     
                                                               ate media recovery w                                                                                                                     
                                                               ith other uses of PD                                                                                                                     
                                                               B datafiles                                                                                                                              
                                                                                                                                                                                                        
Media Recovery       MR                   datafile online      Enqueue used to coor                                                                                                                     
                                                               dinate datafile offl                                                                                                                     
                                                               ine in RAC                                                                                                                               
                                                                                                                                                                                                        
Media Recovery       MR                   adg instance recover Synchronizes multi i                                                                                                                     
                                          y                    nstance recovery cle                                                                                                                     
                                                               anup with adg instan                                                                                                                     
                                                               ce recovery                                                                                                                              
                                                                                                                                                                                                        
Media Recovery       MR                   preplugin recovery   Lock used to disallo                                                                                                                     
                                                               w concurrent preplug                                                                                                                     
                                                               in recovery in the s                                                                                                                     
                                                               ame PDB                                                                                                                                  
                                                                                                                                                                                                        
Media Recovery       MR                   datafile pre-create  Enqueue for datafile                                                                                                                     
                                                                pre-create task dur                                                                                                                     
                                                               ing standby recovery                                                                                                                     
                                                                                                                                                                                                        
Backup/Restore       BR                   file shrink          Lock held to prevent                                                                                                                     
                                                                file from decreasin                                                                                                                     
                                                               g in physical size d                                                                                                                     
                                                               uring RMAN backup                                                                                                                        
                                                                                                                                                                                                        
Backup/Restore       BR                   proxy-copy           Lock held to allow c                                                                                                                     
                                                               leanup from backup m                                                                                                                     
                                                               ode during an RMAN p                                                                                                                     
                                                               roxy-copy backup                                                                                                                         
                                                                                                                                                                                                        
Backup/Restore       BR                   multi-section restor Lock held to seriali                                                                                                                     
                                          e header             ze file header acces                                                                                                                     
                                                               s during multi-secti                                                                                                                     
                                                               on restore                                                                                                                               
                                                                                                                                                                                                        
Backup/Restore       BR                   multi-section restor Lock held to seriali                                                                                                                     
                                          e section            ze section access du                                                                                                                     
                                                               ring multi-section r                                                                                                                     
                                                               estore                                                                                                                                   
                                                                                                                                                                                                        
Backup/Restore       BR                   space info datafile  Lock held to prevent                                                                                                                     
                                          hdr update            multiple process to                                                                                                                     
                                                                update the headers                                                                                                                      
                                                               at the same time                                                                                                                         
                                                                                                                                                                                                        
Backup/Restore       BR                   request autobackup   Lock held to request                                                                                                                     
                                                                controlfile autobac                                                                                                                     
                                                               kups                                                                                                                                     
                                                                                                                                                                                                        
Backup/Restore       BR                   perform autobackup   Lock held to perform                                                                                                                     
                                                                a new controlfile a                                                                                                                     
                                                               utobackup                                                                                                                                
                                                                                                                                                                                                        
Backup/Restore       BR                   perform catalog reco Lock held to seriali                                                                                                                     
                                          very area            ze catalog recovery                                                                                                                      
                                                               area search                                                                                                                              
                                                                                                                                                                                                        
NID                  ID                   contention           Lock held to prevent                                                                                                                     
                                                                other processes fro                                                                                                                     
                                                               m performing control                                                                                                                     
                                                               file transaction whi                                                                                                                     
                                                               le NID is running                                                                                                                        
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare1        Backup spare1                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare2        Backup spare2                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare3        Backup spare3                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare4        Backup spare4                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare5        Backup spare5                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare6        Backup spare6                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare7        Backup spare7                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare8        Backup spare8                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare9        Backup spare9                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Backup/Restore spare BS                   Backup spare0        Backup spare0                                                                                                                            
 enq                                                                                                                                                                                                    
                                                                                                                                                                                                        
Auto BMR             AB                   ABMR process start/s Lock held to ensure                                                                                                                      
                                          top                  that only one ABMR i                                                                                                                     
                                                               s started in the clu                                                                                                                     
                                                               ster                                                                                                                                     
                                                                                                                                                                                                        
Auto BMR             AB                   ABMR process initial Lock held to ensure                                                                                                                      
                                          ized                 that ABMR process is                                                                                                                     
                                                                initialized                                                                                                                             
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA lock db        Perform DB storage a                                                                                                                     
                                                               llocations on the Re                                                                                                                     
                                                               covery Appliance                                                                                                                         
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA lock storage l Lock to use reserved                                                                                                                     
                                          oc                    storage to perform                                                                                                                      
                                                               in line purging                                                                                                                          
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA lock timer que Lock to perform time                                                                                                                     
                                          ue                   r functions on the R                                                                                                                     
                                                               ecovery Appliance                                                                                                                        
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA lock scheduler Lock to perform job                                                                                                                      
                                                               scheduling functions                                                                                                                     
                                                                on the Recovery App                                                                                                                     
                                                               liance                                                                                                                                   
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA lock API       Lock to single strea                                                                                                                     
                                                               m API functions on t                                                                                                                     
                                                               he Recovery Applianc                                                                                                                     
                                                               e                                                                                                                                        
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA quiesce tasks  Lock to prevent new                                                                                                                      
                                                               tasks from executing                                                                                                                     
                                                                                                                                                                                                        
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA check quiesce  Lock to verify that                                                                                                                      
                                          tasks                task execution is no                                                                                                                     
                                                               t being quiesced                                                                                                                         
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA quiesce servle Lock to prevent new                                                                                                                      
                                          ts                   servlet backups                                                                                                                          
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA check servlet  Lock to verify that                                                                                                                      
                                          quiescence           servlet backups are                                                                                                                      
                                                               not being quiesced                                                                                                                       
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA serialize unre Lock to single strea                                                                                                                     
                                          gister db            m unregister db requ                                                                                                                     
                                                               ests                                                                                                                                     
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA run scheduler  Hint that Recovery A                                                                                                                     
                                                               ppliance schedulers                                                                                                                      
                                                               may have new work                                                                                                                        
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA purge storage  Lock to restrict a s                                                                                                                     
                                          loc                  ingle purging thread                                                                                                                     
                                                                per storage locatio                                                                                                                     
                                                               n                                                                                                                                        
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA spare enq 10   ZDLRA spare enq 10                                                                                                                       
ZDLRA Server         ZR                   ZDLRA invalidate pla Lock to allow invali                                                                                                                     
                                          ns                   dation of Recovery A                                                                                                                     
                                                               ppliance plans                                                                                                                           
                                                                                                                                                                                                        
ZDLRA Server         ZR                   ZDLRA protect plans  Lock to protect a Re                                                                                                                     
                                                               covery Appliance pla                                                                                                                     
                                                               n from becoming inva                                                                                                                     
                                                               lid                                                                                                                                      
                                                                                                                                                                                                        
BA Container         BC                   drop container group Group lock held whil                                                                                                                     
                                                               e dropping a contain                                                                                                                     
                                                               er group                                                                                                                                 
                                                                                                                                                                                                        
BA Container         BC                   create container     Container lock held                                                                                                                      
                                                               while creating a con                                                                                                                     
                                                               tainer                                                                                                                                   
                                                                                                                                                                                                        
BA Container         BC                   group - create conta Group lock held whil                                                                                                                     
                                          iner                 e creating a contain                                                                                                                     
                                                               er                                                                                                                                       
                                                                                                                                                                                                        
BA Container         BC                   drop container       Container lock held                                                                                                                      
                                                               while dropping a con                                                                                                                     
                                                               tainer                                                                                                                                   
                                                                                                                                                                                                        
BA Container         BC                   group - create file  Group lock held whil                                                                                                                     
                                                               e creating a contain                                                                                                                     
                                                               ed file                                                                                                                                  
                                                                                                                                                                                                        
BA Contained File Id BI                   create file          Enqueue held while a                                                                                                                     
entification                                                    contained file is c                                                                                                                     
                                                               reated                                                                                                                                   
                                                                                                                                                                                                        
BA Contained File Id BI                   identify file        Enqueue held while a                                                                                                                     
entification                                                    contained file is i                                                                                                                     
                                                               dentified                                                                                                                                
                                                                                                                                                                                                        
BA Contained File Id BI                   delete file          Enqueue held while a                                                                                                                     
entification                                                    contained file is c                                                                                                                     
                                                               leaned up or deleted                                                                                                                     
                                                                                                                                                                                                        
BA Contained File Re BZ                   resize file          Enqueue held while a                                                                                                                     
size                                                            contained file is r                                                                                                                     
                                                               esized                                                                                                                                   
                                                                                                                                                                                                        
BA Group Rebuild/Val BV                   rebuild/validate gro Enqueue held while a                                                                                                                     
idate                                     up                    container group is                                                                                                                      
                                                               rebuilding                                                                                                                               
                                                                                                                                                                                                        
LogMiner             MN                   contention           Synchronizes updates                                                                                                                     
                                                                to the LogMiner dic                                                                                                                     
                                                               tionary and prevents                                                                                                                     
                                                                multiple instances                                                                                                                      
                                                               from preparing the s                                                                                                                     
                                                               ame LogMiner session                                                                                                                     
                                                                                                                                                                                                        
Foreign Log Maintena ZL                   LogMiner foreign log Session-specific loc                                                                                                                     
nce                                        metadata            k to serialize addit                                                                                                                     
                                                               ions or removals fro                                                                                                                     
                                                               m the foreign log se                                                                                                                     
                                                               ction                                                                                                                                    
                                                                                                                                                                                                        
Transportable Tables PL                   contention           Coordinates plug-in                                                                                                                      
pace                                                           operation of transpo                                                                                                                     
                                                               rtable tablespaces                                                                                                                       
                                                                                                                                                                                                        
Pluggable Database   CP                   Pluggable database r Synchronization                                                                                                                          
                                          esetlogs                                                                                                                                                      
                                                                                                                                                                                                        
LogicalStandby       SB                   logical standby meta Synchronizes Logical                                                                                                                     
                                          data                  Standby metadata op                                                                                                                     
                                                               erations                                                                                                                                 
                                                                                                                                                                                                        
LogicalStandby       SB                   table instantiation  Synchronizes table i                                                                                                                     
                                                               nstantiation and EDS                                                                                                                     
                                                                operations                                                                                                                              
                                                                                                                                                                                                        
Quiesce / Force Logg XR                   quiesce database     Lock held during dat                                                                                                                     
ing                                                            abase quiesce                                                                                                                            
                                                                                                                                                                                                        
Quiesce / Force Logg XR                   database force loggi Lock held during dat                                                                                                                     
ing                                       ng                   abase force logging                                                                                                                      
                                                               mode                                                                                                                                     
                                                                                                                                                                                                        
Block Change Trackin CT                   global space managem Lock held during cha                                                                                                                     
g                                         ent                  nge tracking space m                                                                                                                     
                                                               anagement operations                                                                                                                     
                                                                that affect the ent                                                                                                                     
                                                               ire change tracking                                                                                                                      
                                                               file                                                                                                                                     
                                                                                                                                                                                                        
Block Change Trackin CT                   local space manageme Lock held during cha                                                                                                                     
g                                         nt                   nge tracking space m                                                                                                                     
                                                               anagement operations                                                                                                                     
                                                                that affect just th                                                                                                                     
                                                               e data for one threa                                                                                                                     
                                                               d                                                                                                                                        
                                                                                                                                                                                                        
Block Change Trackin CT                   change stream owners Lock held by one ins                                                                                                                     
g                                         hip                  tance while change t                                                                                                                     
                                                               racking is enabled,                                                                                                                      
                                                               to guarantee access                                                                                                                      
                                                               to thread-specific r                                                                                                                     
                                                               esources                                                                                                                                 
                                                                                                                                                                                                        
Block Change Trackin CT                   state                Lock held while enab                                                                                                                     
g                                                              ling or disabling ch                                                                                                                     
                                                               ange tracking, to en                                                                                                                     
                                                               sure that it is only                                                                                                                     
                                                                enabled or disabled                                                                                                                     
                                                                by one user at a ti                                                                                                                     
                                                               me                                                                                                                                       
                                                                                                                                                                                                        
Block Change Trackin CT                   state change gate 1  Lock held while enab                                                                                                                     
g                                                              ling or disabling ch                                                                                                                     
                                                               ange tracking in RAC                                                                                                                     
                                                                                                                                                                                                        
Block Change Trackin CT                   state change gate 2  Lock held while enab                                                                                                                     
g                                                              ling or disabling ch                                                                                                                     
                                                               ange tracking in RAC                                                                                                                     
                                                                                                                                                                                                        
Block Change Trackin CT                   CTWR process start/s Lock held to ensure                                                                                                                      
g                                         top                  that only one CTWR p                                                                                                                     
                                                               rocess is started in                                                                                                                     
                                                                a single instance                                                                                                                       
                                                                                                                                                                                                        
Block Change Trackin CT                   reading              Lock held to ensure                                                                                                                      
g                                                              that change tracking                                                                                                                     
                                                                data remains in exi                                                                                                                     
                                                               stence until a reade                                                                                                                     
                                                               r is done with it                                                                                                                        
                                                                                                                                                                                                        
Reclaimable Space    RS                   file delete          Lock held to prevent                                                                                                                     
                                                                file from accessing                                                                                                                     
                                                                during space reclai                                                                                                                     
                                                               mation                                                                                                                                   
                                                                                                                                                                                                        
Reclaimable Space    RS                   record reuse         Lock held to prevent                                                                                                                     
                                                                file from accessing                                                                                                                     
                                                                while reusing circu                                                                                                                     
                                                               lar record                                                                                                                               
                                                                                                                                                                                                        
Reclaimable Space    RS                   prevent file delete  Lock held to prevent                                                                                                                     
                                                                deleting file to re                                                                                                                     
                                                               claim space                                                                                                                              
                                                                                                                                                                                                        
Reclaimable Space    RS                   prevent aging list u Lock held to prevent                                                                                                                     
                                          pdate                 aging list update                                                                                                                       
                                                                                                                                                                                                        
Reclaimable Space    RS                   persist alert level  Lock held to make al                                                                                                                     
                                                               ert level persistent                                                                                                                     
                                                                                                                                                                                                        
Reclaimable Space    RS                   read alert level     Lock held to read al                                                                                                                     
                                                               ert level                                                                                                                                
                                                                                                                                                                                                        
Reclaimable Space    RS                   write alert level    Lock held to write a                                                                                                                     
                                                               lert level                                                                                                                               
                                                                                                                                                                                                        
Flashback database l FL                   Flashback database l Synchronization                                                                                                                          
og                                        og                                                                                                                                                            
                                                                                                                                                                                                        
Flashback database l FL                   Flashback db command Enqueue used to sync                                                                                                                     
og                                                             hronize Flashback Da                                                                                                                     
                                                               tabase and and delet                                                                                                                     
                                                               ion of flashback log                                                                                                                     
                                                               s.                                                                                                                                       
                                                                                                                                                                                                        
Flashback Database   FD                   Marker generation    Synchronization                                                                                                                          
Flashback Database   FD                   Tablespace flashback Synchronization                                                                                                                          
                                           on/off                                                                                                                                                       
                                                                                                                                                                                                        
Flashback Database   FD                   Flashback coordinato Synchronization                                                                                                                          
                                          r                                                                                                                                                             
                                                                                                                                                                                                        
Flashback Database   FD                   Flashback on/off     Synchronization                                                                                                                          
Flashback Database   FD                   Restore point create Synchronization                                                                                                                          
                                          /drop                                                                                                                                                         
                                                                                                                                                                                                        
Flashback Database   FD                   Flashback logical op Synchronization                                                                                                                          
                                          erations                                                                                                                                                      
                                                                                                                                                                                                        
DML                  TM                   contention           Synchronizes accesse                                                                                                                     
                                                               s to an object                                                                                                                           
                                                                                                                                                                                                        
Space Transaction    ST                   contention           Synchronizes space m                                                                                                                     
                                                               anagement activities                                                                                                                     
                                                                in dictionary-manag                                                                                                                     
                                                               ed tablespaces                                                                                                                           
                                                                                                                                                                                                        
Instance Undo        TA                   contention           Serializes operation                                                                                                                     
                                                               s on undo segments a                                                                                                                     
                                                               nd undo tablespaces                                                                                                                      
                                                                                                                                                                                                        
Transaction          TX                   contention           Lock held by a trans                                                                                                                     
                                                               action to allow othe                                                                                                                     
                                                               r transactions to wa                                                                                                                     
                                                               it for it                                                                                                                                
                                                                                                                                                                                                        
Transaction          TX                   row lock contention  Lock held on a parti                                                                                                                     
                                                               cular row by a trans                                                                                                                     
                                                               action to prevent ot                                                                                                                     
                                                               her transactions fro                                                                                                                     
                                                               m modifying it                                                                                                                           
                                                                                                                                                                                                        
Transaction          TX                   allocate ITL entry   Allocating an ITL en                                                                                                                     
                                                               try in order to begi                                                                                                                     
                                                               n a transaction                                                                                                                          
                                                                                                                                                                                                        
Transaction          TX                   index contention     Lock held on an inde                                                                                                                     
                                                               x during a split to                                                                                                                      
                                                               prevent other operat                                                                                                                     
                                                               ions on it                                                                                                                               
                                                                                                                                                                                                        
Cross-Instance Trans TW                   contention           Lock held by one ins                                                                                                                     
action                                                         tance to wait for tr                                                                                                                     
                                                               ansactions on all in                                                                                                                     
                                                               stances to finish                                                                                                                        
                                                                                                                                                                                                        
Undo Segment         US                   contention           Lock held to perform                                                                                                                     
                                                                DDL on the undo seg                                                                                                                     
                                                               ment                                                                                                                                     
                                                                                                                                                                                                        
Kti blr lock         IM                   contention for blr   Serializes block rec                                                                                                                     
                                                               overy for IMU txn                                                                                                                        
                                                                                                                                                                                                        
KTF map table enqueu TD                   KTF dump entries     KTF dumping time/scn                                                                                                                     
e                                                               mappings in SMON_SC                                                                                                                     
                                                               N_TIME table                                                                                                                             
                                                                                                                                                                                                        
KTF broadcast        TE                   KTF broadcast        KTF broadcasting                                                                                                                         
KTCN REG enq         CN                   race with txn        during registration                                                                                                                      
KTCN REG enq         CN                   race with reg        during transaction c                                                                                                                     
                                                               ommit to see concurr                                                                                                                     
                                                               ent registrations                                                                                                                        
                                                                                                                                                                                                        
KTCN REG enq         CN                   race with init       during descriptor in                                                                                                                     
                                                               itialization                                                                                                                             
                                                                                                                                                                                                        
KTUCLO Master Slave  CO                   master slave det     enqueue held by Mast                                                                                                                     
enq                                                            er in Cleanout Optim                                                                                                                     
                                                                                                                                                                                                        
KTFA Recovery        FE                   contention           Serializes flashback                                                                                                                     
                                                                archive recovery                                                                                                                        
                                                                                                                                                                                                        
SGA Log Operation    MC                   Securefile log       Serializes log creat                                                                                                                     
                                                               ion/destruction with                                                                                                                     
                                                                log flushes                                                                                                                             
                                                                                                                                                                                                        
SGA Log-Bkt Flush    MF                   flush bkgnd periodic Serializes flushes f                                                                                                                     
                                                               or a SGA log in bkgn                                                                                                                     
                                                               d                                                                                                                                        
                                                                                                                                                                                                        
SGA Log-Bkt Flush    MF                   creating swap in ins Serializes multiple                                                                                                                      
                                          tance                processes in creatin                                                                                                                     
                                                               g the swap space                                                                                                                         
                                                                                                                                                                                                        
SGA Log-Bkt Flush    MF                   flush space          Serializes flushes f                                                                                                                     
                                                               or a single SGA log                                                                                                                      
                                                               - space lack                                                                                                                             
                                                                                                                                                                                                        
SGA Log-Bkt Flush    MF                   flush client         Serializes flushes f                                                                                                                     
                                                               or a single SGA log                                                                                                                      
                                                               - client                                                                                                                                 
                                                                                                                                                                                                        
SGA Log-Bkt Flush    MF                   flush prior error    Serializes flushes f                                                                                                                     
                                                               or a single SGA log                                                                                                                      
                                                               - error earlier                                                                                                                          
                                                                                                                                                                                                        
SGA Log-Bkt Flush    MF                   flush destroy        Serializes flushes f                                                                                                                     
                                                               or a single SGA log                                                                                                                      
                                                               - destroy                                                                                                                                
                                                                                                                                                                                                        
quiesce enq          ZQ                   register             SMU create                                                                                                                               
quiesce enq          ZQ                   quiesce              quiesce loading                                                                                                                          
Temporary File       TF                   contention           Serializes dropping                                                                                                                      
                                                               of a temporary file                                                                                                                      
                                                                                                                                                                                                        
Default Temporary Ta DT                   contention           Serializes changing                                                                                                                      
blespace                                                       the default temporar                                                                                                                     
                                                               y table spaceand use                                                                                                                     
                                                               r creation                                                                                                                               
                                                                                                                                                                                                        
Segment High Water M HW                   contention           Lock used to broker                                                                                                                      
ark                                                            the high water mark                                                                                                                      
                                                               during parallel inse                                                                                                                     
                                                               rts                                                                                                                                      
                                                                                                                                                                                                        
Critical Block Alloc BE                   Critical Block Alloc Lock used to seriali                                                                                                                     
ation                                     ation                ze allocation of cri                                                                                                                     
                                                               tical blocks                                                                                                                             
                                                                                                                                                                                                        
Temporary Segment    TS                   contention           Serializes accesses                                                                                                                      
                                                               to temp segments                                                                                                                         
                                                                                                                                                                                                        
Format Block         FB                   contention           Ensures that only on                                                                                                                     
                                                               e process can format                                                                                                                     
                                                                data blcoks in auto                                                                                                                     
                                                                segment space manag                                                                                                                     
                                                               ed tablespaces                                                                                                                           
                                                                                                                                                                                                        
Sort Segment         SS                   contention           Ensures that sort se                                                                                                                     
                                                               gments created durin                                                                                                                     
                                                               g parallel DML opera                                                                                                                     
                                                               tions aren't prematu                                                                                                                     
                                                               rely cleaned up                                                                                                                          
                                                                                                                                                                                                        
Shrink Segment       SK                   contention           Serialize shrink of                                                                                                                      
                                                               a segment                                                                                                                                
                                                                                                                                                                                                        
In memory Dispenser  DW                   contention           Serialize in memory                                                                                                                      
                                                               dispenser operations                                                                                                                     
                                                                                                                                                                                                        
SaveUndo Segment     SU                   contention           Serializes access to                                                                                                                     
                                                                SaveUndo Segment                                                                                                                        
                                                                                                                                                                                                        
Tablespace           TT                   contention           Serializes DDL opera                                                                                                                     
                                                               tions on tablespaces                                                                                                                     
                                                                                                                                                                                                        
KTSJ Slave Task Canc SJ                   Slave Task Cancel    Serializes cancellin                                                                                                                     
el                                                             g task executed by s                                                                                                                     
                                                               lave process                                                                                                                             
                                                                                                                                                                                                        
Flush Stat           FH                   contention           Serializes flush of                                                                                                                      
                                                               ILM stats to disk                                                                                                                        
                                                                                                                                                                                                        
in-memory            TZ                   contention           Serialize in-memory                                                                                                                      
                                                               area create/drop                                                                                                                         
                                                                                                                                                                                                        
in-memory segment    IN                   contention           Serialize in-memory                                                                                                                      
                                                               segment create/drop                                                                                                                      
                                                                                                                                                                                                        
in-memory TS         ZB                   contention           Serialize in-memory                                                                                                                      
                                                               tablespace create/dr                                                                                                                     
                                                               op                                                                                                                                       
                                                                                                                                                                                                        
Sequence Cache       SQ                   contention           Lock to ensure that                                                                                                                      
                                                               only one process can                                                                                                                     
                                                                replenish the seque                                                                                                                     
                                                               nce cache                                                                                                                                
                                                                                                                                                                                                        
Direct Loader High W HV                   contention           Lock used to broker                                                                                                                      
ater Mark                                                      the high water mark                                                                                                                      
                                                               during parallel inse                                                                                                                     
                                                               rts                                                                                                                                      
                                                                                                                                                                                                        
Direct Loader Index  DL                   contention           Lock to prevent inde                                                                                                                     
Creation                                                       x DDL during direct                                                                                                                      
                                                               load                                                                                                                                     
                                                                                                                                                                                                        
Hash Queue           HQ                   contention           Synchronizes the cre                                                                                                                     
                                                               ation of new queue I                                                                                                                     
                                                               Ds                                                                                                                                       
                                                                                                                                                                                                        
Queue Page           HP                   contention           Synchronizes accesse                                                                                                                     
                                                               s to queue pages                                                                                                                         
                                                                                                                                                                                                        
Write gather local e WG                   delete fso           acquire lobid local                                                                                                                      
nqueue                                                         enqueue when deletin                                                                                                                     
                                                               g fso                                                                                                                                    
                                                                                                                                                                                                        
Write gather local e WG                   lock fso             acquire lobid local                                                                                                                      
nqueue                                                         enqueue when locking                                                                                                                     
                                                                fso                                                                                                                                     
                                                                                                                                                                                                        
Serialize Lock reque SL                   get lock             sending lock req to                                                                                                                      
st                                                             LCK0                                                                                                                                     
                                                                                                                                                                                                        
Serialize Lock reque SL                   escalate lock        sending lock escalat                                                                                                                     
st                                                             e to LCK0                                                                                                                                
                                                                                                                                                                                                        
Serialize Lock reque SL                   get lock for undo    sending lock req for                                                                                                                     
st                                                              undo to LCK0                                                                                                                            
                                                                                                                                                                                                        
Compression Analyzer ZH                   compression analysis Synchronizes analysi                                                                                                                     
                                                               s and insert into co                                                                                                                     
                                                               mpression$, prevents                                                                                                                     
                                                                multiple threads an                                                                                                                     
                                                               alyzing the same tab                                                                                                                     
                                                               le during a load                                                                                                                         
                                                                                                                                                                                                        
IM segment populate  SZ                   contention           Lock used to seriali                                                                                                                     
                                                               ze in-memory segment                                                                                                                     
                                                                populates                                                                                                                               
                                                                                                                                                                                                        
IM FastStart Admin   ZC                   FS Seg contention    Serialize FS segment                                                                                                                     
                                                                creation                                                                                                                                
                                                                                                                                                                                                        
IM FastStart CU      ZD                   FS CU mod            Serialize FS savepoi                                                                                                                     
                                                               nt mod                                                                                                                                   
                                                                                                                                                                                                        
IM chunk populate    SY                   IM populate by other Serialize populate o                                                                                                                     
                                           session             f in-memory chunk                                                                                                                        
                                                                                                                                                                                                        
Join group dictionar JZ                   Join group dictionar Synchronizes modific                                                                                                                     
y                                         y                    ations to im_domain$                                                                                                                     
                                                                and im_joingroup$                                                                                                                       
                                                                                                                                                                                                        
Diana Versioning     DV                   contention           Synchronizes access                                                                                                                      
                                                               to lower-version Dia                                                                                                                     
                                                               na (PL/SQL intermedi                                                                                                                     
                                                               ate representation)                                                                                                                      
                                                                                                                                                                                                        
Shared Object        SO                   contention           Synchronizes access                                                                                                                      
                                                               to Shared Object (PL                                                                                                                     
                                                               /SQL Shared Object M                                                                                                                     
                                                               anager)                                                                                                                                  
                                                                                                                                                                                                        
Runtime Fixed Table  TP                   contention           Lock held during pur                                                                                                                     
Purge                                                          ge and dynamic recon                                                                                                                     
                                                               figuration of fixed                                                                                                                      
                                                               tables.                                                                                                                                  
                                                                                                                                                                                                        
Materialized View Fl RW                   MV metadata contenti Lock held by CREATE/                                                                                                                     
ags                                       on                   ALTER/DROP materiali                                                                                                                     
                                                               zed viewwhile updati                                                                                                                     
                                                               ng materialized view                                                                                                                     
                                                                flags in detail tab                                                                                                                     
                                                               les                                                                                                                                      
                                                                                                                                                                                                        
Outline Cache        OC                   contention           Synchronizes write a                                                                                                                     
                                                               ccesses to the outli                                                                                                                     
                                                               ne cache                                                                                                                                 
                                                                                                                                                                                                        
Outline Name         OL                   contention           Synchronizes accesse                                                                                                                     
                                                               s to a particular ou                                                                                                                     
                                                               tline name                                                                                                                               
                                                                                                                                                                                                        
Cursor               CU                   contention           Recovers cursors in                                                                                                                      
                                                               case of death while                                                                                                                      
                                                               compiling                                                                                                                                
                                                                                                                                                                                                        
Edition Lock         AE                   lock                 Prevent Dropping an                                                                                                                      
                                                               edition in use                                                                                                                           
                                                                                                                                                                                                        
Password File        PF                   contention           Synchronizes accesse                                                                                                                     
                                                               s to the password fi                                                                                                                     
                                                               le                                                                                                                                       
                                                                                                                                                                                                        
Password File Metada PZ                   flush passwordfile m Synchronizes changes                                                                                                                     
ta Cache                                  etadata               to the password fil                                                                                                                     
                                                               e metadata cache                                                                                                                         
                                                                                                                                                                                                        
Password File Metada PZ                   load passwordfile me Synchronizes read an                                                                                                                     
ta Cache                                  tadata               d writes to the pass                                                                                                                     
                                                               word file metadata c                                                                                                                     
                                                               ache                                                                                                                                     
                                                                                                                                                                                                        
Label Security       IL                   contention           Synchronizes accesse                                                                                                                     
                                                               s to internal label                                                                                                                      
                                                               data structures                                                                                                                          
                                                                                                                                                                                                        
Label Security cache CL                   drop label           Synchronizes accesse                                                                                                                     
                                                               s to label cache whe                                                                                                                     
                                                               n dropping a label                                                                                                                       
                                                                                                                                                                                                        
Label Security cache CL                   compare labels       Synchronizes accesse                                                                                                                     
                                                               s to label cache for                                                                                                                     
                                                                label comparison                                                                                                                        
                                                                                                                                                                                                        
OLS groups           SG                   OLS Add Group        Synchronize access t                                                                                                                     
                                                               o ols$groups when zl                                                                                                                     
                                                               llabGroupTreeAddGrou                                                                                                                     
                                                               p does a read                                                                                                                            
                                                                                                                                                                                                        
OLS groups           SG                   OLS Create Group     Synchronize access t                                                                                                                     
                                                               o ols$groups when cr                                                                                                                     
                                                               eating a group                                                                                                                           
                                                                                                                                                                                                        
OLS groups           SG                   OLS Drop Group       Synchronizing access                                                                                                                     
                                                                to ols$groups when                                                                                                                      
                                                               dropping a group                                                                                                                         
                                                                                                                                                                                                        
OLS groups           SG                   OLS Alter Group Pare Synchronizing access                                                                                                                     
                                          nt                    to ols$groups when                                                                                                                      
                                                               alter group parent                                                                                                                       
                                                                                                                                                                                                        
Label Security Profi OP                   OLS Store user entri Synchronizing access                                                                                                                     
le                                        es                    to ols$user when in                                                                                                                     
                                                               serting user entries                                                                                                                     
                                                                                                                                                                                                        
Label Security Profi OP                   OLS Cleanup unused p Synchronizing access                                                                                                                     
le                                        rofiles               to ols$profile when                                                                                                                     
                                                                deleting unused pro                                                                                                                     
                                                               files                                                                                                                                    
                                                                                                                                                                                                        
Column Key           CC                   decryption           decrypting and cachi                                                                                                                     
                                                               ng column key                                                                                                                            
                                                                                                                                                                                                        
Master Key           MK                   contention           changing values in e                                                                                                                     
                                                               nc$                                                                                                                                      
                                                                                                                                                                                                        
Encryption Wallet    OW                   initialization       initializing the wal                                                                                                                     
                                                               let context                                                                                                                              
                                                                                                                                                                                                        
Encryption Wallet    OW                   termination          terminate the wallet                                                                                                                     
                                                                context                                                                                                                                 
                                                                                                                                                                                                        

EQ_NAME              EQ_TYPE              REQ_REASON           REQ_DESCRIPTION                                                                                                                          
-------------------- -------------------- -------------------- --------------------                                                                                                                     
wallet_set_mkey      RK                   set key              wallet master key re                                                                                                                     
                                                               key                                                                                                                                      
                                                                                                                                                                                                        
wallet_set_mkey      RK                   queue wallet and TS  coordinate with tabl                                                                                                                     
                                          keys                 espace key rekey                                                                                                                         
                                                                                                                                                                                                        
HSM cache            HC                   HSM cache write      add or delete from t                                                                                                                     
                                                               he HSM cache                                                                                                                             
                                                                                                                                                                                                        
HSM cache            HC                   HSM cache read       read from the HSM ca                                                                                                                     
                                                               che                                                                                                                                      
                                                                                                                                                                                                        
RAC Encryption Walle RL                   RAC wallet lock      RAC wallet lock                                                                                                                          
t Lock                                                                                                                                                                                                  
                                                                                                                                                                                                        
DV Policy Admin API  PJ                   modify DV policy     lock held for modify                                                                                                                     
                                                               ing Database Vault p                                                                                                                     
                                                               olicy                                                                                                                                    
                                                                                                                                                                                                        
DV Policy Admin API  PJ                   read DV policy       lock held for readin                                                                                                                     
                                                               g Database Vault pol                                                                                                                     
                                                               icy                                                                                                                                      
                                                                                                                                                                                                        
Global Context Actio ZZ                   update hash tables   lock held for updati                                                                                                                     
n                                                              ng global context ha                                                                                                                     
                                                               sh tables                                                                                                                                
                                                                                                                                                                                                        
Audit Partition      ZA                   add std audit table  lock held to add par                                                                                                                     
                                          partition            tition to std audit                                                                                                                      
                                                               table                                                                                                                                    
                                                                                                                                                                                                        
FGA Partition        ZF                   add fga audit table  lock held to add par                                                                                                                     
                                          partition            tition to fga audit                                                                                                                      
                                                               table                                                                                                                                    
                                                                                                                                                                                                        
Spillover Audit file ZS                   excl access to spill lock held while writ                                                                                                                     
s                                          audit file          ing to/renaming/dele                                                                                                                     
                                                               ting spillover audit                                                                                                                     
                                                                file                                                                                                                                    
                                                                                                                                                                                                        
Transfer Unified Aud UT                   transfer audit recor lock held while exec                                                                                                                     
it Records                                ds                   uting transfer proce                                                                                                                     
                                                               dure                                                                                                                                     
                                                                                                                                                                                                        
CBAC Master Lock     CB                   role operation       Synchronizes accesse                                                                                                                     
                                                               s to the CBAC roles                                                                                                                      
                                                               cached in KGL                                                                                                                            
                                                                                                                                                                                                        
Privilege Capture AP PA                   modify a privilege c lock held for during                                                                                                                     
I                                         apture                modify a privilege                                                                                                                      
                                                               capture                                                                                                                                  
                                                                                                                                                                                                        
Privilege Capture AP PA                   read a privilege cap lock held for during                                                                                                                     
I                                         ture                  reading privilege c                                                                                                                     
                                                               aptur status                                                                                                                             
                                                                                                                                                                                                        
Enqueue for kzppctxs PC                   update privilege cap lock held while modi                                                                                                                     
                                          ture info            fying kzppctxs in SG                                                                                                                     
                                                               A                                                                                                                                        
                                                                                                                                                                                                        
Enqueue for kzppctxs PC                   read privilege captu lock held while read                                                                                                                     
                                          re info              ing kzppctxs in SGA                                                                                                                      
                                                                                                                                                                                                        
Distributed Transact DX                   contention           Serializes tightly c                                                                                                                     
ion                                                            oupled distributed t                                                                                                                     
                                                               ransaction branches                                                                                                                      
                                                                                                                                                                                                        
Distributed Recovery DR                   contention           Serializes the activ                                                                                                                     
                                                               e distributed recove                                                                                                                     
                                                               ry operation                                                                                                                             
                                                                                                                                                                                                        
Global Transaction B BB                   2PC across RAC insta 2PC distributed tran                                                                                                                     
ranch                                     nces                 saction branch acros                                                                                                                     
                                                               s RAC instances                                                                                                                          
                                                                                                                                                                                                        
Job Queue Date       JD                   contention           Synchronizes dates b                                                                                                                     
                                                               etween job queue coo                                                                                                                     
                                                               rdinator and slave p                                                                                                                     
                                                               rocesses                                                                                                                                 
                                                                                                                                                                                                        
Job Queue            JQ                   contention           Lock to prevent mult                                                                                                                     
                                                               iple instances from                                                                                                                      
                                                               running a single job                                                                                                                     
                                                                                                                                                                                                        
Online DDLs          OD                   Serializing DDLs     Lock to prevent conc                                                                                                                     
                                                               urrent online DDLs                                                                                                                       
                                                                                                                                                                                                        
DbsDriver            DB                   contention           Synchronizes modific                                                                                                                     
                                                               ation of database wi                                                                                                                     
                                                               de supplementalloggi                                                                                                                     
                                                               ng attributes                                                                                                                            
                                                                                                                                                                                                        
Materialized View Lo MD                   contention           Lock held during mat                                                                                                                     
g DDL                                                          erialized view log D                                                                                                                     
                                                               DL statements                                                                                                                            
                                                                                                                                                                                                        
Materialized View Re MS                   contention           Lock held during mat                                                                                                                     
fresh Log                                                      erialized view refre                                                                                                                     
                                                               sh to setup MV log                                                                                                                       
                                                                                                                                                                                                        
SPM Autopurge        AP                   contention           This enqueue is used                                                                                                                     
                                                                to serialize the pu                                                                                                                     
                                                               rging of SQL plan ba                                                                                                                     
                                                               selines                                                                                                                                  
                                                                                                                                                                                                        
SQLQ Autopurge       RH                   quarantine           This enqueue is used                                                                                                                     
                                                                to serialize the pu                                                                                                                     
                                                               rging of SQL quarant                                                                                                                     
                                                               ine configurations                                                                                                                       
                                                                                                                                                                                                        
Remote PX Process Sp PI                   contention           Communicates remote                                                                                                                      
awn Status                                                     Parallel Execution S                                                                                                                     
                                                               erver Process creati                                                                                                                     
                                                               on status                                                                                                                                
                                                                                                                                                                                                        
PX Process Reservati PS                   contention           Parallel Execution S                                                                                                                     
on                                                             erver Process reserv                                                                                                                     
                                                               ation and synchroniz                                                                                                                     
                                                               ation                                                                                                                                    
                                                                                                                                                                                                        
Instance DP Array    DA                   Slave Process Array  Slave Process Spawn                                                                                                                      
                                                               reservation and sync                                                                                                                     
                                                               hronization                                                                                                                              
                                                                                                                                                                                                        
KSXA Test Affinity D AY                   contention           Affinity Dictionary                                                                                                                      
ictionary                                                      test affinity synchr                                                                                                                     
                                                               onization                                                                                                                                
                                                                                                                                                                                                        
Temp Object          TO                   contention           Synchronizes DDL and                                                                                                                     
                                                                DML operations on a                                                                                                                     
                                                                temp object                                                                                                                             
                                                                                                                                                                                                        
In Memory Temp Objec TG                   IMCDT global resourc Allocate on imcdt gl                                                                                                                     
t                                         e                    obal resource                                                                                                                            
                                                                                                                                                                                                        
In Memory Temp Objec TI                   IMCDT object HT      Allocate on imcdt ob                                                                                                                     
t HT                                                           ject HT                                                                                                                                  
                                                                                                                                                                                                        
Private Temp Table s ZP                   Private Temporary Ta Synchronizes add/dro                                                                                                                     
ynchronize                                ble                  p of Private Temp Ta                                                                                                                     
                                                               ble with DBA_PRIVATE                                                                                                                     
                                                               _TEMP_TABLES                                                                                                                             
                                                                                                                                                                                                        
In-Mem Temp Table Me IT                   contention           Synchronizes accesse                                                                                                                     
ta Creation                                                    s to a temp object's                                                                                                                     
                                                                metadata                                                                                                                                
                                                                                                                                                                                                        
BLOOM FILTER         BF                   allocation contentio Allocate a bloom fil                                                                                                                     
                                          n                    ter in a parallel st                                                                                                                     
                                                               atement                                                                                                                                  
                                                                                                                                                                                                        
BLOOM FILTER         BF                   PMON Join Filter cle PMON bloom filter re                                                                                                                     
                                          anup                 covery                                                                                                                                   
                                                                                                                                                                                                        
Result Cache: Enqueu RC                   Result Cache: Conten Coordinates access t                                                                                                                     
e                                         tion                 o a result-set                                                                                                                           
                                                                                                                                                                                                        
SQL STATEMENT QUEUE  JX                   SQL statement queue   statement                                                                                                                               
SQL STATEMENT QUEUE  JX                   cleanup of  queue    release SQL statemen                                                                                                                     
                                                               t resources                                                                                                                              
                                                                                                                                                                                                        
RAC Load             RD                   RAC load              update RAC load inf                                                                                                                     
                                                               o                                                                                                                                        
                                                                                                                                                                                                        
KEY VECTOR           KV                   IMA key vector acces Access a key vector                                                                                                                      
                                          s                    in an IMA query                                                                                                                          
                                                                                                                                                                                                        
MGA service          MG                   MGA allocation       synchronize MGA serv                                                                                                                     
                                                               ice MGA allocation                                                                                                                       
                                                                                                                                                                                                        
MGA service          MG                   client shared contex synchronize MGA serv                                                                                                                     
                                          t allocation         ice client shared co                                                                                                                     
                                                               ntext allocation                                                                                                                         
                                                                                                                                                                                                        
Kupp Process Startup KP                   contention           Synchronizes kupp pr                                                                                                                     
                                                               ocess startup                                                                                                                            
                                                                                                                                                                                                        
Synchronized Replica SR                   contention           Coordinates replicat                                                                                                                     
tion                                                           ion / streams operat                                                                                                                     
                                                               ions                                                                                                                                     
                                                                                                                                                                                                        
Replication Global   RG                   Apply coord start/st Coordinates instance                                                                                                                     
                                          op                   -wide replication /                                                                                                                      
                                                               streams operations                                                                                                                       
                                                                                                                                                                                                        
Streams Table Instan SI                   contention           Prevents multiple st                                                                                                                     
tiation                                                        reams tabel instanti                                                                                                                     
                                                               ations                                                                                                                                   
                                                                                                                                                                                                        
File Group           ZG                   contention           Coordinates file gro                                                                                                                     
                                                               up operations                                                                                                                            
                                                                                                                                                                                                        
Internal             IA                   contention                                                                                                                                                    
Materialized View    JI                   contention           Lock held during mat                                                                                                                     
                                                               erialized view opera                                                                                                                     
                                                               tions (like refresh,                                                                                                                     
                                                                alter) to prevent c                                                                                                                     
                                                               oncurrent operations                                                                                                                     
                                                                on the same materia                                                                                                                     
                                                               lized view                                                                                                                               
                                                                                                                                                                                                        
Alter Tablespace     AT                   contention           Serializes 'alter ta                                                                                                                     
                                                               blespace' operations                                                                                                                     
                                                                                                                                                                                                        
Cleanup querycache r CQ                   contention           Serializes access to                                                                                                                     
egistrations                                                    cleanup client quer                                                                                                                     
                                                               y cache registration                                                                                                                     
                                                               s                                                                                                                                        
                                                                                                                                                                                                        
Emon-SRVNTFN_Q Creat AZ                   AQ_SRVNTFN_Q Creatio Create AQ_SRVNTFN_Q                                                                                                                      
e                                         n                    by single Emon slave                                                                                                                     
                                                                only                                                                                                                                    
                                                                                                                                                                                                        
Session Migration    SE                   contention           Synchronizes transpa                                                                                                                     
                                                               rent session migrati                                                                                                                     
                                                               on operations                                                                                                                            
                                                                                                                                                                                                        
User-defined         UL                   contention           Lock used by user ap                                                                                                                     
                                                               plications                                                                                                                               
                                                                                                                                                                                                        
Queue table enqueue  TQ                   TM contention        TM access to the que                                                                                                                     
                                                               ue table                                                                                                                                 
                                                                                                                                                                                                        
Queue table enqueue  TQ                   DDL contention       TM access to the que                                                                                                                     
                                                               ue table                                                                                                                                 
                                                                                                                                                                                                        
Queue table enqueue  TQ                   INI contention       TM access to the que                                                                                                                     
                                                               ue table                                                                                                                                 
                                                                                                                                                                                                        
Queue table enqueue  TQ                   DDL-INI contention   Streams DDL on queue                                                                                                                     
                                                                table                                                                                                                                   
                                                                                                                                                                                                        
Queue table enqueue  TQ                   INI sq contention    INIT access to the q                                                                                                                     
                                                               ueue tables                                                                                                                              
                                                                                                                                                                                                        
Queue table enqueue  TQ                   MC free sync at cros Shift dequeue affini                                                                                                                     
                                          s job start          ty to destination in                                                                                                                     
                                                               stance                                                                                                                                   
                                                                                                                                                                                                        
Queue table enqueue  TQ                   MC free sync at cros Shift dequeue affini                                                                                                                     
                                          s job stop           ty to source instanc                                                                                                                     
                                                               e                                                                                                                                        
                                                                                                                                                                                                        
Queue table enqueue  TQ                   MC free sync at cros Stop a cross job str                                                                                                                     
                                          s job end            eam                                                                                                                                      
                                                                                                                                                                                                        
Queue table enqueue  TQ                   MC free sync at expo Export a subshard in                                                                                                                     
                                          rt subshard           cross stream                                                                                                                            
                                                                                                                                                                                                        
Queue table enqueue  TQ                   create eviction tabl post upgrade creatio                                                                                                                     
                                          e                    n of eviction table                                                                                                                      
                                                                                                                                                                                                        
Queue table enqueue  TQ                   TM Job cache initial TM Job cache Initial                                                                                                                     
                                          ization              ization                                                                                                                                  
                                                                                                                                                                                                        
Queue table enqueue  TQ                   TM Job cache use     TM Job cache usage                                                                                                                       
Queue table enqueue  TQ                    sq TM contention    SQ TM access to the                                                                                                                      
                                                               queue table                                                                                                                              
                                                                                                                                                                                                        
Queue table enqueue  TQ                   LB drop volatile sha LB drop volatile sha                                                                                                                     
                                          rd                   rd                                                                                                                                       
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   Enqueue commit uncac Enqueue commit uncac                                                                                                                     
                                          hed                  hed                                                                                                                                      
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   Enqueue commit cache Enqueue commit rac c                                                                                                                     
                                          d                    ached                                                                                                                                    
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   Dequeue update scn   Dequeue updating scn                                                                                                                     
Enqueue-Cross SCN    RQ                   Parallel cross updat Parallel cross(updat                                                                                                                     
                                          e scn                e scn) - truncate su                                                                                                                     
                                                               bshard                                                                                                                                   
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   Cross update scn     Cross process updati                                                                                                                     
                                                               ng disk                                                                                                                                  
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   Trucate subshard     Truncate - Cross(exp                                                                                                                     
                                                               ort) subshard                                                                                                                            
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   Cross export subshar Cross(export) - trun                                                                                                                     
                                          d                    cate subshard                                                                                                                            
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   Cross import subshar Cross(import) - free                                                                                                                     
                                          d                     shadow shard                                                                                                                            
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   Free shadow shard    Free shadow - Cross(                                                                                                                     
                                                               import) shard                                                                                                                            
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ indexed cached co AQ indexed cached co                                                                                                                     
                                          mmit                 mmit                                                                                                                                     
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ uncached commit W AQ uncached commit W                                                                                                                     
                                          M update             M update                                                                                                                                 
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ uncached dequeue  AQ uncached dequeue                                                                                                                      
Enqueue-Cross SCN    RQ                   AQ Eq Ptn Mapping    AQ Eq Ptn Mapping                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Dq Ptn Mapping    AQ Dq Ptn Mapping                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Trnc mem free     AQ Trnc mem free                                                                                                                         
Enqueue-Cross SCN    RQ                   AQ Trnc mem free rem AQ Trnc mem free rem                                                                                                                     
                                          ote                  ote                                                                                                                                      
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Trnc mem free by  AQ Trnc mem free kws                                                                                                                     
                                          LB                   lb                                                                                                                                       
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Trnc mem free by  AQ Trnc mem free kws                                                                                                                     
                                          CP                   mcx                                                                                                                                      
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Enq commit incarn AQ incarnation numbe                                                                                                                     
                                          ation wrap           r wrap                                                                                                                                   
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Rule evaluation s AQ segment load kwse                                                                                                                     
                                          egment load                                                                                                                                                   
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Evict: block trun AQ message cache man                                                                                                                     
                                          cate                 agement                                                                                                                                  
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Unevict PGA: setu AQ message cache man                                                                                                                     
                                          p subscriber         agement                                                                                                                                  
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Unevict PGA: Queu AQ message cache man                                                                                                                     
                                          e View               agement                                                                                                                                  
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Shid Gen          AQ Shid Gen                                                                                                                              
Enqueue-Cross SCN    RQ                   AQ Enq commit block  AQ RAC enqueue commi                                                                                                                     
                                          truncate             t                                                                                                                                        
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Cross update scn  AQ Cross uncached co                                                                                                                     
                                          for delay            nversion                                                                                                                                 
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ Cross Shard mem f AQ RAC message forwa                                                                                                                     
                                          ree                  rding end                                                                                                                                
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ rollback retry co AQ retry count                                                                                                                           
                                          unt update                                                                                                                                                    
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ cached commit WM  AQ cached commit WM                                                                                                                      
                                          update               update                                                                                                                                   
                                                                                                                                                                                                        
Enqueue-Cross SCN    RQ                   AQ cached dequeue by AQ cached dequeue by                                                                                                                     
                                           condition            condition                                                                                                                               
                                                                                                                                                                                                        
Enqueue-Delete Rule  KR                   Drop rule force      Drop rule force                                                                                                                          
Enqueue-Delete Rule  KR                   Add rule to ruleset  Synchronize with dro                                                                                                                     
                                                               p rule                                                                                                                                   
                                                                                                                                                                                                        
Enqueue-Delete Rule  KR                   Remove rule from rul Syncronize remove ru                                                                                                                     
                                          eset                 le from ruleset                                                                                                                          
                                                                                                                                                                                                        
LDAP Parameter       DP                   contention           Synchronizes access                                                                                                                      
                                                               to LDAP parameters                                                                                                                       
                                                                                                                                                                                                        
AQ Notification Mail MH                   contention           Lock used for recove                                                                                                                     
 Host                                                          ry when setting Mail                                                                                                                     
                                                                Host for AQ e-mail                                                                                                                      
                                                               notifications                                                                                                                            
                                                                                                                                                                                                        
AQ Notification Mail ML                   contention           Lock used for recove                                                                                                                     
 Port                                                          ry when setting Mail                                                                                                                     
                                                                Port for AQ e-mail                                                                                                                      
                                                               notifications                                                                                                                            
                                                                                                                                                                                                        
AQ Notification Prox PH                   contention           Lock used for recove                                                                                                                     
y                                                              ry when setting Prox                                                                                                                     
                                                               y for AQ HTTP notifi                                                                                                                     
                                                               cations                                                                                                                                  
                                                                                                                                                                                                        
AQ Notification Send SF                   contention           Lock used for recove                                                                                                                     
er                                                             ry when setting Send                                                                                                                     
                                                               er for AQ e-mail not                                                                                                                     
                                                               ifications                                                                                                                               
                                                                                                                                                                                                        
AQ Notification No-P XH                   contention           Lock used for recove                                                                                                                     
roxy                                                           ry when setting No P                                                                                                                     
                                                               roxy Domains for AQ                                                                                                                      
                                                               HTTP notifications                                                                                                                       
                                                                                                                                                                                                        
AQ Notification Wate WA                   contention           Lock used for recove                                                                                                                     
rmark                                                          ry when setting Wate                                                                                                                     
                                                               rmark for memory usa                                                                                                                     
                                                               ge in AQ notificatio                                                                                                                     
                                                               ns                                                                                                                                       
                                                                                                                                                                                                        
Queue Partitioning l AQ                   QPT fg map dqpt      kwsptGetOrMapDqPtn                                                                                                                       
ocal enqueue                                                                                                                                                                                            
                                                                                                                                                                                                        
Queue Partitioning l AQ                   QPT fg map qpt       kwsptGetOrMapQPtn                                                                                                                        
ocal enqueue                                                                                                                                                                                            
                                                                                                                                                                                                        
Queue Ptning global  PQ                   QPT add qpt          kwsptLoadQCache: Add                                                                                                                     
enq                                                             Q Partitions.                                                                                                                           
                                                                                                                                                                                                        
Queue Ptning global  PQ                   QPT drop qpt         kwsptLoadQCache:Drop                                                                                                                     
enq                                                             Q Partitions.                                                                                                                           
                                                                                                                                                                                                        
Queue Ptning global  PQ                   QPT add dqpt         kwsptLoadDqCache: Ad                                                                                                                     
enq                                                            d DQ Partitions.                                                                                                                         
                                                                                                                                                                                                        
Queue Ptning global  PQ                   QPT drop dqpt        kwsptLoadDqCache:Dro                                                                                                                     
enq                                                            p DQ Partitions.                                                                                                                         
                                                                                                                                                                                                        
Queue Ptning global  PQ                   QPT add qpt fg       kwsptMapQPtn: Add Q                                                                                                                      
enq                                                            Partitions in foregr                                                                                                                     
                                                               ound                                                                                                                                     
                                                                                                                                                                                                        
Queue Ptning global  PQ                   QPT add dqpt fg      kwsptMapDqPtn:Drop D                                                                                                                     
enq                                                            Q Partitions in fore                                                                                                                     
                                                               ground                                                                                                                                   
                                                                                                                                                                                                        
Queue Ptning global  PQ                   QPT Trunc            kwsptChkTrncLst:Trun                                                                                                                     
enq                                                            cate                                                                                                                                     
                                                                                                                                                                                                        
Queue Ptning global  PQ                   QPT LB Trunc sync    kwslbFreShadowShrd:L                                                                                                                     
enq                                                            B syncronization wit                                                                                                                     
                                                               h Truncate                                                                                                                               
                                                                                                                                                                                                        
Queue Ptning global  PQ                   QPT XSTART Trunc syn kwsmcxMoreToExport:X                                                                                                                     
enq                                       c                    START syncronization                                                                                                                     
                                                                with Truncate                                                                                                                           
                                                                                                                                                                                                        
non durable sub bmap BA                   SUBBMAP contention   subscriber access to                                                                                                                     
 alloc                                                          bitmap                                                                                                                                  
                                                                                                                                                                                                        
TEXT: Index Specific CX                   TEXT: Index Specific Index Specific Lock                                                                                                                      
 Lock                                      Lock                on CTX index                                                                                                                             
                                                                                                                                                                                                        
TEXT: Generic Lock   OT                   TEXT: Generic Lock   CTX Generic Locks                                                                                                                        
XDB Configuration    XC                   XDB Configuration    Lock obtained when i                                                                                                                     
                                                               ncrementing XDB conf                                                                                                                     
                                                               iguration version nu                                                                                                                     
                                                               mber                                                                                                                                     
                                                                                                                                                                                                        
Data Guard Broker    RF                   synch: DG Broker met Ensures r/w atomicit                                                                                                                     
                                          adata                y of DG configuratio                                                                                                                     
                                                               n metadata                                                                                                                               
                                                                                                                                                                                                        
Data Guard Broker    RF                   atomicity            Ensures atomicity of                                                                                                                     
                                                                log transport setup                                                                                                                     
                                                                                                                                                                                                        
Data Guard Broker    RF                   Broker Chief Lock    Used to synchronize                                                                                                                      
                                                               broker activity                                                                                                                          
                                                                                                                                                                                                        
Data Guard Broker    RF                   synchronization: aif Synchronizes apply i                                                                                                                     
                                          o master             nstance failure dete                                                                                                                     
                                                               ction and failover o                                                                                                                     
                                                               peration                                                                                                                                 
                                                                                                                                                                                                        
Data Guard Broker    RF                   new AI               Synchronizes selecti                                                                                                                     
                                                               on of the new apply                                                                                                                      
                                                               instance                                                                                                                                 
                                                                                                                                                                                                        
Data Guard Broker    RF                   synchronization: cri Synchronizes critica                                                                                                                     
                                          tical ai             l apply instance amo                                                                                                                     
                                                               ng primary instances                                                                                                                     
                                                                                                                                                                                                        
Data Guard Broker    RF                   RF - Database Automa Means for detecting                                                                                                                      
                                          tic Disable          when database is bei                                                                                                                     
                                                               ng automatically dis                                                                                                                     
                                                               abled                                                                                                                                    
                                                                                                                                                                                                        
Data Guard Broker    RF                   FSFO Observer Heartb Captures recent Fast                                                                                                                     
                                          eat                  -Start Failover Obse                                                                                                                     
                                                               rver heartbeat infor                                                                                                                     
                                                               mation                                                                                                                                   
                                                                                                                                                                                                        
Data Guard Broker    RF                   DG Broker Current Fi Identifies which con                                                                                                                     
                                          le ID                figuration metadata                                                                                                                      
                                                               file is current                                                                                                                          
                                                                                                                                                                                                        
Data Guard Broker    RF                   FSFO Primary Shutdow Records when FSFO Pr                                                                                                                     
                                          n suspended          imary Shutdown is su                                                                                                                     
                                                               spended                                                                                                                                  
                                                                                                                                                                                                        
Data Guard Broker    RF                   Broker State Lock    Captures database-wi                                                                                                                     
                                                               de broker state                                                                                                                          
                                                                                                                                                                                                        
Data Guard Broker    RF                   FSFO string buffer   Makes a FSFO-related                                                                                                                     
                                                                string available ac                                                                                                                     
                                                               ross RAC instances                                                                                                                       
                                                                                                                                                                                                        
Data Guard Broker    RF                   Broker NSV Lock      Used to synchronize                                                                                                                      
                                                               NSV creation/termina                                                                                                                     
                                                               tion                                                                                                                                     
                                                                                                                                                                                                        
Data Guard Broker    RF                   Broker LSBY FO Lock  Used to force lsby f                                                                                                                     
                                                               ailover teardown on                                                                                                                      
                                                               one instance                                                                                                                             
                                                                                                                                                                                                        
Analytic Workspace   AW                   AW$ table lock       Global access synchr                                                                                                                     
                                                               onization to the AW$                                                                                                                     
                                                                table                                                                                                                                   
                                                                                                                                                                                                        
Analytic Workspace   AW                   AW state lock        Row lock synchroniza                                                                                                                     
                                                               tion for the AW$ tab                                                                                                                     
                                                               le                                                                                                                                       
                                                                                                                                                                                                        
Analytic Workspace   AW                   user access for AW   Synchronizes user ac                                                                                                                     
                                                               cesses to a particul                                                                                                                     
                                                               ar workspace                                                                                                                             
                                                                                                                                                                                                        
Analytic Workspace   AW                   AW generation lock   In-use generation st                                                                                                                     
                                                               ate for a particular                                                                                                                     
                                                                workspace                                                                                                                               
                                                                                                                                                                                                        
Analytic Workspace G AG                   contention           Synchronizes generat                                                                                                                     
eneration                                                      ion use of a particu                                                                                                                     
                                                               lar workspace                                                                                                                            
                                                                                                                                                                                                        
MultiWriter Object A AO                   contention           Synchornizes access                                                                                                                      
ccess                                                          to objects and scala                                                                                                                     
                                                               r variables                                                                                                                              
                                                                                                                                                                                                        
OLAPI Histories      OQ                   xsoqhiAlloc          Synchronizes access                                                                                                                      
                                                               to olapi history all                                                                                                                     
                                                               ocation                                                                                                                                  
                                                                                                                                                                                                        
OLAPI Histories      OQ                   xsoqhiFlush          Synchronizes access                                                                                                                      
                                                               to olapi history flu                                                                                                                     
                                                               shing                                                                                                                                    
                                                                                                                                                                                                        
OLAPI Histories      OQ                   xsoq*histrecb        Synchronizes access                                                                                                                      
                                                               to olapi history par                                                                                                                     
                                                               ameter CB                                                                                                                                
                                                                                                                                                                                                        
OLAPI Histories      OQ                   xsoqhiClose          Synchronizes access                                                                                                                      
                                                               to olapi history clo                                                                                                                     
                                                               sing                                                                                                                                     
                                                                                                                                                                                                        
OLAPI Histories      OQ                   xsoqhistrecb         Synchronizes access                                                                                                                      
                                                               to olapi history glo                                                                                                                     
                                                               bals                                                                                                                                     
                                                                                                                                                                                                        
ASM Enqueue          AM                   client registration  Registers DB instanc                                                                                                                     
                                                               e to ASM client stat                                                                                                                     
                                                               e object hash                                                                                                                            
                                                                                                                                                                                                        
ASM Enqueue          AM                   shutdown             Prevent DB instance                                                                                                                      
                                                               registration during                                                                                                                      
                                                               ASM instance shutdow                                                                                                                     
                                                               n                                                                                                                                        
                                                                                                                                                                                                        
ASM Enqueue          AM                   rollback COD reserva Reserve a rollback C                                                                                                                     
                                          tion                 OD entry                                                                                                                                 
                                                                                                                                                                                                        
ASM Enqueue          AM                   background COD reser Reserve a background                                                                                                                     
                                          vation                COD entry                                                                                                                               
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM cache freeze     Start ASM cache free                                                                                                                     
                                                               ze                                                                                                                                       
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM ACD Relocation   Block ASM cache free                                                                                                                     
                                                               ze                                                                                                                                       
                                                                                                                                                                                                        
ASM Enqueue          AM                   group use            Client group use                                                                                                                         
ASM Enqueue          AM                   group block          ASM group block                                                                                                                          
ASM Enqueue          AM                   ASM File Destroy     Prevent same file de                                                                                                                     
                                                               letion race                                                                                                                              
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM User             Prevents a user from                                                                                                                     
                                                                being dropped if it                                                                                                                     
                                                                owns any open files                                                                                                                     
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Password File Up Allow one ASM passwo                                                                                                                     
                                          date                 rd file update per c                                                                                                                     
                                                               luster at a time                                                                                                                         
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Amdu Dump        Allow only one AMDU                                                                                                                      
                                                               dump when block read                                                                                                                     
                                                                failure                                                                                                                                 
                                                                                                                                                                                                        
ASM Enqueue          AM                   disk offline         Synchronizes disk of                                                                                                                     
                                                               flines                                                                                                                                   
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM reserved         Check id1 of call fo                                                                                                                     
                                                               r specific purpose                                                                                                                       
                                                                                                                                                                                                        
ASM Enqueue          AM                   block repair         Serializes block rep                                                                                                                     
                                                               airs                                                                                                                                     
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM disk based alloc Synchronizes disk ba                                                                                                                     
                                          /dealloc             sed allocations/deal                                                                                                                     
                                                               locations                                                                                                                                
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM file descriptor  Serializes access to                                                                                                                     
                                                                ASM file descriptor                                                                                                                     
                                                               s                                                                                                                                        
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM file relocation  Serializes file relo                                                                                                                     
                                                               cation shrink and dr                                                                                                                     
                                                               op                                                                                                                                       
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM SR relocation    Serializes file relo                                                                                                                     
                                                               cation and SR open                                                                                                                       
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Grow ACD         Serializes growing A                                                                                                                     
                                                               SM ACD                                                                                                                                   
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM DD update SrRloc Serializes DD update                                                                                                                     
                                                                for SrRloc                                                                                                                              
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM file chown       Prevents new owners                                                                                                                      
                                                               of open files from b                                                                                                                     
                                                               eing dropped                                                                                                                             
                                                                                                                                                                                                        
ASM Enqueue          AM                   Register with IOServ Serializes the regis                                                                                                                     
                                          er                   tration of the datab                                                                                                                     
                                                               ase with IOServer                                                                                                                        
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM metadata replica Serializes metadata                                                                                                                      
                                          tion                 replication                                                                                                                              
                                                                                                                                                                                                        
ASM Enqueue          AM                   SR slice Clear/Mark  Serialize clear/assi                                                                                                                     
                                                               gnment for SR slices                                                                                                                     
                                                                                                                                                                                                        
ASM Enqueue          AM                   Enable Remote ASM    Lock held while enab                                                                                                                     
                                                               ling remote asm                                                                                                                          
                                                                                                                                                                                                        
ASM Enqueue          AM                   Disable Remote ASM   Lock held while disa                                                                                                                     
                                                               bling remote asm                                                                                                                         
                                                                                                                                                                                                        
ASM Enqueue          AM                   Credential creation  Lock held while crea                                                                                                                     
                                                               ting credentials                                                                                                                         
                                                                                                                                                                                                        
ASM Enqueue          AM                   Credential deletion  Lock held while dele                                                                                                                     
                                                               ting credentials                                                                                                                         
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM file access req  Synchronizes file ac                                                                                                                     
                                                               cess per client                                                                                                                          
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM client operation Synchronizes client                                                                                                                      
                                                               operations and shutd                                                                                                                     
                                                               own                                                                                                                                      
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM client check     Synchronizes client                                                                                                                      
                                                               check, kill and regi                                                                                                                     
                                                               ster                                                                                                                                     
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM ATB COD creation ASM ATB COD creation                                                                                                                     
ASM Enqueue          AM                   Create default DG ke ASM audit create def                                                                                                                     
                                          y in OCR             ault DG key in OCR                                                                                                                       
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Audit file Delet ASM Audit file Delet                                                                                                                     
                                          e                    e                                                                                                                                        
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Audit file Clean ASM Audit file Clean                                                                                                                     
                                          up                   up                                                                                                                                       
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM VAT migration    ASM VAT migration                                                                                                                        
ASM Enqueue          AM                   Update SR nomark fla Synchronize updating                                                                                                                     
                                          g                     of Staleness Regist                                                                                                                     
                                                               ry nomark flag                                                                                                                           
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM VAL cache        ASM VAL cache                                                                                                                            
ASM Enqueue          AM                   ASM SR Segment Reuse Synchronizes SR Segm                                                                                                                     
                                                               ent Reuse enqueue ac                                                                                                                     
                                                               quisition                                                                                                                                
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM SR Segment Reuse Synchronizes Segment                                                                                                                     
                                           Lookup               Reuse client lookup                                                                                                                     
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM SR Batch Allocat Serialize SR batch a                                                                                                                     
                                          ion                  llocation                                                                                                                                
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Sparse Disk IOCT Serialize sparse dis                                                                                                                     
                                          L                    k IOCTLs                                                                                                                                 
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM VAM Active       Serialize access to                                                                                                                      
                                                               _vam_active attribut                                                                                                                     
                                                               e                                                                                                                                        
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Split Mirror Fil Serialize file creat                                                                                                                     
                                          e Create             e with split mirror                                                                                                                      
                                                               operations                                                                                                                               
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Split Mirror Fil Serializes file dele                                                                                                                     
                                          e Delete             te with split mirror                                                                                                                     
                                                                operations                                                                                                                              
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Mirror Prepare   Serialize PREPARE wi                                                                                                                     
                                                               th other operations                                                                                                                      
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Mirror Split     Serialize SPLIT with                                                                                                                     
                                                                other operations                                                                                                                        
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Drop Mirror      Serialize DROP MIRRO                                                                                                                     
                                                               R with other operati                                                                                                                     
                                                               ons                                                                                                                                      
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM PDB Mirror Split Serialize PDB SPLIT                                                                                                                      
                                                               with other operation                                                                                                                     
                                                               s                                                                                                                                        
                                                                                                                                                                                                        
ASM Enqueue          AM                   DB Mirror Prepare    Serialize PREPARE wi                                                                                                                     
                                                               th other split mirro                                                                                                                     
                                                               r operations                                                                                                                             
                                                                                                                                                                                                        
ASM Enqueue          AM                   DB Drop Mirror Copy  Serialize DROP MIRRO                                                                                                                     
                                                               R with other split m                                                                                                                     
                                                               irror operations                                                                                                                         
                                                                                                                                                                                                        
ASM Enqueue          AM                   DB Mirror Split      Serialize SPLIT with                                                                                                                     
                                                                split mirror operat                                                                                                                     
                                                               ions                                                                                                                                     
                                                                                                                                                                                                        
ASM Enqueue          AM                   PDB Mirror Split     Serialize PDB SPLIT                                                                                                                      
                                                               with split mirror op                                                                                                                     
                                                               erations                                                                                                                                 
                                                                                                                                                                                                        
ASM Enqueue          AM                   Create Prepare Child Serialize split mirr                                                                                                                     
                                           file group          or PREPARE with Chan                                                                                                                     
                                                               ge Redundancy                                                                                                                            
                                                                                                                                                                                                        
ASM Enqueue          AM                   Change file group re Serialize Change Red                                                                                                                     
                                          dundancy             undancy with split m                                                                                                                     
                                                               irror PREPARE                                                                                                                            
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Split Mirror ODM Serialize ODM file c                                                                                                                     
                                           File Crt            reate with split mir                                                                                                                     
                                                               ror operations                                                                                                                           
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Split Mirror ODM Serializes ODM file                                                                                                                      
                                           File Del            delete with split mi                                                                                                                     
                                                               rror operations                                                                                                                          
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASMB Startup         Serialize startup of                                                                                                                     
                                                                multiple ASMB backg                                                                                                                     
                                                               rounds                                                                                                                                   
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASMB Renew           Serialize renew of d                                                                                                                     
                                                               iskgroups among mult                                                                                                                     
                                                               iple ASMB background                                                                                                                     
                                                               s                                                                                                                                        
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM: group unblock   Serialize group unbl                                                                                                                     
                                                               ock                                                                                                                                      
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM file create      Serializes ASM file                                                                                                                      
                                                               create                                                                                                                                   
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM ATE conversion   ASM ATE conversion                                                                                                                       
ASM Enqueue          AM                   ASM resync from ATE  Serializes work to e                                                                                                                     
                                                               nable resync from AT                                                                                                                     
                                                               Es                                                                                                                                       
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Split Status Wri Serialize SPLIT STAT                                                                                                                     
                                          te                   US Write                                                                                                                                 
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Split Status Rea Serialize SPLIT STAT                                                                                                                     
                                          d                    US Read                                                                                                                                  
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Client Assisted  ASM client assisted                                                                                                                      
                                          Offline              offline                                                                                                                                  
                                                                                                                                                                                                        
ASM Enqueue          AM                   ASM Client Assisted  Check pending client                                                                                                                     
                                          Offline Chk           assisted offline                                                                                                                        
                                                                                                                                                                                                        
ASM Instance Enqueue CM                   gate                 serialize access to                                                                                                                      
                                                               instance enqueue                                                                                                                         
                                                                                                                                                                                                        
ASM Instance Enqueue CM                   instance             indicate ASM diskgro                                                                                                                     
                                                               up is mounted                                                                                                                            
                                                                                                                                                                                                        
ASM Instance Enqueue CM                   diskgroup dismount   serialize asm diskgr                                                                                                                     
                                                               oup dismount                                                                                                                             
                                                                                                                                                                                                        
ASM Extent Relocatio XQ                   recovery             prevent relocation d                                                                                                                     
n Enqueue                                                      uring _recovery_asse                                                                                                                     
                                                               rts checking                                                                                                                             
                                                                                                                                                                                                        
ASM Extent Relocatio XQ                   relocation           wait for recovery be                                                                                                                     
n Enqueue                                                      fore doing relocatio                                                                                                                     
                                                               n                                                                                                                                        
                                                                                                                                                                                                        
ASM Extent Relocatio XQ                   purification         wait for relocation                                                                                                                      
n Enqueue                                                      before doing block p                                                                                                                     
                                                               urification                                                                                                                              
                                                                                                                                                                                                        
ASM Disk AU Lock     AD                   allocate AU          Synchronizes accesse                                                                                                                     
                                                               s to a specific ASM                                                                                                                      
                                                               disk AU                                                                                                                                  
                                                                                                                                                                                                        
ASM Disk AU Lock     AD                   deallocate AU        Synchronizes accesse                                                                                                                     
                                                               s to a specific ASM                                                                                                                      
                                                               disk AU                                                                                                                                  
                                                                                                                                                                                                        
ASM Disk AU Lock     AD                   relocate AU          Synchronizes accesse                                                                                                                     
                                                               s to a specific ASM                                                                                                                      
                                                               disk AU                                                                                                                                  
                                                                                                                                                                                                        
ASM Disk AU Lock     AD                   flush writes to AU   Waits for pending wr                                                                                                                     
                                                               ites to an AU to be                                                                                                                      
                                                               flushed                                                                                                                                  
                                                                                                                                                                                                        
ASM Disk Online Lock DO                   disk online          Synchronizes disk on                                                                                                                     
                                                               lines and their reco                                                                                                                     
                                                               very                                                                                                                                     
                                                                                                                                                                                                        
ASM Disk Online Lock DO                   disk online recovery Synchronizes disk on                                                                                                                     
                                                               lines and their reco                                                                                                                     
                                                               very                                                                                                                                     
                                                                                                                                                                                                        
ASM Disk Online Lock DO                   Staleness Registry c Synchronizes Stalene                                                                                                                     
                                          reate                ss Registry creation                                                                                                                     
                                                                                                                                                                                                        
ASM Disk Online Lock DO                   startup of MARK proc Synchronizes startup                                                                                                                     
                                          ess                   of MARK process                                                                                                                         
                                                                                                                                                                                                        
ASM Extent Fault Loc XL                   fault extent map     Keep multiple proces                                                                                                                     
k                                                              ses from faulting in                                                                                                                     
                                                                the same extent chu                                                                                                                     
                                                               nk                                                                                                                                       
                                                                                                                                                                                                        
ASM Disk Group Modif DG                   contention           Synchronizes accesse                                                                                                                     
ication                                                        s to ASM disk groups                                                                                                                     
                                                                                                                                                                                                        
ASM Local Disk Group DD                   contention           Synchronizes local a                                                                                                                     
                                                               ccesses to ASM disk                                                                                                                      
                                                               groups                                                                                                                                   
                                                                                                                                                                                                        
ASM Disk Header      HD                   contention           Serializes accesses                                                                                                                      
                                                               to ASM SGA data stru                                                                                                                     
                                                               ctures                                                                                                                                   
                                                                                                                                                                                                        
Diskgroup number gen DN                   contention           Serializes group num                                                                                                                     
erator                                                         ber generations                                                                                                                          
                                                                                                                                                                                                        
ASM File Access Lock FA                   access file          Synchronizes accesse                                                                                                                     
                                                               s to open ASM files                                                                                                                      
                                                                                                                                                                                                        
ASM Extent Relocatio RX                   relocate extent      Synchronizes relocat                                                                                                                     
n Lock                                                         ing ASM extents                                                                                                                          
                                                                                                                                                                                                        
ASM Extent Relocatio RX                   unlock extent        Synchronizes unlocki                                                                                                                     
n Lock                                                         ng ASM extents                                                                                                                           
                                                                                                                                                                                                        
Disk Group Recovery  FR                   contention           begin recovery of di                                                                                                                     
                                                               sk group                                                                                                                                 
                                                                                                                                                                                                        
Disk Group Recovery  FR                   use the thread       indicate this ACD th                                                                                                                     
                                                               read is alive                                                                                                                            
                                                                                                                                                                                                        
Disk Group Recovery  FR                   recover the thread   wait for lock domain                                                                                                                     
                                                                detach                                                                                                                                  
                                                                                                                                                                                                        
ACD Relocation Gate  FG                   serialize ACD reloca only 1 process in th                                                                                                                     
Enqueue                                   te                   e cluster may do ACD                                                                                                                     
                                                                relocation in a dis                                                                                                                     
                                                               k group                                                                                                                                  
                                                                                                                                                                                                        
ACD Relocation Gate  FG                   FG redo generation e resolve race conditi                                                                                                                     
Enqueue                                   nq race              on to acquire Disk G                                                                                                                     
                                                               roup Redo Generation                                                                                                                     
                                                                Enqueue                                                                                                                                 
                                                                                                                                                                                                        
ACD Relocation Gate  FG                   LGWR redo generation resolve race conditi                                                                                                                     
Enqueue                                    enq race            on to acquire Disk G                                                                                                                     
                                                               roup Redo Generation                                                                                                                     
                                                                Enqueue                                                                                                                                 
                                                                                                                                                                                                        
Disk Group Redo Gene FT                   allow LGWR writes    allow LGWR to genera                                                                                                                     
ration                                                         te redo in this thre                                                                                                                     
                                                               ad                                                                                                                                       
                                                                                                                                                                                                        
Disk Group Redo Gene FT                   disable LGWR writes  prevent LGWR from ge                                                                                                                     
ration                                                         nerating redo in thi                                                                                                                     
                                                               s thread                                                                                                                                 
                                                                                                                                                                                                        
Disk Group Chunk Mou FC                   open an ACD thread   LGWR opens an ACD th                                                                                                                     
nt                                                             read                                                                                                                                     
                                                                                                                                                                                                        
Disk Group Chunk Mou FC                   recover an ACD threa SMON recovers an ACD                                                                                                                     
nt                                        d                     thread                                                                                                                                  
                                                                                                                                                                                                        
ACD Xtnt Info CIC    FX                   issue ACD Xtnt Reloc ARB relocates ACD ex                                                                                                                     
                                          ation CIC            tent                                                                                                                                     
                                                                                                                                                                                                        
ASM Rollback Recover RB                   contention           Serializes ASM rollb                                                                                                                     
y                                                              ack recovery operati                                                                                                                     
                                                               ons                                                                                                                                      
                                                                                                                                                                                                        
IOServer Client      IC                   IOServer clientID    Gets a unique client                                                                                                                     
                                                                ID                                                                                                                                      
                                                                                                                                                                                                        
IOServer File        IF                   file open            File Open                                                                                                                                
IOServer File        IF                   file close           File Close                                                                                                                               
ASM Partnership and  PT                   contention           Synchronizes access                                                                                                                      
Status Table                                                   to ASM PST metadata                                                                                                                      
                                                                                                                                                                                                        
ASM Partnership and  PT                   ASM Storage May Spli Synchronize storage                                                                                                                      
Status Table                              t                    split check                                                                                                                              
                                                                                                                                                                                                        
ASM Attributes Enque KQ                   access ASM attribute Synchronization of A                                                                                                                     
                                                               SM cached attributes                                                                                                                     
                                                                                                                                                                                                        
ASM volume locks     AV                   persistent DG number prevent DG number co                                                                                                                     
                                                               llisions                                                                                                                                 
                                                                                                                                                                                                        
ASM volume locks     AV                   volume relocate      Serialize relocating                                                                                                                     
                                                                volume extents                                                                                                                          
                                                                                                                                                                                                        
ASM volume locks     AV                   AVD client registrat Serialize inst reg a                                                                                                                     
                                          ion                  nd first DG use                                                                                                                          
                                                                                                                                                                                                        
ASM volume locks     AV                   add/enable first vol Serialize taking the                                                                                                                     
                                          ume in DG             AVD DG enqueue                                                                                                                          
                                                                                                                                                                                                        
AWR Flush            WF                   contention           This enqueue is used                                                                                                                     
                                                                to serialize the fl                                                                                                                     
                                                               ushing of snapshots                                                                                                                      
                                                                                                                                                                                                        
AWR CDB-Wide Table L WT                   contention           This enqueue seriali                                                                                                                     
ock                                                            zes CDB-Wide Operati                                                                                                                     
                                                               on on AWR Table                                                                                                                          
                                                                                                                                                                                                        
AWR Purge            WP                   contention           This enqueue handles                                                                                                                     
                                                                concurrency between                                                                                                                     
                                                                purging and baselin                                                                                                                     
                                                               es                                                                                                                                       
                                                                                                                                                                                                        
DBFUS                FU                   contention           This enqueue is used                                                                                                                     
                                                                to serialize the ca                                                                                                                     
                                                               pture of the DB Feat                                                                                                                     
                                                               ure           Usage                                                                                                                      
                                                               and High Water Mark                                                                                                                      
                                                               Statistics                                                                                                                               
                                                                                                                                                                                                        
AWR undostat stat fl UF                   undo stat flush per  This enqueue is used                                                                                                                     
ush for PDB                               PDB                   to serialize undo s                                                                                                                     
                                                               tat flush per PDB                                                                                                                        
                                                                                                                                                                                                        
AWR import           WI                   AWR import           Serialize the import                                                                                                                     
                                                                of AWR dump files                                                                                                                       
                                                                                                                                                                                                        
AWR auto-export      WE                   AWR auto-export      Serialize auto-expor                                                                                                                     
                                                               t of AWR data                                                                                                                            
                                                                                                                                                                                                        
AWR mail package ret WD                   AWR mail package ret Serialize retrieving                                                                                                                     
rieval                                    rieval                AWR mail package                                                                                                                        
                                                                                                                                                                                                        
SQL Tuning Base Exis TB                   SQL Tuning Base Cach Synchronizes writes                                                                                                                      
tence Cache                               e Update             to the SQL Tuning Ba                                                                                                                     
                                                               se Existence Cache                                                                                                                       
                                                                                                                                                                                                        
SQL Tuning Base Exis TB                   SQL Tuning Base Cach Synchronizes writes                                                                                                                      
tence Cache                               e Load               to the SQL Tuning Ba                                                                                                                     
                                                               se Existence Cache                                                                                                                       
                                                                                                                                                                                                        
Active Session Histo SH                   contention           Should seldom see th                                                                                                                     
ry Flushing                                                    is contention as thi                                                                                                                     
                                                               s Enqueue is always                                                                                                                      
                                                                acquired in no-wait                                                                                                                     
                                                                mode                                                                                                                                    
                                                                                                                                                                                                        
Advisor Framework    AF                   task serialization   This enqueue is used                                                                                                                     
                                                                to serialize access                                                                                                                     
                                                                to an advisor task                                                                                                                      
                                                                                                                                                                                                        
MMON restricted sess MO                   contention           Serialize MMON opera                                                                                                                     
ion                                                            tions for restricted                                                                                                                     
                                                                sessions                                                                                                                                
                                                                                                                                                                                                        
MMON Management      MM                   MMON Autotask schedu Serialize MMON Autot                                                                                                                     
                                          ling                 ask scheduling                                                                                                                           
                                                                                                                                                                                                        
Log Lock             TL                   contention           Serializes threshold                                                                                                                     
                                                                log table read and                                                                                                                      
                                                               update                                                                                                                                   
                                                                                                                                                                                                        
Threshold Chain      TH                   metric threshold eva Serializes threshold                                                                                                                     
                                          luation               in-memory chain acc                                                                                                                     
                                                               ess                                                                                                                                      
                                                                                                                                                                                                        
Auto Task Serializat TK                   Auto Task Serializat Lock held by MMON to                                                                                                                     
ion                                       ion                   prevent other MMON                                                                                                                      
                                                               spawning of Autotask                                                                                                                     
                                                                Slave                                                                                                                                   
                                                                                                                                                                                                        
Auto Task Serializat TK                   Auto Task Slave Lock Serializes spawned A                                                                                                                     
ion                                       out                  utotask Slaves                                                                                                                           
                                                                                                                                                                                                        
Workload Capture and RR                   contention           Concurrent invocatio                                                                                                                     
 Replay                                                        n of DBMS_WORKLOAD_*                                                                                                                     
                                                                package API                                                                                                                             
                                                                                                                                                                                                        
Real-Time ADDM Flood RA                   RT ADDM flood contro Flood control in RAC                                                                                                                     
 Control                                  l                    . Acquired in no-wai                                                                                                                     
                                                               t.                                                                                                                                       
                                                                                                                                                                                                        
MWIN Schedule        MW                   contention           This enqueue is used                                                                                                                     
                                                                to serialize the ca                                                                                                                     
                                                               libration of the                                                                                                                         
                                                                      manageability                                                                                                                     
                                                                schedules with the                                                                                                                      
                                                               Maintenance Window                                                                                                                       
                                                                                                                                                                                                        
TOP UPD              TU                   UMF topology         Enqueue used to seri                                                                                                                     
                                                               alize updates to top                                                                                                                     
                                                               ology data                                                                                                                               

EQ_NAME              EQ_TYPE              REQ_REASON           REQ_DESCRIPTION                                                                                                                          
-------------------- -------------------- -------------------- --------------------                                                                                                                     
                                                                                                                                                                                                        
Job Scheduler        JS                   job run lock - synch Lock to prevent job                                                                                                                      
                                          ronize               from running elsewhe                                                                                                                     
                                                               re                                                                                                                                       
                                                                                                                                                                                                        
Job Scheduler        JS                   job recov lock       Lock to recover jobs                                                                                                                     
                                                                running on crashed                                                                                                                      
                                                               RAC inst                                                                                                                                 
                                                                                                                                                                                                        
Job Scheduler        JS                   wdw op               Lock got when doing                                                                                                                      
                                                               window open/close                                                                                                                        
                                                                                                                                                                                                        
Job Scheduler        JS                   evt notify           Lock got during even                                                                                                                     
                                                               t notification                                                                                                                           
                                                                                                                                                                                                        
Job Scheduler        JS                   aq sync              Scheduler evt code a                                                                                                                     
                                                               nd AQ sync                                                                                                                               
                                                                                                                                                                                                        
Job Scheduler1       JG                   queue lock           Lock on internal sch                                                                                                                     
                                                               eduler queue                                                                                                                             
                                                                                                                                                                                                        
Job Scheduler1       JG                   q mem clnup lck      Lock obtained when c                                                                                                                     
                                                               leaning up q memory                                                                                                                      
                                                                                                                                                                                                        
Job Scheduler1       JG                   contention           Synchronizes accesse                                                                                                                     
                                                               s to the job cache                                                                                                                       
                                                                                                                                                                                                        
Job Scheduler1       JG                   sch locl enqs        Scheduler non-global                                                                                                                     
                                                                enqueues                                                                                                                                
                                                                                                                                                                                                        
Job Scheduler1       JG                   evt notify           Lock got during even                                                                                                                     
                                                               t notification                                                                                                                           
                                                                                                                                                                                                        
Job Scheduler1       JG                   evtsub add           Lock got when adding                                                                                                                     
                                                                subscriber to event                                                                                                                     
                                                                q                                                                                                                                       
                                                                                                                                                                                                        
Job Scheduler1       JG                   evtsub drop          Lock got when droppi                                                                                                                     
                                                               ng subscriber to eve                                                                                                                     
                                                               nt q                                                                                                                                     
                                                                                                                                                                                                        
DBKR                 AU                   ADR Purge Operation  This enqueue is used                                                                                                                     
                                                                to serialize ADR pu                                                                                                                     
                                                               rge operation                                                                                                                            
                                                                                                                                                                                                        
Auto Online Exadata  XD                   ASM disk drop/add    Serialize Auto Drop/                                                                                                                     
disks                                                          Add Exadata disk ope                                                                                                                     
                                                               rations                                                                                                                                  
                                                                                                                                                                                                        
Auto Online Exadata  XD                   ASM disk ONLINE      Serialize ONLINE Exa                                                                                                                     
disks                                                          data disk operations                                                                                                                     
                                                                                                                                                                                                        
Auto Online Exadata  XD                   ASM disk OFFLINE     Serialize OFFLINE Ex                                                                                                                     
disks                                                          adata disk operation                                                                                                                     
                                                               s                                                                                                                                        
                                                                                                                                                                                                        
PDB SGA ALLOCATION   SN                   PDB SGA allocation   Synchronize PDB SGA                                                                                                                      
                                                               allocation                                                                                                                               
                                                                                                                                                                                                        
PDB SGA ALLOCATION   SN                   PDB SGA free         Synchronize PDB SGA                                                                                                                      
                                                               Free                                                                                                                                     
                                                                                                                                                                                                        
PDB SGA ALLOCATION   SN                   PDB SGA protection   Synchronize PDB SGA                                                                                                                      
                                                               Protection                                                                                                                               
                                                                                                                                                                                                        
PDB DDL Operations   PB                   PDB Lock             Enqueue used to sync                                                                                                                     
                                                               hronize PDB DDL oper                                                                                                                     
                                                               ations                                                                                                                                   

Leave a Reply