chapter 16: concurrency control

©Silberschatz, Korth and Sudarshan16.1Database System Concepts 3rd Edition

Chapter 16: Concurrency ControlChapter 16: Concurrency Control

Lock-Based Protocols

Timestamp-Based Protocols

Validation-Based Protocols (Optimistic Conc. Control)

Multiple Granularity

Multiversion Schemes

Deadlock Handling

Insert and Delete Operations


Lock-Based ProtocolsLock-Based Protocols

A lock is a mechanism to control concurrent access to a data item

Data items can be locked in two modes

1. Exclusive (X) mode: read/write

2. Shared (S) mode: read

Lock requests are made to concurrency-control manager. Transaction can proceed only after request is granted.


Lock-Based Protocols (Cont.)Lock-Based Protocols (Cont.)

Lock-compatibility matrix

A transaction may be granted a lock on an item if the requested lock is compatible with locks already held on the item by other transactions

Any number of transactions can hold shared locks on an item No other transaction may hold any lock on the item if any

transaction holds an exclusive lock on the item If a lock cannot be granted, the requesting transaction must wait

till all incompatible locks held by other transactions have been released.


Lock-Based Protocols (Cont.)Lock-Based Protocols (Cont.)

Example

lock-S(A);

read (A);

unlock(A);

lock-S(B);

read (B);

unlock(B);

display(A+B)

Locking as above is not sufficient to guarantee serializability If A and B get updated between the read of A and B, the displayed sum would

be wrong.

A locking protocol is a set of rules followed by all transactions while requesting and releasing locks. Locking protocols restrict the set of possible schedules.


Pitfalls of Lock-Based ProtocolsPitfalls of Lock-Based Protocols

Deadlock

Neither T3 nor T4 can make progress — executing lock-S(B) causes T4 to wait for T3 to release its lock on B, while executing lock-X(A) causes T3 to wait for T4 to release its lock on A.


Pitfalls of Lock-Based Protocols (Cont.)Pitfalls of Lock-Based Protocols (Cont.)

Starvation A transaction may be waiting for an X-lock on an item, while a

sequence of other transactions request and are granted an S-lock on the same item.

Concurrency control manager can be designed to prevent starvation.


Two Phase Locking ProtocolTwo Phase Locking Protocol

Supports conflict serializability

Growing Phase Transaction may obtain locks

Transaction may not release locks

Shrinking Phase Transaction may release locks

Transaction may not obtain locks

Transactions can be serialized in the order of their lock points

(i.e. the points where transactions acquire their final locks).


Two-Phase Locking Protocol (Cont.)Two-Phase Locking Protocol (Cont.)

Potential deadlocks

Possible cascading roll-backs

To avoid, use strict 2PL.

A transaction must hold all its exclusive locks till it commits/aborts.

Rigorous 2PL

All locks are held till commit/abort. Transactions can be serialized in their commit order

Most commercial DB’s implement strict or rigorous 2PL


Timestamp-Based ProtocolsTimestamp-Based Protocols

Each transaction is issued a timestamp when it enters the system

Time-stamps determine the serializability order

Ensure that any conflicting read and write operations are executed in timestamp order

For each data Q maintain two timestamp values:

W-timestamp(Q) is the largest time-stamp of any transaction that executed write(Q) successfully

R-timestamp(Q) is the largest time-stamp of any transaction that executed read(Q) successfully


Timestamp Ordering ProtocolTimestamp Ordering Protocol

Suppose a transaction Ti issues a read(Q)

1. If TS(Ti) < W-timestamp(Q)

Reject the read operation and roll back Ti

2. If TS(Ti) W-timestamp(Q)

Execute read operation

R-timestamp(Q) = max(R-timestamp(Q), TS(Ti))


Timestamp Ordering ProtocolTimestamp Ordering Protocol

Suppose Ti issues write(Q)

If TS(Ti) < R-timestamp(Q) or TS(Ti) < W-timestamp(Q)

Reject the write operation and roll back Ti

Else

Execute the write operation

TS(Ti) = W-timestamp(Q)


Correctness of Timestamp-Ordering ProtocolCorrectness of Timestamp-Ordering Protocol

The timestamp-ordering protocol guarantees serializability since all the arcs in the precedence graph are of the form:

No cycles in the precedence graph No deadlock since no transaction ever waits May not be cascade free May not even be recoverable.

transactionwith smallertimestamp

transactionwith largertimestamp


Recoverability and Cascade FreedomRecoverability and Cascade Freedom

Problem with timestamp-ordering protocol:

Suppose Ti aborts, but Tj has read a data item written by Ti

Tj must abort; if Tj had been allowed to commit earlier, the schedule is not recoverable

Any transaction that has read a data item written by Tj must abort

Cascading rollback

Solution: Perform all writes at the end of a transaction

Exclusive access

Locking

Ensure transactions do not read data written by uncommitted transactions


Thomas’ Write RuleThomas’ Write Rule

Modified version of the timestamp-ordering protocol Obsolete write operations may be ignored under certain

circumstances.

When Ti attempts to write data item Q, if TS(Ti) < W-timestamp(Q),

then Ti is attempting to write an obsolete value of {Q}. Ignore this

{write} operation rather than rolling back Ti

Thomas' Write Rule allows greater potential concurrency.

Allows some view serializable schedules that are not conflict-

serializable

DoesThomas’ write rule eliminate the casecding rollback

problem? Why or why not?


Validation-Based ProtocolValidation-Based Protocol

Transaction (Ti ) execution phases 1. Read phase

Ti writes only to local variables

2. Validation phase Transaction Ti performs a validation test to determine if local

variables can be written without violating serializability.

3. Write phase If Ti is validated, the updates are applied to the database; otherwise,

Ti is rolled back

Optimistic concurrency control Transaction executes fully in the hope that all will go well during

validation


Validation-Based Protocol (Cont.)Validation-Based Protocol (Cont.)

Each transaction Ti has 3 timestamps

Start(Ti) : the time when Ti started its execution

Validation(Ti): the time when Ti entered its validation phase

Finish(Ti) : the time when Ti finished its write phase

Serializability order is determined by timestamp given at validation time to increase concurrency.

TS(Ti) = Validation(Ti)

Greater degree of concurrency if probability of conflicts is low The serializability order is not pre-decided and relatively less

transactions will have to be rolled back


Validation Test for Transaction Validation Test for Transaction TTjj

If for all Ti with TS (Ti) < TS (Tj) either one of the following condition holds:

finish(Ti) < start(Tj)

No overlapped execution

start(Tj) < finish(Ti) < validation(Tj) and the set of data items written by Ti does not intersect with the set of data items read by Tj

then validation succeeds and Tj can be committed. Otherwise, validation fails and Tj is aborted.

The writes of Tj do not affect reads of Ti since they occur after Ti has finished its reads

The writes of Ti do not affect reads of Tj since Tj does not read any item written by Ti


Schedule Produced by ValidationSchedule Produced by Validation

Valid schedule; conflict serializable?T14 T15

read(B)read(B)B = B-50read(A)A = A+50

read(A)(validate)display (A+B)

(validate)write (B)write (A)


Multiversion SchemesMultiversion Schemes

Multiversion schemes keep old versions of data item to increase concurrency Each successful write results in the creation of a new version

Use timestamps to label versions

When a read(Q) operation is issued, select an appropriate version of Q based on the timestamp of the transaction

reads never have to wait as an appropriate version is returned immediately

Ensureserializability

Efficient mechanism to select the appropriate version


Deadlock HandlingDeadlock Handling

Consider the following two transactions:

T1: write (X) T2: write(Y)

write(Y) write(X)

Schedule with deadlockT1 T2

lock-X on Xwrite (X)

lock-X on Ywrite (X) wait for lock-X on X

wait for lock-X on Y


Deadlock HandlingDeadlock Handling

Deadlock prevention

Ensure that the system will never enter into a deadlock state

Acquire all locks before starting execution

Impose partial ordering of all data items and require that a transaction can lock data items only in the specified order

Any problem?


More Deadlock Prevention StrategiesMore Deadlock Prevention Strategies

wait-die scheme — non-preemptive

Older transaction may wait for younger one to release data item. Younger are rolled back.

A transaction may die several times before acquiring needed data item

wound-wait scheme — preemptive

Older transaction wounds (forces rollback) younger transaction instead of waiting for it. Younger transactions may wait for older ones.

Fewer rollbacks than wait-die scheme


Deadlock prevention (Cont.)Deadlock prevention (Cont.)

Both in wait-die and in wound-wait schemes, a rolled back transactions is restarted with its original timestamp. Older transactions thus have precedence over newer ones, and starvation is hence avoided.

Timeout-Based Schemes : A transaction waits for a lock only for a specified amount of time.

After that, the wait times out and the transaction is rolled back.

Deadlocks are not possible

Potential starvation

Difficult to determine good value of the timeout interval


Deadlock DetectionDeadlock Detection

Wait-for graph G = (V, E),

V is a set of vertices (all the transactions in the system)

E is a set of edges; each element is an ordered pair Ti Tj

Ti is waiting for Tj to release a data item

The system is in a deadlock state iff the wait-for graph has a cycle

Invoke a deadlock-detection algorithm periodically to look for cycles


Deadlock Detection (Cont.)Deadlock Detection (Cont.)

Wait-for graph without a cycle Wait-for graph with a cycle


Deadlock RecoveryDeadlock Recovery

When deadlock is detected :

Roll back some victim transactions to break deadlock

Select that transaction as victim that will incur minimum cost.

Include the number of rollbacks in the cost factor to avoid starvation


Insert and Delete OperationsInsert and Delete Operations

If two-phase locking is used : Exclusive lock is necessary to insert or delete a tuple

Insertions and deletions can lead to the phantom phenomenon. T1: find all accounts in Perryridge

T2: insert a tuple in the relation, e.g., insert a new account at Perryridge

If the serialization order should be <T1, T2>, T1 & T2 conflict although they do not access any tuple in common

If only tuple locks are used, non-serializable schedules can result

Lock tables: low concurrency


Insert and Delete Operations (Cont.)Insert and Delete Operations (Cont.)

One solution: Associate a data item with the relation, to represent the information

about what tuples the relation contains Transactions scanning the relation acquire a shared lock in the data

item Transactions inserting or deleting a tuple acquire an exclusive lock on

the data item Low concurrency for insertions/deletions

e.g., two insertions of different tuples can not be executed concurrently

Index locking protocols Higher concurrency Prevent the phantom phenomenon by requiring locks

on certain index buckets e.g., lock B+tree nodes based on the serach key values

End of ChapterEnd of Chapter

chapter 16: concurrency control

Documents