The document explains validation-based protocols in optimistic concurrency control, detailing three phases: read, validation, and write. It emphasizes the importance of timestamps in transaction management for ensuring serializability and describes multiple granularity locking (MGL) in database systems. MGL allows locks on hierarchical data objects, balancing concurrency and overhead through varying levels of granularity.

1. Validation Based Protocol
ANKUR SRIVASTAVA
DEPT OF CSE
JETGI, BBK
1

2. Definition:-In optimistic concurrency control techniques,
also known as validation or certification techniques, no
checking is done while the transaction is executing.
Also based on Timestamp Protocol. It has three phases:
• Read Phase:- During this phase, the system executes
transaction Ti. . It reads the values of the various data
items and stores them in variable local to Ti. It
performs all the write operations on temporary local
variables without update of the actual database.
2

3. • Validation Phase:- Transaction Ti performs a validation
test to determine whether it can copy to database the
temporary local variables that hold the result of write
operations without causing a violation of serializability.
• Write Phase:- If Transaction Ti succeeds in
validation, then the system applies the actual
updates to the database, otherwise the system rolls
back Ti.
3

4. To perform the validation test, we need to know when
the various phases of transaction Ti took place. We shall
therefore associate three different timestamps with
transaction Ti.
1. Start (Ti): the time when Ti, started its
execution.
2. Validation (Ti): the time when Ti finished its
read phase and started its validation phase.
3. Finish (Ti): the time when Ti finished its write
phase.
4

5. The Validation Test for Tj requires that, for all
transaction Ti with TS(Ti ) < TS(Tj ) one of the following
condition must hold:-
• Finish (Ti) < Start (Tj): Since Ti completes its
execution before Tj started, the serializability
order is indeed maintained.
• Start(Tj )<Finish(Ti ) <validation(Tj ): The
validation phase of Tj should occur after
Tifinishes.
5

6. Multiple Granularity
• Multiple granularity locking (MGL) is a locking
method used in database management
systems (DBMS) and relational databases. In
MGL, locks are set on objects that contain
other objects. ...
For example, a database may have files, which
contain pages, which further contain records.
6

7. • Allow data items to be of various sizes and define a
hierarchy of data granularities, where the small
granularities are nested within larger ones
• Can be represented graphically as a tree (but
don't confuse with tree-locking protocol)
• When a transaction locks a node in the tree
explicitly, it implicitly locks all the node's
descendents in the same mode.
7

8. Granularity of locking (level in tree where locking is
done):
fine granularity (lower in tree): high concurrency, high
locking overhead
coarse granularity (higher in tree): low locking
overhead, low concurrency
8

9. Example of Granularity Hierarchy
9

10. The highest level in the above example hierarchy is the entire
database.
The levels below are of type area, file and record in that order.
• Intention Lock Modes:-In addition to S and X lock
modes, there are three additional lock modes with
multiple granularity:
 intention-shared (IS): indicates explicit locking at a lower level of the tree but only
with shared locks.
 intention-exclusive (IX): indicates explicit locking at a lower level with exclusive or
shared locks
 shared and intention-exclusive (SIX): the subtree rooted by that node is locked
explicitly in shared mode and explicit locking is being done at a lower level with
exclusive-mode locks.
• intention locks allow a higher level node to be
locked in S or X mode without having to check all
descendent nodes.
10

11. THANKS
11