Leveraging Lock Contention to Improve Transaction Applications. University of Washington

Transcription

1 Leveraging Lock Contention to Improve Transaction Applications Cong Yan Alvin Cheung University of Washington

2 Background Pessimistic locking-based CC protocols Poor performance under high data contention long lock waiting time and high abort rate Time breakdown for YCSB transaction under high data contention Main-memory DBMS, 2PL ( Staring into the Abyss: An Evaluation of Concurrency Control with One Thousand Cores, VLDB15) 2

3 Two-phase Locking Example transaction: online shopping Alice and Cong buying Echo at the same time void transaction(){ v = ; ; b = ; ; } select(c, Cong) void transaction(){ v = ; ; b = select(c, Cong); update(c, Cong); } update(c, Cong) P = Product table C = Customer table 3

4 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- T Product Echo T Customer Alice Cong :shared lock :exclusive lock 4

5 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- T Product Echo T Customer Alice Cong :shared lock :exclusive lock 5

6 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong :shared lock :exclusive lock 6

7 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong :shared lock :exclusive lock 7

8 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong :shared lock :exclusive lock 8

9 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong :shared lock :exclusive lock 9

10 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong :shared lock :exclusive lock 10

11 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong select(c, Cong) :shared lock :exclusive lock 11

12 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong select(c, Cong) update(c, Cong) :shared lock :exclusive lock 12

13 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) :shared lock :exclusive lock 13

14 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) select(c, Cong) update(c, Cong) :shared lock :exclusive lock 14

15 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) select(c, Cong) update(c, Cong) :shared lock :exclusive lock 15

16 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) select(c, Cong) update(c, Cong) :shared lock :exclusive lock 16

17 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) select(c, Cong) update(c, Cong) :shared lock :exclusive lock 17

18 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) select(c, Cong) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) update(c, Cong) :shared lock :exclusive lock 18

19 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) select(c, Cong) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) update(c, Cong) :shared lock :exclusive lock 19

20 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) select(c, Cong) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) update(c, Cong) :shared lock :exclusive lock 20

21 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) select(c, Cong) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) (Waiting for lock) update(c, Cong) :shared lock :exclusive lock 21

22 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) select(c, Cong) T Product Echo T Customer Alice Cong Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) (Waiting for lock) update(c, Cong) :shared lock :exclusive lock 22

23 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) select(c, Cong) Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) (Waiting for lock) Reduced time update(c, Cong) 23

24 Shortening Lock Waiting Original txn Reordered txn Execution time T1 T2 T3 T4 T5 T6 T1 T2 T3 T4 T5 T6 Reduced time Greater performance improvement when running with more concurrent txns 24

25 Two-phase Locking Execution time --(T1)-- Original txn --(T2)-- (Waiting for lock) select(c, Cong) QURO Reordered txn --(T1)-- --(T2)-- select(c, Cong) update(c, Cong) (Waiting for lock) update(c, Cong) 25

26 Overview QURO: compiler for query reordering Architecture Optimizations Evaluation QURO Implementation & benchmarks Compare the throughput of QURO-generated txn with: Original impl. / stored procedure / other concurrency control schemes 26

27 Overview QURO: compiler for query reordering Architecture Optimizations Evaluation QURO Implementation & benchmarks Compare the throughput of QURO-generated txn with: Original impl. / stored procedure / other concurrency control schemes 27

28 QURO Architecture Input: C++ transaction code with embedded SQL queries void transaction(){ v = ; ; b = ; ; } 28

29 QURO Architecture Input: C++ transaction code with embedded SQL queries void transaction(){ v = ; ; b = ; ; } Profile the application Analyze application code Reorder queries 29

30 QURO Architecture Input: C++ transaction code with embedded SQL queries void transaction(){ v = ; ; b = ; ; } Profile the application Analyze application code Reorder queries Output: C++ code with reordered SQL queries 30 void transaction(){ b = ; ; v = ; ; }

31 Preserving Semantics Analyze the relationship among queries Data dependency among program variables (RAW, WAR, WAW) 1. v1 = select(table1); 2. v2 = select(table2, v1); 3. update(table1, v3); Statement 1 should appear before statement 2 Database constraints (R/W on the same table, view, foreign key...) 1. v1 = select(table1); 2. v2 = select(table2, v1); 3. update(table1, v3); Statement 1 should appear before statement 3 31

32 ILP Formulation position of statement i contention level of query i Constraint: data dependencies & database constraints p i, (1 p i n) c i, (const. Larger c i, higher contention) 1. v1 = select(table1); 2. v2 = select(table2, v1); 3. update(table1, v3); p 1 < p 2, variable v1 p 1 < p 3, table1 Goal: contentious query appear as late as possible maximize n i=1 p i *c i Result: query order values of p 1, p 2,..., p n 32

33 ILP Formulation Goal: contentious queries appear as late as possible in transactions maximize n i=1 p i *c i void transaction(){ v = ; b = ; ; } 33

34 ILP Formulation Goal: contentious queries appear as late as possible in transactions maximize n i=1 p i *c i (Contention index) c 1 = 100 c 2 = 110 c 3 = 1 c 4 = 10 void transaction(){ v = ; b = ; ; } 34

35 ILP Formulation Goal: contentious queries appear as late as possible in transactions maximize n i=1 p i *c i (Contention index) (Order constraints) c 1 = 100 c 2 = 110 c 3 = 1 c 4 = 10 void transaction(){ v = ; b = ; ; } p 1 < p 2 p 3 < p 4 35

36 ILP Formulation Goal: contentious queries appear as late as possible in transactions maximize n i=1 p i *c i (Contention index) (Order constraints) c 1 = 100 c 2 = 110 c 3 = 1 c 4 = 10 void transaction(){ v = ; b = ; ; } p 1 < p 2 p 3 < p 4 ILP solver p 3 = 1 p 4 = 2 p 1 = 3 p 2 = 4 36

37 ILP Formulation Goal: contentious queries appear as late as possible in transactions maximize n i=1 p i *c i (Contention index) (Order constraints) c 1 = 100 c 2 = 110 c 3 = 1 c 4 = 10 void transaction(){ v = ; b = ; ; } p 1 < p 2 p 3 < p 4 ILP solver p 3 = 1 p 4 = 2 p 1 = 3 p 2 = 4 void transaction(){ b = ; ; v = ; ; } 37

38 How to get contention index? Profiling the application Clients repetitively issue transactions Calculate the standard deviation of query running time Larger the deviation, more likely to access contentious data Same machine settings, same workload (given by user) 38

39 Overview QURO: compiler for query reordering Architecture Optimizations Evaluation QURO Implementation & benchmarks Compare the throughput of QURO-generated txn with: Original impl. / stored procedure / other concurrency control schemes 39

40 Improving reorder results Allow more flexible reordering Loop fission for (i=1;i<n;i++){ update(table1, v1); update(table2, v2); } original : query on contentious data for (i=1;i<n;i++) update(table1, v1); for (i=1;i<n;i++) update(table2, v2); after loop fission for (i=1;i<n;i++) update(table2, v2); for (i=1;i<n;i++) update(table1, v1); after reordering Breaking conditional block 40

41 Reduce ILP solving time Using transitive closure to reduce # variables # constraints 41

42 Overview QURO: compiler for query reordering Architecture Optimizations Evaluation QURO Implementation & benchmarks Compare the throughput of QURO-generated txn with: Original impl. / stored procedure / other concurrency control schemes 42

43 Implementation QURO implementation: Build with Clang tools Use external ILP solver (gurobi) Experiment overview: System throughput (txns/sec), latency Increasing data contention Smaller database More clients 43

44 Benchmarks: TPC-C 5 types of transactions TPC-E trade-related of transaction (update/order/result/status) Bidding Evaluation Compare with: Original implementation Stored procedure implementation Other concurrency control protocols Experimental settings: MySQL GHz processors, 1056G memory 44

45 Overview QURO: compiler for query reordering Architecture Optimizations Evaluation QURO Implementation & benchmarks Compare the throughput of QURO-generated txn with: Original impl. / stored procedure / other concurrency control schemes 45

46 QURO vs. Original Benchmark: TPC-C payment transaction most contentious changing data size scaling to more threads most contentious latency: decreases up to 83% latency: decreases up to 70% 46 threads

47 QURO vs. Original Benchmark: TPC-C payment transaction most contentious changing data size scaling to more threads most contentious latency: decreases up to 83% latency: decreases up to 70% 47 threads

48 QURO vs. Original Benchmark: TPC-E trade update transaction most contentious changing data size scaling to more threads most contentious latency: decreases up to 75% 48 threads latency: decreases up to 66%

49 QURO vs. Original Mix of different transactions TPC-C standard mix: 5 types of transactions most contentious 49 threads

50 QURO vs. Stored-procedure TPC-C payment transaction most contentious 50

51 QURO vs. Other CC Schemes TPC-C a mix of payment and new order transactions Technical report: 51

52 Conclusion The order of queries has large impact on transaction performance. QURO leverages information about query contention, and automatically reorders the queries. Reordered code generated by QURO can improve throughput up to 6.53x, and can be applied to a wide range of applications. QURO also outperforms stored-proc and other concurrency control schemes under high data contention. Project website: 52

53 QURO vs. Worst-case Order Comparing with worst-case ordering most contentious most contentious TPCC payment transaction TPCC standard mix 53

54 QURO: Smaller Bufferpool Smaller bufferpool increase buffer management time TPC-C new order transaction smaller bufferpool 54

55 backup1 Analysis Trade-off Loop breaking most contentious : query time increase (after reorder) : query time decrease

56 backup 2 Comparing with other concurrency control schemes -(T1)- Execution -(T1)- -(T2)- -(T1)- -(T2)- -(T1)- -(T2)- time -(T2)- 2PL reordered MVCC OCC 2PL original :A transaction :Write operation on contentious data : Read operation on contentious data : OCC Validation phase : Abort window Execution of transactions T1 and T2 under different concurrency control schemes. Both T1 and T2 read and write the same tuple. 56