Alexey Scherbakov created IGNITE-16175:
------------------------------------------
Summary: Deadlock prevention implementation doesn't exactly
follows the definition
Key: IGNITE-16175
URL: https://issues.apache.org/jira/browse/IGNITE-16175
Project: Ignite
Issue Type: Improvement
Reporter: Alexey Scherbakov
h3. The actual definitions of deadlock prevention schemes look as the follows:
h3. Wait-Die Scheme
In this scheme, if a transaction requests to lock a resource (data item), which
is already held with a conflicting lock by another transaction, then one of the
two possibilities may occur −
* If TS(T{~}i{~}) < TS(T{~}j{~}) − that is T{~}i{~}, which is requesting a
conflicting lock, is older than T{~}j{~} − then T{~}i{~} is allowed to wait
until the data-item is available.
* If TS(T{~}i{~}) > TS(t{~}j{~}) − that is T{~}i{~} is younger than T{~}j{~} −
then T{~}i{~} dies. T{~}i{~} is restarted later with a random delay but with
the same timestamp.
This scheme allows the older transaction to wait but kills the younger one.
h3. Wound-Wait Scheme
In this scheme, if a transaction requests to lock a resource (data item), which
is already held with conflicting lock by some another transaction, one of the
two possibilities may occur −
* If TS(T{~}i{~}) < TS(T{~}j{~}), then T{~}i{~} forces T{~}j{~} to be rolled
back − that is T{~}i{~} wounds T{~}j{~}. T{~}j{~} is restarted later with a
random delay but with the same timestamp.
* If TS(T{~}i{~}) > TS(T{~}j{~}), then T{~}i{~} is forced to wait until the
resource is available.
This scheme, allows the younger transaction to wait; but when an older
transaction requests an item held by a younger one, the older transaction
forces the younger one to abort and release the item.
In both the cases, the transaction that enters the system at a later stage is
aborted.
*It seems current implementation doesn't exactly follow any of one.*
Currently is' better described as non-preemptive wound-wait.
Transactions must be restarted with the same timestamp to reduce abort rate.
This test must pass in wound-wait mode:
{code:java}
public void testWoundWait() {
accounts.recordView().upsert(makeValue(1, 100.));
InternalTransaction tx = (InternalTransaction)
igniteTransactions.begin();
InternalTransaction tx2 = (InternalTransaction)
igniteTransactions.begin();
var table = accounts.recordView().withTransaction(tx); // Older tx
var table2 = accounts.recordView().withTransaction(tx2); // Younger tx
assertTrue(tx.timestamp().compareTo(tx2.timestamp()) < 0);
table2.upsert(makeValue(1, 200));
table.get(makeKey(1));
assertThrows(Exception.class, () -> tx2.commit(), "Younger tx must be
aborted");
}
{code}
--
This message was sent by Atlassian Jira
(v8.20.1#820001)
