All on Adaptive and Extended Cursor Sharing

28/11/15 Mohamed Houri www.hourim.wordpress.com
1
Adaptive Cursor Sharing
Short answer to sharing cursors and optimizing SQL
Mohamed Houri
www.hourim.wordpress.com
Mohamed Houri
www.hourim.wordpress.com

2
Agenda
Set the scene
Expose the performance problem caused by sharing cursors
Literal, bind variable, bind variable peeking and hard parsing
Introduce Adaptive Cursor Sharing feature
Explain the cursor bind sensitive property
Explain the cursor bind aware property
Show a simple practical ACS example
Explain the ACS monitoring v$sql views
Uncover the bind aware secret sauce
Show how ACS can introduce a serious perfomance issue
Conclusion

3
WHAT IS THE PROBLEM?
PART 0
Set the scene

4
Syntactic check
Syntax, keywords
Semantic check
Access, right, exist Store parent cursor in
v$sql(SGA)
Logical Optimization
Physical Optimization
Store child cursor in
v$sql(SGA)
Parent
cursor?
Child
cursor?
Execute SQL
No
No
Yes
Yes
Set the scene
Hardparse
Softparse

5
Using Literal variable
➔
hard parsing for each execution
➔
traumatizes the SGA
➔
burns a lot CPU
Set the scene
Using bind variables
➔
avoids hard parsing
➔
makes the SGA attractive
➔
uses less resource - CPU
generates “always“ an optimal plan
sharing plan is not always optimal

6
How to have best-of-both-world?
Set the scene
➔ Attractive SGA + less CPU consumption
➔ Optimal execution plan for each execution
Adaptive Cursor Sharing-ACS

7
ACS - triggering diagram
Invesigate this property

8
WHEN A CURSOR IS BIND SENSITIVE?
PART I
ACS

9
SQL> desc V$SQL
Name Null? Type
------------------------------- -------- -------------
1 SQL_TEXT VARCHAR2(1000)
2 SQL_FULLTEXT CLOB
3 SQL_ID VARCHAR2(13)
45 CHILD_NUMBER NUMBER
63 IS_OBSOLETE VARCHAR2(1)
64 IS_BIND_SENSITIVE VARCHAR2(1)
65 IS_BIND_AWARE VARCHAR2(1)
66 IS_SHAREABLE VARCHAR2(1)
ACS - v$sql

10
ACS – model
SQL> create table t_acs(n1 number, n2 number);
SQL> BEGIN
for j in 1..1200150 loop
if j = 1 then
insert into t_acs values (j, 1);
elsif j>1 and j<=101 then
insert into t_acs values(j, 100);
elsif j>101 and j<=1101 then
insert into t_acs values (j, 1000);
elsif j>10001 and j<= 110001 then
insert into t_acs values(j,10000);
else
insert into t_acs values(j, 1000000);
end if;
end loop;
commit;
END;
Inflexion point
Inflexion point

11
ACS – model
SQL> create index t_acs_i1 on t_acs(n2);
SQL> BEGIN
dbms_stats.gather_table_stats
(user
,'t_acs'
,method_opt => 'for all columns size 1'
,cascade => true
,estimate_percent => dbms_stats.auto_sample_size
);
END;
/
–- declare and affect a value to a bind variable
–- and run a query with range predicate
SQL> var ln2 number;
SQL> exec :ln2 := 100;
Without histogram

12
ACS – bind sensitive : range predicate
SQL> select count(1) from t_acs where n2 <= :ln2;
SQL> select
sql_id
,child_number
,is_bind_sensitive
from
v$sql
where
sql_id = 'ct0yv82p15jdw';
SQL_ID CHILD_NUMBER IS_BIND_SENSITIVE
------------- ------------ -----------------
ct0yv82p15jdw 0 Y
range predicate
cursor is bind sensitive

13
ACS – bind sensitive : equality predicate with histogram
SQL> BEGIN
dbms_stats.gather_table_stats
(user,'t_acs'
,method_opt => 'for all columns size auto'
,cascade => true
,estimate_percent => dbms_stats.auto_sample_size);
END;/
SQL> SELECT
column_name,
histogram
FROM user_tab_col_statistics
WHERE table_name = 'T_ACS'
AND column_name = 'N2';
COLUMN_NAME HISTOGRAM
----------------- -----------
N2 FREQUENCY
with histogram
with histogram

14
ACS – bind sensitive : equality predicate with histogram
SQL> select count(1) from t_acs where n2 = :ln2;
SQL> select
sql_id
,child_number
,is_bind_sensitive
from
v$sql
where
sql_id = 'f2pmwazy1rnfd';
------------- ------------ –-----------------
f2pmwazy1rnfd 0 Y
equality predicate
with histogram

15
ACS – bind sensitive : partition key
SQL> create table t_acs_part(n1 number, n2 number)
partition by range (n2)
( partition p1 values less than (100)
,partition p2 values less than (1000)
,partition p6 values less than (10000000));
SQL> –- insert data and gather stats without histogram
SQL> select column_name, histogram
FROM user_tab_col_statistics
where table_name = 'T_ACS_PART' AND column_name = 'N2';
COLUMN_NAM HISTOGRAM
---------- ---------
N2 NONE

16
ACS – bind sensitive : partition key
SQL> select
sql_id
,child_number
,is_bind_sensitive
from
v$sql
where
sql_id = 'byztzuffb65n9';
------------- ------------ –----------------
byztzuffb65n9 0 Y
partition key

17
ACS – bind sensitive : summary
range predicate (with simple statistics)
SQL> select count(1) from t_acs where n2 <= :ln2;
equality predicate (with histogram)
predicate with partition key (simple stats)

18
18
PART II
ACS-simple example
A SIMPLE ACS EXAMPLE

19
ACS-simple example
SQL> exec :ln2 := 100
SQL> select n2,count(1) from t_acs group by n2 order by 2;
N2 COUNT(1)
---------- ----------
1 1
100 100
1000 1000
10000 100000
1000000 1099049
index range scan
full table scan

20
ACS-simple example
SQL_ID f2pmwazy1rnfd, child number 0
-----------------------------------------------------
| Id | Operation | Name | Rows | Bytes |
-----------------------------------------------------
| 0 | SELECT STATEMENT | | | |
| 1 | SORT AGGREGATE | | 1 | 3 |
|* 2 | INDEX RANGE SCAN| T_ACS_I1 | 856 | 2568 |
-----------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
2 - access("N2"=:LN2)
optimal plan for the first execution.
Plan has been hard parsed

21
ACS-simple example
SQL> exec :ln2 := 1000000
–- 1st
execution with bind variable value = 1000000
-----------------------------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------------------------
2 - access("N2"=:LN2)
sharing plan is bad here

22
ACS-simple example
SQL> exec :ln2 := 1000000
–- 2nd
execution with bind variable value = 1000000
-----------------------------------------------------
-----------------------------------------------------
|* 2 | TABLE ACCESS FULL| T_ACS | 1104K| 3235K|
-----------------------------------------------------
---------------------------------------------------
2 – filter("N2"=:LN2) optimal plan at the second
execution

23
ACS-simple example
–- back to the first bind variable value 100
SQL> exec :ln2 := 100
------------------------------------------------------
------------------------------------------------------
------------------------------------------------------
---------------------------------------------------
2 – access("N2"=:LN2) execution plan is now immediately
optimal

24
SQL> select
sql_id
,child_number
,is_bind_sensitive
,is_bind_aware
from
v$sql
where
SQL_ID CHILD_NUMBER IS_BIND_SENS IS_BIND_AWARE
------------- ------------ –----------- –-------------
f2pmwazy1rnfd 0 Y N → index-RS
f2pmwazy1rnfd 1 Y Y → table-FS
f2pmwazy1rnfd 2 Y Y → index-RS
is that cursor is now bind aware
what happens?
ACS-simple example

25
ACS-simple example
We have gone wrong(index range scan plan shared) during the
first execution with :ln2 := 1000000
It is until the second execution with :ln2 := 1000000 that Oracle has
compiled a new optimal plan (full table scan)
We have to share the “wrong” plan during a certain number of
executions
This “certain number” of executions is strongly related to the number
of executions done at the initial bind variable value :ln2 := 100
This execution-count relationship will be explained later
(BUCKET_ID, COUNT)

26
26
PART III
ACS-bind aware secret sauce
When Oracle decides that it is time to compile
a new execution plan?

27
27
SQL> desc V$SQL_CS_STATISTICS
Name Null? Type
------------------------------- -------- --------------
1 ADDRESS RAW(8)
2 HASH_VALUE NUMBER
5 BIND_SET_HASH_VALUE NUMBER
6 PEEKED VARCHAR2(1)
7 EXECUTIONS NUMBER
8 ROWS_PROCESSED NUMBER
9 BUFFER_GETS NUMBER
10 CPU_TIME NUMBER
11 CON_ID NUMBER
Starting from 12c this
view is obsolete

28
28
SQL> desc V$SQL_CS_HISTOGRAM
Name Null? Type
------------------------------- -------- -------------
1 ADDRESS RAW(8)
2 HASH_VALUE NUMBER
5 BUCKET_ID NUMBER
6 COUNT NUMBER
7 CON_ID NUMBER
number of executions
done at this child_number
linked to the number of
rows processed by
this child_number

29
29
SQL> desc V$SQL_CS_SELECTIVITY
Name Null? Type
----------------------- -------- --------------
1 ADDRESS RAW(8)
2 HASH_VALUE NUMBER
5 PREDICATE VARCHAR2(40)
6 RANGE_ID NUMBER
7 LOW VARCHAR2(10)
8 HIGH VARCHAR2(10)
9 CON_ID NUMBER
This view becomes useful
only when cursor is
bind aware

30
30
0 <= ROWS_PROCESSED< 1,000
increments COUNT
of BUCKET_ID n° 0
1,000 <= ROWS_PROCESSED<= 1,000,000
increments COUNT
of BUCKET_ID n° 1
ROWS_PROCESSED> 1,000,000
increments COUNT
of BUCKET_ID n° 2
Inflexion point
Inflexion point

31
SQL> exec :ln2 := 100 –- 1st
execution with this value
COUNT(1)
----------
100
Nbr of rows processed <1000
SQL> select
child_number,bucket_id,count
from
v$sql_cs_histogram
where sql_id = 'f2pmwazy1rnfd' ;
CHILD_NUMBER BUCKET_ID COUNT
------------ ---------- ----------
0 0 1
0 1 0
0 2 0
count(bucket_id n°0)
incremented

32
SQL> exec :ln2 := 100 –- 2nd
COUNT(1)
----------
100
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 2
0 1 0
0 2 0
incremented

33
SQL> exec :ln2 := 100 –- 3rd
COUNT(1)
----------
100
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 3
0 1 0
0 2 0
incremented

34
SQL> exec :ln2 := 1000 –- 1st
COUNT(1)
-------
1000
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 3
0 1 1
0 2 0
incremented
1000<= Nbr of rows processed <= 1e6
still sharing same plan

35
SQL> exec :ln2 := 1000 –-2nd
COUNT(1)
-------
1000
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 3
0 1 2
0 2 0
incremented

36
SQL> exec :ln2 := 1000 –-3rd
COUNT(1)
-------
1000
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 3
0 1 3
0 2 0
incremented

37
SQL> exec :ln2 := 1000 –-4th
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
1 0 0
1 1 1
1 2 0
0 0 3
0 1 3
0 2 0
incremented
new compiled plan

38
SQL> select
sql_id
,child_number
,is_bind_sensitive
,is_bind_aware
from
v$sql
where
------------- ------------ –----------- –-------------
f2pmwazy1rnfd 0 Y N
f2pmwazy1rnfd 1 Y Y
cursor n° 1 is now bind aware

39
39
ACS-bind aware secret sauce – rule n° 1 : adjacent buckets
COUNT(BUCKET_ID n° 1) = COUNT(BUCKET_ID n° 0)
OR
COUNT(BUCKET_ID n° 2) = COUNT(BUCKET_ID n° 1)
The next execution at BUCKET_ID n°1 (or n°2) will
 mark the cursor bind aware
 and a new execution plan will be compiled

40
SQL> exec :ln2 := 100 –- bucket_id n° 0
SQL> ../.. 10 executions
ACS-bind aware secret sauce : distant bucket_id
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 10
0 1 0
0 2 0
Incremented 10 times

41
SQL> exec :ln2 := 1000000 –- bucket_id n°2
COUNT(1)
----------
1099049
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 10
0 1 0
0 2 1
Incremented 1 time
Nbr of rows > 1e6

42
Question : How many executions at bucket_id n°2 we need to have
before Oracle compile a new optimal plan?
–- run this 3 times
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 10
0 1 0
0 2 4
incremented 3 times
Answer : 4 executions
still sharing the
same plan

43
SQL> exec :ln2 := 1000000 –-5th
execution at this value
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
1 0 0
1 1 0
1 2 1
0 0 10
0 1 0
0 2 4
10 exec at bucket_id n°0
new compiled plan

44
44
4 = ceil (10/3)
The next execution at BUCKET_ID n°2 will
 and a new execution plan will be compiled
Applies only with distant bucket_id (0 and 2)
COUNT(BUCKET_ID n° 2) = ceil (COUNT(BUCKET_ID n° 0)/3)

45
ACS-bind aware secret sauce : all buckets involved
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 10
0 1 3
0 2 1
Question : How many executions at bucket_id n°2 we need to have
before Oracle compiles a new optimal plan?

46
------------------------------------------------------------------------------
-- File name: fv_will_cs_be_bind_aware
-- Author : Mohamed Houri (Mohamed.Houri@gmail.com)
-- Date : 29/08/2015
-- Purpose : When supplied with 3 parameters
-- pin_cnt_bucket_0 : count of bucket_id n°0
-- this function will return a status:
-- 'Y' if the next execution at any bucket_id will mark the cursor bind aware
-- 'N' if the next execution any bucket_id will NOT mark the cursor bind aware
--------------------------------------------------------------------------------
create or replace function fv_will_cs_be_bind_aware
(pin_cnt_bucket_0 in number,pin_cnt_bucket_1 in number,pin_cnt_bucket_2 in number)
return varchar2 is
lv_will_be_bind_aware varchar2(1) := 'N';
ln_least_0_2 number := least(pin_cnt_bucket_0,pin_cnt_bucket_2);
ln_great_0_2 number := greatest(pin_cnt_bucket_0,pin_cnt_bucket_2);
begin
if pin_cnt_bucket_0 + pin_cnt_bucket_2 > = pin_cnt_bucket_1
and ln_least_0_2 >= ceil ((ln_great_0_2-pin_cnt_bucket_1)/3)then
return 'Y';
else
return 'N';
end if;
end fv_will_cs_be_bind_aware;

47
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 10
0 1 3
0 2 1
SQL> select fv_will_cs_be_bind_aware(10,3,1) acs from dual;
ACS
----
N
next execution will share the same plan

48
SQL> exec :ln2 := 1000000 –- 2nd
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 10
0 1 3
0 2 2
ACS
----
N next execution will share the same plan

49
SQL> exec :ln2 := 1000000 –- 3rd
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
0 0 10
0 1 3
0 2 3
ACS
----
Y next execution will compile a new plan

50
SQL> exec :ln2 := 1000000 –- 4th
SQL> select
from
v$sql_cs_histogram
------------ ---------- ----------
1 0 0
1 1 0
1 2 1
0 0 10
0 1 3
0 2 3
new execution plan compiled

51
51
The next exection at any BUCKET will
 and a new execution plan will be
compiled
SQL> select
fv_will_cs_be_bind_aware
(pin_cnt_bucket_0
,pin_cnt_bucket_1
,pin_cnt_bucket_2 )
from dual;
Existing plan will be
shared
N Y
Not extensively tested!!!

52
52
ACS-bind aware secret sauce : summary
COUNT(BUCKET_ID 1) =
COUNT(BUCKET_ID 0)
ADJACENT BUCKET_ID
(0-1 or 1-2)
next execution will compile
a new execution plan
COUNT(BUCKET_ID 2) =
CEIL(COUNT(BUCKET_ID 0)
/3)
DISTANT BUCKET_ID
(0-2)
select
fv_will_cs_be_bind_aware
(0,1,2) from dual; → Y
ALL BUCKET_ID
involved

53
53
PART IV
Extended Cursor Sharing
Extended Cursor Sharing- ECS

54
54
is responsible for marking bind aware
a bind sensitive cursor provided one of
the 3 rules is satisfied
is responsible for checking if an execution
plan of a bind aware cursor has to be
shared or a new plan has to be compiled
according to the bind variable selectivity
it peeks at each execution

55
SQL> select
sql_id
,child_number
,is_bind_sensitive
,is_bind_aware
from
v$sql
where
------------- ------------ –----------- –-------------
f2pmwazy1rnfd 0 Y N
f2pmwazy1rnfd 1 Y Y
once a cursor is bind aware a row exists in v$sql_cs_selectivity

56
SQL> select
child_number
,predicate
,low
,high
From v$sql_cs_selectivity
where sql_id = 'f2pmwazy1rnfd';
CHILD_NUMBER PREDICATE LOW HIGH
------------ ------------- ---------- ----------
2 =LN2 0.827448 1.011325
1 =LN2 0.000807 0.000986
for each execution bind variable selectivity is
checked: if it exists in one of the LOW-HIGH
ranges then share plan. If not then compile a new
plan and insert/update a new LOW-HIGH range
this is ECS

57
57
PART V
Extended Cursor Sharing causing a performance issue
When ACS (in fact ECS) becomes a serious
performance threat

58
SQL> select
sql_id
,count(1)
from
v$sql
where executions < 2
group by sql_id
having count(1) > 10
order by 2 desc;
SQL_ID COUNT(1)
------------- ----------
7zwq7z1nj7vga 44217
Why this high nbr
of versions?

59
SQL> @nonshared 7zwq7z1nj7vga
Show why existing SQL child cursors were not reused(V$SQL_SHARED_CURSOR)
-----------------
SQL_ID : 7zwq7z1nj7vga
ADDRESS : 000000406DBB30F8
CHILD_ADDRESS : 00000042CE36F7E8
CHILD_NUMBER : 99
BIND_EQUIV_FAILURE : Y
REASON :<ChildNode><ChildNumber>0</ChildNumber><ID>40</ID>
<reason>Bindmismatch(33)</reason><size>2x4</size>
<init_ranges_in_first_pass>0</init_ranges_in_first_pass>
<selectivity>1097868685</selectivity>
</ChildNode>
100 exec plans (0-99)
due to bind_equivalent_failure

60
SQL> select count(1)
from v$sql_shared_cursor
Where sql_id = '7zwq7z1nj7vga';
COUNT(1)
----------
45125
SQL> select count(1)
from v$sql_shared_cursor
Where sql_id = '7zwq7z1nj7vga'
and BIND_EQUIV_FAILURE = 'Y';
COUNT(1)
----------
45121
99% of non shared cursors are due to
BIND_EQUIV_FAILURE

61
BIND_EQUIV_FAILURE : bind value's selectivity does
not match that used to optimize the existing child
cursor
SQL> select
count(1)
from
v$sql_cs_selectivity
where
sql_id = '7zwq7z1nj7vga';
COUNT(1)
----------
16,847,320 !!!
for each execution ECS
will check this view!!!
CHILD_NUMBER PREDICATE LOW HIGH
------------ ------------- ---------- ----------
2 =LN2 0.827448 1.011325

62
Run a query using a bind aware cursor
Oracle (ECS layer code) will do behind the scene:
1. peeks at the bind variable value
2. runs a query against v$sql_cs_selectivity(16M of rows)
3. if low < selectivity < high then share existing plan
4. if selectity not found in low-high range then hard parse a new plan
If another user executes the same query:
1. Oracle will try to do the above 1-4 steps
2. if Oracle is still busy with above 1-4 steps then we start experiencing:
a) cursor: pin S wait on X
b) library cache lock

63
63
PART V
Adaptive-Extended Cursor Sharing
FINAL ACS-ECS DIAGRAM
https://hourim.wordpress.com/2015/08/12/adaptive-cursor-sharing-triggering-mechanism/

64
64
•Conclusion
• Literal variables are good for query performance
• very bad for resource and memory
• and they produce a non scalable application
• Bind variables are not always good for query performance
• very good for resource and memory
• and they produce a scalable application
• Adaptive cursor sharing allows query good performance
• even when using bind variable
• but be aware of the extra parsing work it might introduce

All on Adaptive and Extended Cursor Sharing

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (16)

Similar to All on Adaptive and Extended Cursor Sharing

Similar to All on Adaptive and Extended Cursor Sharing (20)

Recently uploaded

Recently uploaded (20)

All on Adaptive and Extended Cursor Sharing