Timestamp based Concurrency Control

Timestamp-based concurrency control is a method used in database systems to ensure that transactions are executed safely and consistently without conflicts, even when multiple transactions are being processed simultaneously. This approach relies on timestamps to manage and coordinate the execution order of transactions. Refer to the timestamp of a transaction T as TS(T).

What is Timestamp Ordering Protocol?

The Timestamp Ordering Protocol is a method used in database systems to order transactions based on their timestamps. A timestamp is a unique identifier assigned to each transaction, typically determined using the system clock or a logical counter. Transactions are executed in the ascending order of their timestamps, ensuring that older transactions get higher priority.

For example:

• If Transaction T1 enters the system first, it gets a timestamp TS(T1) = 007 (assumption).
• If Transaction T2 enters after T1, it gets a timestamp TS(T2) = 009 (assumption).

This means T1 is "older" than T2 and T1 should execute before T2 to maintain consistency.

Key Features of Timestamp Ordering Protocol:

Transaction Priority:

• Older transactions (those with smaller timestamps) are given higher priority.
• For example, if transaction T1 has a timestamp of 007 times and transaction T2 has a timestamp of 009 times, T1 will execute first as it entered the system earlier.

Early Conflict Management:

• Unlike lock-based protocols, which manage conflicts during execution, timestamp-based protocols start managing conflicts as soon as a transaction is created.

Ensuring Serializability:

• The protocol ensures that the schedule of transactions is serializable. This means the transactions can be executed in an order that is logically equivalent to their timestamp order.

Basic Timestamp Ordering

Precedence Graph for TS ordering 

The Basic Timestamp Ordering (TO) Protocol is a method in database systems that uses timestamps to manage the order of transactions. Each transaction is assigned a unique timestamp when it enters the system ensuring that all operations follow a specific order making the schedule conflict-serializable and deadlock-free.

• Suppose, if an old transaction T_i has timestamp TS(T_i), a new transaction T_j is assigned timestamp TS(T_j) such that TS(T_i) < TS(T_j).

• The protocol manages concurrent execution such that the timestamps determine the serializability order.

• The timestamp ordering protocol ensures that any conflicting read and write operations are executed in timestamp order.

• Whenever some Transaction T tries to issue a R_item(X) or a W_item(X), the Basic TO algorithm compares the timestamp of T with R_TS(X) & W_TS(X) to ensure that the Timestamp order is not violated.

This describes the Basic TO protocol in the following two cases:

Whenever a Transaction T issues a W_item(X) operation, check the following conditions: 

• If R_TS(X) > TS(T) and if W_TS(X) > TS(T), then abort and rollback T and reject the operation. else,
• Execute W_item(X) operation of T and set W_TS(X) to TS(T) to the larger of TS(T) and current W_TS(X).

Whenever a Transaction T issues a R_item(X) operation, check the following conditions: 

• If W_TS(X) > TS(T), then abort and reject T and reject the operation, else
• If W_TS(X) <= TS(T), then execute the R_item(X) operation of T and set R_TS(X) to the larger of TS(T) and current R_TS(X). 

Whenever the Basic TO algorithm detects two conflicting operations that occur in an incorrect order, it rejects the latter of the two operations by aborting the Transaction that issued it.

Advantages of Basic TO Protocol

• Conflict Serializable: Ensures all conflicting operations follow the timestamp order.

• Deadlock-Free: Transactions do not wait for resources, preventing deadlocks.

• Strict Ordering: Operations are executed in a predefined, conflict-free order based on timestamps.

Drawbacks of Basic Timestamp Ordering (TO) Protocol

• Cascading Rollbacks : If a transaction is aborted, all dependent transactions must also be aborted, leading to inefficiency.

• Starvation of Newer Transactions : Older transactions are prioritized, which can delay or starve newer transactions.

• High Overhead: Maintaining and updating timestamps for every data item adds significant system overhead.

• Inefficient for High Concurrency: The strict ordering can reduce throughput in systems with many concurrent transactions.

Strict Timestamp Ordering

The Strict Timestamp Ordering Protocol is an enhanced version of the Basic Timestamp Ordering Protocol. It ensures a stricter control over the execution of transactions to avoid cascading rollbacks and maintain a more consistent schedule. 

Key Features

• Strict Execution Order: Transactions must execute in the exact order of their timestamps. Operations are delayed if executing them would violate the timestamp order, ensuring a strict schedule.

• No Cascading Rollbacks: To avoid cascading aborts, a transaction must delay its operations until all conflicting operations of older transactions are either committed or aborted.

• Consistency and Serializability: The protocol ensures conflict-serializable schedules by following strict ordering rules based on transaction timestamps.

For Read Operations (R_item(X)):

• A transaction T can read a data item X only if: W_TS(X), the timestamp of the last transaction that wrote to X, is less than or equal to TS(T), the timestamp of T and the transaction that last wrote to X has committed.

• If these conditions are not met, T's read operation is delayed until they are satisfied.

For Write Operations (W_item(X)):

• A transaction T can write to a data item X only if: R_TS(X), the timestamp of the last transaction that read X, and W_TS(X), the timestamp of the last transaction that wrote to X, are both less than or equal to TS(T) and all transactions that previously read or wrote X have committed.

• If these conditions are not met, T's write operation is delayed until all conflicting transactions are resolved.

Related GATE Questions on Timestamp Based Protocol 

1. GATE | GATE CS 2010 | Question 20
2. GATE | GATE-CS-2017 (Set 1) | Question 46
3. GATE | GATE-IT-2004 | Question 21