Shared Pool Waits

Kyle Hailey
http://perfvision.com
[email protected]
Shared Pool Waits
1. Latch: Library Cache
2. Latch: Shared Pool Latch
3. Mutexes
4. Library Cache Pin
5. Library Cache Lock
6. Library Cache Load Lock
7. Row Cache Lock

Copyright 2006 Kyle Hailey

Library Cache

Lib
Cache

Copyright 2006 Kyle Hailey

Shared Pool Structure
Hash
Table
SQL statements are hashed
handle
On their text. The resulting
handle handle Hash is used to find the appropriate
bucket, which is searched for the
Compiled SQL. If it’s not there,
then we parse it.

handle handle

handle

handle handle handle

handle handle handle

handle

Copyright 2006 Kyle Hailey

Shared Pool Latch
 Cause: Hard Parses by Concurrent Sessions
 Contention can arise when too many sessions are hard
parsing and looking for space in the shared pool.
 Protects Space Allocation in the Shared Pool
 Protects the structure containing memory chunks
 Ensures two users don’t get same chunk of
memory

Copyright 2006 Kyle Hailey

Shared Pool Latch
Get library cache latch
Get shared pool latch
Search right bucket
Find best fit
If lists get long, search gets long

_kghdsidx_count number of shared pool latches

Not supported to change, but increasing it can increase
ORA-4031s if shared pool Is not increased as well

Copyright 2006 Kyle Hailey

Shared Pool Latch
Shared Pool Latch covers changes in the lists
of free memory chunks

Shared Pool Free Space

Copyright 2006 Kyle Hailey

Shared Pool Latch 8.1.6

Bucket sizes
0 < 80 bytes
1 < 144
2 < 272
3 < 528 Shared Pool pre 8.1.6
4 < 1040 Memory Chunk Buckets
5 < 2064
6 < 4112
7 < 8208
8 < 16400
9 < 32784
10 bigger

Copyright 2006 Kyle Hailey

Shared Pool Latch

Shared Pool Latch

Shared Pool Free Space 8.1.6+

Before 8.1.6, oversizing the shared pool could be
a problem, after 8.1.6 should be fine

Copyright 2006 Kyle Hailey

Shared Pool Latch
Shared Pool
Memory Chunk Buckets 8.1.6 and up
0 16 bytes
1 20 bytes
… (0-198 only have one chunk size in bucket)
198 808 bytes
199 812 to 872
…. (199-248 only have 16 possible chunk sizes per bucket)
248 3948 - 4008
249 4012 - 4104
250 4108 - 8204
251 8204 - 16392
252 16396 - 32776
253 32780 - 65544
254 bigger

Copyright 2006 Kyle Hailey

Library Cache Latches
 Protects changes in Library Cache
 Library Locks are not atomic
 Thus need library cache latch
 Broken out into
 library cache pin allocation
 library cache lock allocation
 library cache lock
 library cache
 library cache pin
 library cache load lock

Copyright 2006 Kyle Hailey

Library Cache
Hash Table

pin lock

pin lock

handle handle

Find and Lock

Pin (and Load)

Copyright 2006 Kyle Hailey

Library Cache Structures
Hash Table

waiters

pin lock

pin lock
Library Cache Latch

pin lock
holders
pin lock

handle
Handle handle handle
Cursor(0)
flags
Cursor (0)
Heap 1
pin lock
Heap 0
Heap 6
pin lock

Child cursor 1

Child cursor
2

Child cursor 3
Copyright 2006 Kyle Hailey
Library Cache Latch Contention
 Excessive Hard Parsing
 Not Sharing SQL – use of Literal Values
 Shared Pool too small
 Too many invalidations

 Excessive Soft Parsing

Copyright 2006 Kyle Hailey

Sharing SQL & Literals

select
select
plan_hash_value,
plan_hash_value,
count(plan_hash_value)
count(plan_hash_value)
from
from
v$sql
v$sql
group
groupby
by plan_hash_value,
plan_hash_value,
order
orderby
bycount(plan_hash_value)
count(plan_hash_value)

SQL>
SQL> @dups
@dups
PLAN_HASH_VALUE
PLAN_HASH_VALUE CNT
CNT
---------------
--------------- ----------
----------
272002086
272002086 520
520
Copyright 2006 Kyle Hailey
Sharing SQL & Literals
SQL>
SQL> @dups
select sql_text
select sql_text @dups
from
from v$sql
v$sql PLAN_HASH_VALUE
PLAN_HASH_VALUE CNT
CNT
where
where ---------------
--------------- ----
----
plan_hash_value = 272002086 272002086
272002086 520
520
plan_hash_value = 272002086
and
andrownum
rownum<< 10;
10;
SQL_TEXT
SQL_TEXT
-----------------------------------------------
-----------------------------------------------
SELECT
SELECT ** FROM
FROM dual
dual WHERE
WHERE dummy=-634891633
dummy=-634891633
SELECT
SELECT ** FROM
FROM dual
dual WHERE
WHERE dummy=1987751014
dummy=1987751014
SELECT
SELECT ** FROM
FROM dual
dual WHERE
WHERE dummy=25965276
dummy=25965276
SELECT
SELECT ** FROM
FROM dual
dual WHERE
WHERE dummy=32449789
dummy=32449789
SELECT
SELECT ** FROM
FROM dual
dual WHERE
WHERE dummy=-364632215
dummy=-364632215
SELECT
SELECT ** FROM
FROM dual
dual WHERE
WHERE dummy=-34273351
dummy=-34273351
SELECT
SELECT ** FROM
FROM dual
dual WHERE
WHERE dummy=-699712683
dummy=-699712683
SELECT
SELECT ** FROM
FROM dual
dual WHERE
WHERE dummy=1752437199
dummy=1752437199
SELECT
SELECT ** FROM
FROM dual
dual WHERE
WHERE
Copyright dummy=-1081512404
2006 Kyledummy=-1081512404
Hailey
Cursor Sharing

 Bind Variables
 Select * from dual where dummy = :var;
 Cursor_Sharing
 Cursor_sharing = Force
Oracle replaces variables with bind variables
 Defaults to Exact

Copyright 2006 Kyle Hailey

Shared Pool too Small

SQL>
SQL> select
select namespace,
namespace, reloads
reloads
from
from v$librarycache;
v$librarycache;
NAMESPACE
NAMESPACE RELOADS
RELOADS
---------------
--------------- ----------
----------
SQL
SQL AREA
AREA 367
367
TABLE/PROCEDURE
TABLE/PROCEDURE 592
592

 Reloads means Cursor heaps were kicked

out implying shared_pool too small

Copyright 2006 Kyle Hailey

Invalidations
SQL>
SQL> select
select namespace,
namespace,
invalidations
invalidations
from
from v$librarycache;
v$librarycache;
NAMESPACE
NAMESPACE INVALIDATIONS
INVALIDATIONS
---------------
--------------- -------------
-------------
SQL
SQL AREA
AREA 6065
6065
 Changes in dependent objects invalidate
cursor
FOR
FOR i IN 1..3000
i IN 1..3000 LOOP
LOOP
l_cursor:=dbms_sql.open_cursor;
l_cursor:=dbms_sql.open_cursor;
dbms_sql.parse(l_cursor,
dbms_sql.parse(l_cursor,
'SELECT
'SELECT * FROM toto',dbms_sql.native);
* FROM toto',dbms_sql.native);
execute
execute immediate
immediate'analyze table
'analyze toto
table compute
toto statistics';
compute statistics';
dbms_sql.close_cursor(l_cursor);
dbms_sql.close_cursor(l_cursor);
END
ENDLOOP;
LOOP;
Copyright 2006 Kyle Hailey
Soft Parsing
Cursor Memory
= Latch
lock lock lock lock lock

pin pin pin pin pin

Execute 1 Execute 2 Execute 3 Execute 4 Execute 5

Re-Executing a Cursor
1. Libray Cache latch
2. Locks
3. Pins
Copyright 2006 Kyle Hailey
Session Cached Cursors

= Latch Cursor Memory

lock

pin pin pin pin pin

Execute 1 Execute 2 Execute 3 Execute 4 Execute 5

Session_cached_cursor:
If Opening/Closing keeps locked in Memory
Copyright 2006 Kyle Hailey
Session Cached Cursors
FOR
FORi iIN
IN1..30000
1..30000LOOP
LOOP
l_cursor:=dbms_sql.open_cursor;
l_cursor:=dbms_sql.open_cursor;
dbms_sql.parse(l_cursor,'SELECT
dbms_sql.parse(l_cursor,'SELECT**FROM
FROMdual’,dbms_sql.native);
dual’,dbms_sql.native);
dbms_sql.close_cursor(l_cursor);
dbms_sql.close_cursor(l_cursor);
END
ENDLOOP;
LOOP;

Session_cached_cursors=0
Latch Gets
----- ----
library cache lock 120,028
library cache 180,074
library cache pin 60,048
Session_cached_cursors=20

library cache lock 4

library cache 60,061
library cache pin
Copyright 2006 Kyle Hailey 60,048
 Cursor Space for Time

= Latch Cursor Memory

Open
lock
Close
Cursor pin
Cursor

Execute 1 Execute 2 Execute 3 Execute 4 Execute 5

Cursor_space_for_time=true :
if open and re-executing – keeps cursor pinned
(Cursor already locked because cursor is kept open)
Copyright 2006 Kyle Hailey
Cursor Space For Time
FOR
FORi iININ1..30000
1..30000LOOP
LOOP
rc:=dbms_sql.execute(l_cursor);
rc:=dbms_sql.execute(l_cursor);
IFIFDBMS_SQL.FETCH_ROWS
DBMS_SQL.FETCH_ROWS(l_cursor)
(l_cursor)<<00THEN
THEN
DBMS_SQL.COLUMN_VALUE
DBMS_SQL.COLUMN_VALUE(l_cursor,(l_cursor,1,
1,cnt);
cnt);
end
endif;if;
End
Endloop;
loop;
Cursor_space_for_time=false
Latch Gets
----- ----
library cache lock 35
library cache 60,096
library cache pin 60,044
Cursor_space_for_time=true

library cache lock 30

library cache 85
library cache pin
Copyright 2006 Kyle Hailey 42
Efficient Lock and Pinning
 Reduce use of latches
 Improve throughput
 Improve Concurrency ***

Copyright 2006 Kyle Hailey

Cursor Sharing
select * from (
select sql_id, count(*) cnt
pin lock from V$SQL_SHARED_CURSOR
pin lock
group by sql_id )
where cnt > 5
Handle
handle
handle handle handle order by cnt;
Cursor(0)
flags
Cursor (0)

Heap 1
Child cursor 2 Heap 0
Heap 6

Heap 1
Child cursor 3 Heap 0
Heap 6

Heap 1
Child cursor 4 Heap 0
Heap 6

Copyright 2006 Kyle Hailey

V$SQL_SHARED_CURSOR

 10gR2, 53 reasons why cursors aren’t shared

 If using “cursor_sharing=similar” might not
work – bugs
 Examples
 OPTIMIZER_MODE_MISMATCH , see V$SQL_OPTIMIZER_ENV
 STATS_ROW_MISMATCH, could be sql trace
 AUTH_CHECK_MISMATCH
TRANSLATION_MISMATCH – different object in SQL stmt
 BIND_MISMATCH – bind variable different sizes
 LANGUAGE_MISMATCH – NLS Language

http://www.juliandyke.com/Presentations/Presentations.html#LibraryCacheInternals

Copyright 2006 Kyle Hailey

V$SQL_SHARED_CURSOR
UNBOUND_CURSOR USER_BIND_PEEK_MISMATCH
SQL_TYPE_MISMATCH
OPTIMIZER_MISMATCH TYPCHK_DEP_MISMATCH
OUTLINE_MISMATCH NO_TRIGGER_MISMATCH
STATS_ROW_MISMATCH FLASHBACK_CURSOR
LITERAL_MISMATCH ANYDATA_TRANSFORMATION
SEC_DEPTH_MISMATCH INCOMPLETE_CURSOR
EXPLAIN_PLAN_CURSOR TOP_LEVEL_RPI_CURSOR
BUFFERED_DML_MISMATCH DIFFERENT_LONG_LENGTH
PDML_ENV_MISMATCH LOGICAL_STANDBY_APPLY
INST_DRTLD_MISMATCH DIFF_CALL_DURN
SLAVE_QC_MISMATCH BIND_UACS_DIFF
TYPECHECK_MISMATCH PLSQL_CMP_SWITCHS_DIFF
AUTH_CHECK_MISMATCH CURSOR_PARTS_MISMATCH
BIND_MISMATCH STB_OBJECT_MISMATCH
DESCRIBE_MISMATCH ROW_SHIP_MISMATCH
LANGUAGE_MISMATCH PQ_SLAVE_MISMATCH
TRANSLATION_MISMATCH TOP_LEVEL_DDL_MISMATCH
ROW_LEVEL_SEC_MISMATCH MULTI_PX_MISMATCH
INSUFF_PRIVS BIND_PEEKED_PQ_MISMATCH
INSUFF_PRIVS_REM MV_REWRITE_MISMATCH
REMOTE_TRANS_MISMATCH ROLL_INVALID_MISMATCH
LOGMINER_SESSION_MISMATCH OPTIMIZER_MODE_MISMATCH
INCOMP_LTRL_MISMATCH PX_MISMATCH
OVERLAP_TIME_MISMATCH MV_STALEOBJ_MISMATCH
SQL_REDIRECT_MISMATCH FLASHBACK_TABLE_MISMATCH
MV_QUERY_GEN_MISMATCH LITREP_COMP_MISMATCH

Copyright 2006 Kyle Hailey

10g : Mutex

 Mutex
 Mutual exclusion object
 Similar to a latch, prevents
 Deallocation while someone is using it
 Read/write while someone else is modifying

 Different from latch

 Every object can have it’s own mutex
 A mutex can cover multiple objects
 Usually dynamically allocated along with structure they
protect
 Can be stored in the structure, thus destroying structure
deletes the mutex

Copyright 2006 Kyle Hailey

Mutexes

 10gR2 new library cache latch mechanism

 Replace latches
 Takes less memory
 From Tanel Pode, On 32bit linux installation a
 mutex was 28 bytes in size,
 regular latch structure was 110 bytes.
 Takes less instructions to
 mutex get is about 30-35 instructions
 latch get is 150-200 instructions
 Less contention than latches, because there can be
more mutexes
 Mutexes stored in each child cursor
 Turn off with
_kks_use_mutex_pin=false
unsupported

Copyright 2006 Kyle Hailey

Mutex Views and Stats
 Cursor:mutex X  Views
 building a new cursor under a parent  V$mutex_sleep
 building and updating cursor-related statistics
 V$mutex_sleep_history
 capture SQL bind data
 Cursor:mutex S
 examining a parent (when looking for a cursor to execute)
 examining a cursor’s statistics (usually querying v$sqlstats)
 Cursor:pin X
 When attempting to rebuild a cursor. This event should not
be seen typically, because if a cursor is currently being used,
and it needs to be rebuilt, another cursor will be created
Instead of “library cache pin”
 Cursor:pin S
cursor_space_for_time
 Pin cursor for execute, and cursor is currently being
examined by another S not needed
 Cursor:pin S wait on X
 Pinning a cursor for execute
 Bug on 10.2.0.3 typically with DBMS_STATS
 Metalink Note:401435.1, Note:5907779.8, bug 5907779
Copyright 2006 Kyle Hailey
Mutex “cursor: pin”
 cursor: pin ( S, S wait on X)
 re-executions of the same cursors
 Instead of latching for execute pin we use a shared
mutex
 If can’t get the mutex spin
 Turning off should increase ‘library cache pin’ events
 _kks_use_mutex_pin=false
 Contention should be worse for latches because latches
cover multiple objects
 cursor_space_for_time not needed

Copyright 2006 Kyle Hailey

lock and pins
1. Library Cache Pin
2. Library Cache Lock
3. Library Cache Load Lock

 Contention when Sessions try to

 load/compile same SQL
 Compile package others are running

 Locks and Pins are usually in share

mode unless modifications are being
made
Copyright 2006 Kyle Hailey
Lib Cache Locks and Pins

 Object dependency
 lock in Null
 Cursor execution
 lock in null
 Pin in Share

 Cursor compilation
 Lock exclusive
 Pin exclusive

Copyright 2006 Kyle Hailey

library cache lock

 P1 = address of object
 P2 = address of lock
 P3 = mode | namespace
 See
 x$kgllk
pin lock
 dba_kgllock

pin lock

handle handle handle

Copyright 2006 Kyle Hailey

library cache pin

 P1 = address of object
 P2 = address of lock
 P3 = Mode | Namespace
 See
 dba_kgllock
 x$kglpn

pin lock

pin lock

handle handle handle

Copyright 2006 Kyle Hailey

Library cache lock & pin

select
select
w.sid,
w.sid,
kglob.
kglob. kglnaown
kglnaown cursor_owner
cursor_owner,,
kglob.KGLNAOBJ
kglob.KGLNAOBJcursor_object
cursor_object
from
from
x$kglob
x$kglobkglob,
kglob,
v$session_wait
v$session_waitww
where
where
kglob.KGLHDADR=
kglob.KGLHDADR=w.P1RAW
w.P1RAW and
and
event
eventlike
like'%library%';
'%library%';

Copyright 2006 Kyle Hailey

Lib Cache Lock : blockers and waiters

select
select
waiter.sid
waiter.sid waiter,
waiter,
waiter.event
waiter.eventwevent,
wevent,
to_char(blocker_event.sid)||','||to_char(blocker_session.serial#)
to_char(blocker_event.sid)||','||to_char(blocker_session.serial#)blocker, blocker,
substr(decode(blocker_event.wait_time,
substr(decode(blocker_event.wait_time,
0,0,blocker_event.event,
blocker_event.event,
'ON
'ONCPU'),1,30)
CPU'),1,30)beventbevent
from
from
x$kglpn
x$kglpnp,p, WAITER WLOCKP1
WAITER WLOCKP1
WEVENT
WEVENT
BLOCKER BEVENT
BLOCKER BEVENT
gv$session blocker_session, ------- ---------------- ----------------- --------- -----------------
gv$session blocker_session, ------- ---------------- ----------------- --------- -----------------
gv$session_wait 129
12900000003B76AB620
00000003B76AB620library librarycache
cachepin pin135,15534
135,15534PL/SQL
PL/SQLlock
gv$session_waitwaiter,
waiter, timer
timer
lock
gv$session_wait
gv$session_waitblocker_event
blocker_event
where
where
p.kglpnuse=blocker_session.saddr
p.kglpnuse=blocker_session.saddr
and p.kglpnhdl=waiter.p1raw
and p.kglpnhdl=waiter.p1raw
and
and(waiter.event
(waiter.eventinin( ('library
'librarycache
cachepin'
pin', ,
'library
'librarycache
cachelock'
lock', ,
'library
'librarycache
cacheload
loadlock')
lock')
and blocker_event.sid=blocker_session.sid
and blocker_event.sid=blocker_session.sid
and
andwaiter.sid
waiter.sid!=!=blocker_event.sid
blocker_event.sid
order by
order by
waiter.p1raw,waiter.sid;
waiter.p1raw,waiter.sid;
Copyright 2006 Kyle Hailey
library cache load lock

Waiting For a Reload by another Session

 P1 = object address
 P2 = lock address
 P3 = 100*mask+namespace

Copyright 2006 Kyle Hailey

Solutions
1. Library Cache Pin
2. Library Cache Lock
3. Library Cache Load Lock

 Have only one Session compile the same cursor

at a time
 Avoid compiling while executing
 Waits – find “competing” Sessions

Copyright 2006 Kyle Hailey

row cache lock : args
 P1 = cache#
 P2 = Lock Mode Held
 P3 = Lock Mode Requested

select
selectparameter
parameteras
as“name”
“name”
from
fromv$rowcache
v$rowcache
where
wherecache#
cache#==P1;
P1;

Copyright 2006 Kyle Hailey

Row Cache Lock - Statspack

Top
Top 55 Timed
Timed Events
Events Avg
Avg %Total
%Total
~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~ wait
wait Call
Call
Event
Event Waits
Waits Time
Time (s)
(s) (ms)
(ms) Time
Time
----------------------------------
---------------------------------- -----------
----------- ------
------ ------
------
row cache lock
row cache lock 11,925
11,925 57
57 55 53.8
53.8
CPU
CPU time
time 26
26 24.1
24.1
log file parallel write
log file parallel write 1,828
1,828 20
20 11
11 18.7
18.7
log
log file
file sequential
sequential read
read 15
15 11 66
66 .9
.9
control
control file
file parallel
parallel write
write 31
31 11 24
24 .7
.7

Copyright 2006 Kyle Hailey

Row Cache Lock – Statspack

Dictionary
Dictionary Cache
Cache Stats
Stats DB/Inst:
DB/Inst: linux3
linux3 Snaps:
Snaps: 68-69
68-69
->"Pct
->"Pct Misses"
Misses" should
should be
be very
very low
low (<2%
(<2% in
in most
most cases)
cases)
->"Final
->"Final Usage"
Usage" is
is the
the number
number of
of cache
cache entries
entries being
being
Get
Get Pct
Pct Scan
Scan Pct
Pct Mod
Mod Final
Final
Cache
Cache Requests
Requests Miss Miss Reqs
Reqs Miss
Miss Reqs
Reqs Usage
Usage
-------------
------------- --------
-------- ------
------ ----
---- ----
---- ------
------ -----
-----
dc_awr_control
dc_awr_control 11 0.0
0.0 00 00 11
dc_object_ids
dc_object_ids 10
10 0.0
0.0 00 00 650650
dc_objects
dc_objects 28
28 0.0
0.0 00 33 960960
dc_profiles
dc_profiles 66 0.0
0.0 00 00 11
dc_sequences
dc_sequences 12,002
12,002 0.0
0.0 00 12,002
12,002 44
dc_tablespaces
dc_tablespaces 31
31 0.0
0.0 00 00 10
10
dc_usernames
dc_usernames 14
14 0.0
0.0 00 00 11
11
dc_users
dc_users 262
262 0.0
0.0 00 00 22
22
Copyright 2006 Kyle Hailey
 Row Cache Lock - ASH
select
ash.session_id sid,
ash.blocking_session bsid,
nvl(o.object_name,to_char(CURRENT_OBJ#)) obj,
o.object_type otype,
CURRENT_FILE# filen,
CURRENT_BLOCK# blockn,
ash.SQL_ID,
nvl(rc.name,to_char(ash.p3)) row_cache
from v$active_session_history ash,
( select cache#, parameter name from v$rowcache ) rc,
all_objects o
SID BSID OBJ OTYPE FILEN BLOCKN SQL_ID ROW_CACHE
where event='row cache lock'
143 131 -1
and rc.cache#(+)=ash.p1 0 0 41y8w0sfqb61m dc_sequences
134 131(+)= ash.CURRENT_OBJ#
and o.object_id -1 0 0 dc_sequences
151 -1
and ash.session_state='WAITING' 0 0 dc_sequences
134 151
and ash.sample_time >-1 0
sysdate - &minutes/(60*24) 0 dc_sequences
131 151
Order by sample_time
-1 0 0 dc_sequences
151 -1 0 0 dc_sequences
Row Cache Lock

 Select seq.next_val
 Sequence cache set to 1
 Default sequence cache is 20

SQL> @sqltext
Enter value for 1: 41y8w0sfqb61m
SQL_FULLTEXT

SELECT TOTO_SEQ.NEXTVAL FROM DUAL

Copyright 2006 Kyle Hailey

Shared Pool Waits
 Parsing issues
 Shared Pool Latch
 Library Cache Pin
 Compilation problems
 Library Cache Lock
 Library Cache Load Lock
 Row Cache Lock
 Depends on the cache

Copyright 2006 Kyle Hailey

Summary

 Shared Pool Latch

 Shard pool too small or too much hard parsing
 Loading Same Cursor
 Library Cache Pin
 Library Cache Lock
 Library Cache Load Lock

 Row Cache Lock

 Depends on the cache

Copyright 2006 Kyle Hailey

Library Cache Latch Solutions

 Share Cursors
 Use bind variables
 User cursor_sharing=force

 Avoid invalidations and reloads

 Size shared_pool large enough
 Avoid changing dependent objects

 Soft Parsing
 Session_cached_cursors =20 : keep across open/close
 Cursor_space_for_time=true : keep pinned across executes
 hold_cursor=true : used in precompilers

Copyright 2006 Kyle Hailey