new-txn name=txnSSINormalPushee iso=serializable priority=normal ts=10,1
----

new-txn name=txnSSIHighPushee iso=serializable priority=high ts=10,1
----

new-txn name=txnRCNormalPushee iso=read-committed priority=normal ts=10,1
----

new-txn name=txnRCHighPushee iso=read-committed priority=high ts=10,1
----

new-txn name=txnSSINormalPusher iso=serializable priority=normal ts=10,1
----

new-txn name=txnSSIHighPusher iso=serializable priority=high ts=10,1
----

new-txn name=txnRCNormalPusher iso=read-committed priority=normal ts=10,1
----

new-txn name=txnRCHighPusher iso=read-committed priority=high ts=10,1
----

new-txn name=txnSSINormalDiscoverer iso=serializable priority=normal ts=20,1
----

# -------------------------------------------------------------
# Prep: "Pushee" txns acquire 4 locks each.
# -------------------------------------------------------------

new-request name=req1 txn=txnSSINormalPushee ts=10,1
  put key=kSSINormal1  value=v
  put key=kSSINormal2  value=v
  put key=kSSINormal3  value=v
  put key=kSSINormal4  value=v
----

sequence req=req1
----
[1] sequence req1: sequencing request
[1] sequence req1: acquiring latches
[1] sequence req1: scanning lock table for conflicting locks
[1] sequence req1: sequencing complete, returned guard

on-lock-acquired req=req1 key=kSSINormal1 dur=r
----
[-] acquire lock: txn 00000001 @ ‹kSSINormal1›

on-lock-acquired req=req1 key=kSSINormal2 dur=r
----
[-] acquire lock: txn 00000001 @ ‹kSSINormal2›

on-lock-acquired req=req1 key=kSSINormal3 dur=r
----
[-] acquire lock: txn 00000001 @ ‹kSSINormal3›

on-lock-acquired req=req1 key=kSSINormal4 dur=r
----
[-] acquire lock: txn 00000001 @ ‹kSSINormal4›

finish req=req1
----
[-] finish req1: finishing request

new-request name=req2 txn=txnSSIHighPushee ts=10,1
  put key=kSSIHigh1  value=v
  put key=kSSIHigh2  value=v
  put key=kSSIHigh3  value=v
  put key=kSSIHigh4  value=v
----

sequence req=req2
----
[2] sequence req2: sequencing request
[2] sequence req2: acquiring latches
[2] sequence req2: scanning lock table for conflicting locks
[2] sequence req2: sequencing complete, returned guard

on-lock-acquired req=req2 key=kSSIHigh1 dur=r
----
[-] acquire lock: txn 00000002 @ ‹kSSIHigh1›

on-lock-acquired req=req2 key=kSSIHigh2 dur=r
----
[-] acquire lock: txn 00000002 @ ‹kSSIHigh2›

on-lock-acquired req=req2 key=kSSIHigh3 dur=r
----
[-] acquire lock: txn 00000002 @ ‹kSSIHigh3›

on-lock-acquired req=req2 key=kSSIHigh4 dur=r
----
[-] acquire lock: txn 00000002 @ ‹kSSIHigh4›

finish req=req2
----
[-] finish req2: finishing request

new-request name=req3 txn=txnRCNormalPushee ts=10,1
  put key=kRCNormal1  value=v
  put key=kRCNormal2  value=v
  put key=kRCNormal3  value=v
  put key=kRCNormal4  value=v
----

sequence req=req3
----
[3] sequence req3: sequencing request
[3] sequence req3: acquiring latches
[3] sequence req3: scanning lock table for conflicting locks
[3] sequence req3: sequencing complete, returned guard

on-lock-acquired req=req3 key=kRCNormal1 dur=r
----
[-] acquire lock: txn 00000003 @ ‹kRCNormal1›

on-lock-acquired req=req3 key=kRCNormal2 dur=r
----
[-] acquire lock: txn 00000003 @ ‹kRCNormal2›

on-lock-acquired req=req3 key=kRCNormal3 dur=r
----
[-] acquire lock: txn 00000003 @ ‹kRCNormal3›

on-lock-acquired req=req3 key=kRCNormal4 dur=r
----
[-] acquire lock: txn 00000003 @ ‹kRCNormal4›

finish req=req3
----
[-] finish req3: finishing request

new-request name=req4 txn=txnRCHighPushee ts=10,1
  put key=kRCHigh1  value=v
  put key=kRCHigh2  value=v
  put key=kRCHigh3  value=v
  put key=kRCHigh4  value=v
----

sequence req=req4
----
[4] sequence req4: sequencing request
[4] sequence req4: acquiring latches
[4] sequence req4: scanning lock table for conflicting locks
[4] sequence req4: sequencing complete, returned guard

on-lock-acquired req=req4 key=kRCHigh1 dur=r
----
[-] acquire lock: txn 00000004 @ ‹kRCHigh1›

on-lock-acquired req=req4 key=kRCHigh2 dur=r
----
[-] acquire lock: txn 00000004 @ ‹kRCHigh2›

on-lock-acquired req=req4 key=kRCHigh3 dur=r
----
[-] acquire lock: txn 00000004 @ ‹kRCHigh3›

on-lock-acquired req=req4 key=kRCHigh4 dur=r
----
[-] acquire lock: txn 00000004 @ ‹kRCHigh4›

finish req=req4
----
[-] finish req4: finishing request

new-request name=reqDiscoverInitial txn=txnSSINormalDiscoverer ts=20,1
  get key=kRCHigh1
  get key=kRCHigh2
  get key=kRCHigh3
  get key=kRCHigh4
  get key=kRCNormal1
  get key=kRCNormal2
  get key=kRCNormal3
  get key=kRCNormal4
  get key=kSSIHigh1
  get key=kSSIHigh2
  get key=kSSIHigh3
  get key=kSSIHigh4
  get key=kSSINormal1
  get key=kSSINormal2
  get key=kSSINormal3
  get key=kSSINormal4
----

sequence req=reqDiscoverInitial
----
[5] sequence reqDiscoverInitial: sequencing request
[5] sequence reqDiscoverInitial: acquiring latches
[5] sequence reqDiscoverInitial: scanning lock table for conflicting locks
[5] sequence reqDiscoverInitial: sequencing complete, returned guard

handle-lock-conflict-error req=reqDiscoverInitial lease-seq=1
  lock txn=txnRCHighPushee key=kRCHigh1
  lock txn=txnRCHighPushee key=kRCHigh2
  lock txn=txnRCHighPushee key=kRCHigh3
  lock txn=txnRCHighPushee key=kRCHigh4
  lock txn=txnRCNormalPushee key=kRCNormal1
  lock txn=txnRCNormalPushee key=kRCNormal2
  lock txn=txnRCNormalPushee key=kRCNormal3
  lock txn=txnRCNormalPushee key=kRCNormal4
  lock txn=txnSSIHighPushee key=kSSIHigh1
  lock txn=txnSSIHighPushee key=kSSIHigh2
  lock txn=txnSSIHighPushee key=kSSIHigh3
  lock txn=txnSSIHighPushee key=kSSIHigh4
  lock txn=txnSSINormalPushee  key=kSSINormal1
  lock txn=txnSSINormalPushee  key=kSSINormal2
  lock txn=txnSSINormalPushee  key=kSSINormal3
  lock txn=txnSSINormalPushee  key=kSSINormal4
----
[6] handle lock conflict error reqDiscoverInitial: handled conflicting locks on ‹"kRCHigh1"›, ‹"kRCHigh2"›, ‹"kRCHigh3"›, ‹"kRCHigh4"›, ‹"kRCNormal1"› ... ‹"kSSIHigh4"›, ‹"kSSINormal1"›, ‹"kSSINormal2"›, ‹"kSSINormal3"›, ‹"kSSINormal4"›, released latches

finish req=reqDiscoverInitial
----
[-] finish reqDiscoverInitial: finishing request

debug-lock-table
----
num=16
 lock: "kRCHigh1"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh2"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh3"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh4"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal1"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal2"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal3"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal4"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSIHigh1"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSIHigh2"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSIHigh3"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSIHigh4"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSINormal1"
  holder: txn: 00000001-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSINormal2"
  holder: txn: 00000001-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSINormal3"
  holder: txn: 00000001-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSINormal4"
  holder: txn: 00000001-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]

# -------------------------------------------------------------
# Pushee: isolation=serializable, priority=normal
# Pusher: isolation=serializable, priority=normal
#
# Explanation: SSI transactions with the same priority can not
# push each other.
# -------------------------------------------------------------

new-request name=req5 txn=txnSSINormalPusher ts=10,1
  get key=kSSINormal1
----

sequence req=req5
----
[7] sequence req5: sequencing request
[7] sequence req5: acquiring latches
[7] sequence req5: scanning lock table for conflicting locks
[7] sequence req5: waiting in lock wait-queues
[7] sequence req5: lock wait-queue event: wait for txn 00000001 holding lock @ key ‹"kSSINormal1"› (queuedLockingRequests: 0, queuedReaders: 1)
[7] sequence req5: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = false, wait policy error = false
[7] sequence req5: pushing timestamp of txn 00000001 above 10.000000000,1
[7] sequence req5: blocked on select in concurrency_test.(*cluster).PushTransaction

# -------------------------------------------------------------
# Pushee: isolation=serializable, priority=normal
# Pusher: isolation=serializable, priority=high
#
# Explanation: SSI transactions with a high priority can push
# SSI transactions with a normal priority. This also unblocks
# the previous case.
# -------------------------------------------------------------

new-request name=req6 txn=txnSSIHighPusher ts=11,1
  get key=kSSINormal2
----

sequence req=req6
----
[7] sequence req5: resolving intent ‹"kSSINormal1"› for txn 00000001 with PENDING status and clock observation {1 123.000000000,1}
[7] sequence req5: lock wait-queue event: done waiting
[7] sequence req5: conflicted with ‹00000001-0000-0000-0000-000000000000› on ‹"kSSINormal1"› for 0.000s
[7] sequence req5: acquiring latches
[7] sequence req5: scanning lock table for conflicting locks
[7] sequence req5: sequencing complete, returned guard
[8] sequence req6: sequencing request
[8] sequence req6: acquiring latches
[8] sequence req6: scanning lock table for conflicting locks
[8] sequence req6: waiting in lock wait-queues
[8] sequence req6: lock wait-queue event: wait for txn 00000001 holding lock @ key ‹"kSSINormal2"› (queuedLockingRequests: 0, queuedReaders: 1)
[8] sequence req6: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[8] sequence req6: pushing timestamp of txn 00000001 above 11.000000000,1
[8] sequence req6: pusher pushed pushee to 11.000000000,2
[8] sequence req6: resolving intent ‹"kSSINormal2"› for txn 00000001 with PENDING status and clock observation {1 123.000000000,3}
[8] sequence req6: lock wait-queue event: done waiting
[8] sequence req6: conflicted with ‹00000001-0000-0000-0000-000000000000› on ‹"kSSINormal2"› for 0.000s
[8] sequence req6: acquiring latches
[8] sequence req6: scanning lock table for conflicting locks
[8] sequence req6: sequencing complete, returned guard

finish req=req5
----
[-] finish req5: finishing request

finish req=req6
----
[-] finish req6: finishing request

# -------------------------------------------------------------
# Pushee: isolation=serializable,   priority=normal
# Pusher: isolation=read-committed, priority=normal
#
# Explanation: RC transactions with a normal priority can push
# SSI transactions with a normal priority.
# -------------------------------------------------------------

new-request name=req7 txn=txnRCNormalPusher ts=12,1
  get key=kSSINormal3
----

sequence req=req7
----
[9] sequence req7: sequencing request
[9] sequence req7: acquiring latches
[9] sequence req7: scanning lock table for conflicting locks
[9] sequence req7: waiting in lock wait-queues
[9] sequence req7: lock wait-queue event: wait for txn 00000001 holding lock @ key ‹"kSSINormal3"› (queuedLockingRequests: 0, queuedReaders: 1)
[9] sequence req7: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[9] sequence req7: pushing timestamp of txn 00000001 above 12.000000000,1
[9] sequence req7: pusher pushed pushee to 12.000000000,2
[9] sequence req7: resolving intent ‹"kSSINormal3"› for txn 00000001 with PENDING status and clock observation {1 123.000000000,5}
[9] sequence req7: lock wait-queue event: done waiting
[9] sequence req7: conflicted with ‹00000001-0000-0000-0000-000000000000› on ‹"kSSINormal3"› for 0.000s
[9] sequence req7: acquiring latches
[9] sequence req7: scanning lock table for conflicting locks
[9] sequence req7: sequencing complete, returned guard

finish req=req7
----
[-] finish req7: finishing request

# -------------------------------------------------------------
# Pushee: isolation=serializable,   priority=normal
# Pusher: isolation=read-committed, priority=high
#
# Explanation: RC transactions with a high priority can push
# SSI transactions with a normal priority.
# -------------------------------------------------------------

new-request name=req8 txn=txnRCHighPusher ts=13,1
  get key=kSSINormal4
----

sequence req=req8
----
[10] sequence req8: sequencing request
[10] sequence req8: acquiring latches
[10] sequence req8: scanning lock table for conflicting locks
[10] sequence req8: waiting in lock wait-queues
[10] sequence req8: lock wait-queue event: wait for txn 00000001 holding lock @ key ‹"kSSINormal4"› (queuedLockingRequests: 0, queuedReaders: 1)
[10] sequence req8: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[10] sequence req8: pushing timestamp of txn 00000001 above 13.000000000,1
[10] sequence req8: pusher pushed pushee to 13.000000000,2
[10] sequence req8: resolving intent ‹"kSSINormal4"› for txn 00000001 with PENDING status and clock observation {1 123.000000000,7}
[10] sequence req8: lock wait-queue event: done waiting
[10] sequence req8: conflicted with ‹00000001-0000-0000-0000-000000000000› on ‹"kSSINormal4"› for 0.000s
[10] sequence req8: acquiring latches
[10] sequence req8: scanning lock table for conflicting locks
[10] sequence req8: sequencing complete, returned guard

finish req=req8
----
[-] finish req8: finishing request

# Replicated locks are removed from the lock table when their timestamp has been
# successfully moved forward because of a transaction push.
debug-lock-table
----
num=12
 lock: "kRCHigh1"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh2"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh3"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh4"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal1"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal2"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal3"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal4"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSIHigh1"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSIHigh2"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSIHigh3"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]
 lock: "kSSIHigh4"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 10.000000000,1, info: repl [Intent]

# -------------------------------------------------------------
# Pushee: isolation=serializable, priority=high
# Pusher: isolation=serializable, priority=normal
#
# Explanation: SSI transactions with a normal priority can not
# push SSI transactions with a high priority.
# -------------------------------------------------------------

new-request name=req9 txn=txnSSINormalPusher ts=10,1
  get key=kSSIHigh1
----

sequence req=req9
----
[11] sequence req9: sequencing request
[11] sequence req9: acquiring latches
[11] sequence req9: scanning lock table for conflicting locks
[11] sequence req9: waiting in lock wait-queues
[11] sequence req9: lock wait-queue event: wait for txn 00000002 holding lock @ key ‹"kSSIHigh1"› (queuedLockingRequests: 0, queuedReaders: 1)
[11] sequence req9: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = false, wait policy error = false
[11] sequence req9: pushing timestamp of txn 00000002 above 10.000000000,1
[11] sequence req9: blocked on select in concurrency_test.(*cluster).PushTransaction

# -------------------------------------------------------------
# Pushee: isolation=serializable, priority=high
# Pusher: isolation=serializable, priority=high
#
# Explanation: SSI transactions with the same priority can not
# push each other.
# -------------------------------------------------------------

new-request name=req10 txn=txnSSIHighPusher ts=11,1
  get key=kSSIHigh2
----

sequence req=req10
----
[12] sequence req10: sequencing request
[12] sequence req10: acquiring latches
[12] sequence req10: scanning lock table for conflicting locks
[12] sequence req10: waiting in lock wait-queues
[12] sequence req10: lock wait-queue event: wait for txn 00000002 holding lock @ key ‹"kSSIHigh2"› (queuedLockingRequests: 0, queuedReaders: 1)
[12] sequence req10: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = false, wait policy error = false
[12] sequence req10: pushing timestamp of txn 00000002 above 11.000000000,1
[12] sequence req10: blocked on select in concurrency_test.(*cluster).PushTransaction

# -------------------------------------------------------------
# Pushee: isolation=serializable,   priority=high
# Pusher: isolation=read-committed, priority=normal
#
# Explanation: RC transactions with a normal priority can not
# push SSI transactions with a high priority.
# -------------------------------------------------------------

new-request name=req11 txn=txnRCNormalPusher ts=12,1
  get key=kSSIHigh3
----

sequence req=req11
----
[13] sequence req11: sequencing request
[13] sequence req11: acquiring latches
[13] sequence req11: scanning lock table for conflicting locks
[13] sequence req11: waiting in lock wait-queues
[13] sequence req11: lock wait-queue event: wait for txn 00000002 holding lock @ key ‹"kSSIHigh3"› (queuedLockingRequests: 0, queuedReaders: 1)
[13] sequence req11: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = false, wait policy error = false
[13] sequence req11: pushing timestamp of txn 00000002 above 12.000000000,1
[13] sequence req11: blocked on select in concurrency_test.(*cluster).PushTransaction

# -------------------------------------------------------------
# Pushee: isolation=serializable,   priority=high
# Pusher: isolation=read-committed, priority=high
#
# Explanation: RC transactions with a high priority can push
# SSI transactions with a high priority. This also unblocks
# the previous cases.
# -------------------------------------------------------------

new-request name=req12 txn=txnRCHighPusher ts=13,1
  get key=kSSIHigh4
----

sequence req=req12
----
[11] sequence req9: resolving intent ‹"kSSIHigh1"› for txn 00000002 with PENDING status and clock observation {1 123.000000000,9}
[11] sequence req9: lock wait-queue event: done waiting
[11] sequence req9: conflicted with ‹00000002-0000-0000-0000-000000000000› on ‹"kSSIHigh1"› for 0.000s
[11] sequence req9: acquiring latches
[11] sequence req9: scanning lock table for conflicting locks
[11] sequence req9: sequencing complete, returned guard
[12] sequence req10: resolving intent ‹"kSSIHigh2"› for txn 00000002 with PENDING status and clock observation {1 123.000000000,11}
[12] sequence req10: lock wait-queue event: done waiting
[12] sequence req10: conflicted with ‹00000002-0000-0000-0000-000000000000› on ‹"kSSIHigh2"› for 0.000s
[12] sequence req10: acquiring latches
[12] sequence req10: scanning lock table for conflicting locks
[12] sequence req10: sequencing complete, returned guard
[13] sequence req11: resolving intent ‹"kSSIHigh3"› for txn 00000002 with PENDING status and clock observation {1 123.000000000,13}
[13] sequence req11: lock wait-queue event: done waiting
[13] sequence req11: conflicted with ‹00000002-0000-0000-0000-000000000000› on ‹"kSSIHigh3"› for 0.000s
[13] sequence req11: acquiring latches
[13] sequence req11: scanning lock table for conflicting locks
[13] sequence req11: sequencing complete, returned guard
[14] sequence req12: sequencing request
[14] sequence req12: acquiring latches
[14] sequence req12: scanning lock table for conflicting locks
[14] sequence req12: waiting in lock wait-queues
[14] sequence req12: lock wait-queue event: wait for txn 00000002 holding lock @ key ‹"kSSIHigh4"› (queuedLockingRequests: 0, queuedReaders: 1)
[14] sequence req12: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[14] sequence req12: pushing timestamp of txn 00000002 above 13.000000000,1
[14] sequence req12: pusher pushed pushee to 13.000000000,2
[14] sequence req12: resolving intent ‹"kSSIHigh4"› for txn 00000002 with PENDING status and clock observation {1 123.000000000,15}
[14] sequence req12: lock wait-queue event: done waiting
[14] sequence req12: conflicted with ‹00000002-0000-0000-0000-000000000000› on ‹"kSSIHigh4"› for 0.000s
[14] sequence req12: acquiring latches
[14] sequence req12: scanning lock table for conflicting locks
[14] sequence req12: sequencing complete, returned guard

finish req=req9
----
[-] finish req9: finishing request

finish req=req10
----
[-] finish req10: finishing request

finish req=req11
----
[-] finish req11: finishing request

finish req=req12
----
[-] finish req12: finishing request

debug-lock-table
----
num=8
 lock: "kRCHigh1"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh2"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh3"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh4"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal1"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal2"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal3"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCNormal4"
  holder: txn: 00000003-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]

# -------------------------------------------------------------
# Pushee: isolation=read-committed, priority=normal
# Pusher: isolation=serializable,   priority=normal
#
# Explanation: RC transactions can always be pushed.
# -------------------------------------------------------------

new-request name=req13 txn=txnSSINormalPusher ts=10,1
  get key=kRCNormal1
----

sequence req=req13
----
[15] sequence req13: sequencing request
[15] sequence req13: acquiring latches
[15] sequence req13: scanning lock table for conflicting locks
[15] sequence req13: waiting in lock wait-queues
[15] sequence req13: lock wait-queue event: wait for txn 00000003 holding lock @ key ‹"kRCNormal1"› (queuedLockingRequests: 0, queuedReaders: 1)
[15] sequence req13: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[15] sequence req13: pushing timestamp of txn 00000003 above 10.000000000,1
[15] sequence req13: pusher pushed pushee to 10.000000000,2
[15] sequence req13: resolving intent ‹"kRCNormal1"› for txn 00000003 with PENDING status and clock observation {1 123.000000000,17}
[15] sequence req13: lock wait-queue event: done waiting
[15] sequence req13: conflicted with ‹00000003-0000-0000-0000-000000000000› on ‹"kRCNormal1"› for 0.000s
[15] sequence req13: acquiring latches
[15] sequence req13: scanning lock table for conflicting locks
[15] sequence req13: sequencing complete, returned guard

finish req=req13
----
[-] finish req13: finishing request

# -------------------------------------------------------------
# Pushee: isolation=read-committed, priority=normal
# Pusher: isolation=serializable,   priority=high
#
# Explanation: RC transactions can always be pushed.
# -------------------------------------------------------------

new-request name=req14 txn=txnSSIHighPusher ts=11,1
  get key=kRCNormal2
----

sequence req=req14
----
[16] sequence req14: sequencing request
[16] sequence req14: acquiring latches
[16] sequence req14: scanning lock table for conflicting locks
[16] sequence req14: waiting in lock wait-queues
[16] sequence req14: lock wait-queue event: wait for txn 00000003 holding lock @ key ‹"kRCNormal2"› (queuedLockingRequests: 0, queuedReaders: 1)
[16] sequence req14: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[16] sequence req14: pushing timestamp of txn 00000003 above 11.000000000,1
[16] sequence req14: pusher pushed pushee to 11.000000000,2
[16] sequence req14: resolving intent ‹"kRCNormal2"› for txn 00000003 with PENDING status and clock observation {1 123.000000000,19}
[16] sequence req14: lock wait-queue event: done waiting
[16] sequence req14: conflicted with ‹00000003-0000-0000-0000-000000000000› on ‹"kRCNormal2"› for 0.000s
[16] sequence req14: acquiring latches
[16] sequence req14: scanning lock table for conflicting locks
[16] sequence req14: sequencing complete, returned guard

finish req=req14
----
[-] finish req14: finishing request

# -------------------------------------------------------------
# Pushee: isolation=read-committed, priority=normal
# Pusher: isolation=read-committed, priority=normal
#
# Explanation: RC transactions can always be pushed.
# -------------------------------------------------------------

new-request name=req15 txn=txnRCNormalPusher ts=12,1
  get key=kRCNormal3
----

sequence req=req15
----
[17] sequence req15: sequencing request
[17] sequence req15: acquiring latches
[17] sequence req15: scanning lock table for conflicting locks
[17] sequence req15: waiting in lock wait-queues
[17] sequence req15: lock wait-queue event: wait for txn 00000003 holding lock @ key ‹"kRCNormal3"› (queuedLockingRequests: 0, queuedReaders: 1)
[17] sequence req15: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[17] sequence req15: pushing timestamp of txn 00000003 above 12.000000000,1
[17] sequence req15: pusher pushed pushee to 12.000000000,2
[17] sequence req15: resolving intent ‹"kRCNormal3"› for txn 00000003 with PENDING status and clock observation {1 123.000000000,21}
[17] sequence req15: lock wait-queue event: done waiting
[17] sequence req15: conflicted with ‹00000003-0000-0000-0000-000000000000› on ‹"kRCNormal3"› for 0.000s
[17] sequence req15: acquiring latches
[17] sequence req15: scanning lock table for conflicting locks
[17] sequence req15: sequencing complete, returned guard

finish req=req15
----
[-] finish req15: finishing request

# -------------------------------------------------------------
# Pushee: isolation=read-committed, priority=normal
# Pusher: isolation=read-committed, priority=high
#
# Explanation: RC transactions can always be pushed.
# -------------------------------------------------------------

new-request name=req16 txn=txnRCHighPusher ts=13,1
  get key=kRCNormal4
----

sequence req=req16
----
[18] sequence req16: sequencing request
[18] sequence req16: acquiring latches
[18] sequence req16: scanning lock table for conflicting locks
[18] sequence req16: waiting in lock wait-queues
[18] sequence req16: lock wait-queue event: wait for txn 00000003 holding lock @ key ‹"kRCNormal4"› (queuedLockingRequests: 0, queuedReaders: 1)
[18] sequence req16: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[18] sequence req16: pushing timestamp of txn 00000003 above 13.000000000,1
[18] sequence req16: pusher pushed pushee to 13.000000000,2
[18] sequence req16: resolving intent ‹"kRCNormal4"› for txn 00000003 with PENDING status and clock observation {1 123.000000000,23}
[18] sequence req16: lock wait-queue event: done waiting
[18] sequence req16: conflicted with ‹00000003-0000-0000-0000-000000000000› on ‹"kRCNormal4"› for 0.000s
[18] sequence req16: acquiring latches
[18] sequence req16: scanning lock table for conflicting locks
[18] sequence req16: sequencing complete, returned guard

finish req=req16
----
[-] finish req16: finishing request

debug-lock-table
----
num=4
 lock: "kRCHigh1"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh2"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh3"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]
 lock: "kRCHigh4"
  holder: txn: 00000004-0000-0000-0000-000000000000 epoch: 0, iso: ReadCommitted, ts: 10.000000000,1, info: repl [Intent]

# -------------------------------------------------------------
# Pushee: isolation=read-committed, priority=high
# Pusher: isolation=serializable,   priority=normal
#
# Explanation: RC transactions can always be pushed.
# -------------------------------------------------------------

new-request name=req17 txn=txnSSINormalPusher ts=10,1
  get key=kRCHigh1
----

sequence req=req17
----
[19] sequence req17: sequencing request
[19] sequence req17: acquiring latches
[19] sequence req17: scanning lock table for conflicting locks
[19] sequence req17: waiting in lock wait-queues
[19] sequence req17: lock wait-queue event: wait for txn 00000004 holding lock @ key ‹"kRCHigh1"› (queuedLockingRequests: 0, queuedReaders: 1)
[19] sequence req17: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[19] sequence req17: pushing timestamp of txn 00000004 above 10.000000000,1
[19] sequence req17: pusher pushed pushee to 10.000000000,2
[19] sequence req17: resolving intent ‹"kRCHigh1"› for txn 00000004 with PENDING status and clock observation {1 123.000000000,25}
[19] sequence req17: lock wait-queue event: done waiting
[19] sequence req17: conflicted with ‹00000004-0000-0000-0000-000000000000› on ‹"kRCHigh1"› for 0.000s
[19] sequence req17: acquiring latches
[19] sequence req17: scanning lock table for conflicting locks
[19] sequence req17: sequencing complete, returned guard

finish req=req17
----
[-] finish req17: finishing request

# -------------------------------------------------------------
# Pushee: isolation=read-committed, priority=high
# Pusher: isolation=serializable,   priority=high
#
# Explanation: RC transactions can always be pushed.
# -------------------------------------------------------------

new-request name=req18 txn=txnSSIHighPusher ts=11,1
  get key=kRCHigh2
----

sequence req=req18
----
[20] sequence req18: sequencing request
[20] sequence req18: acquiring latches
[20] sequence req18: scanning lock table for conflicting locks
[20] sequence req18: waiting in lock wait-queues
[20] sequence req18: lock wait-queue event: wait for txn 00000004 holding lock @ key ‹"kRCHigh2"› (queuedLockingRequests: 0, queuedReaders: 1)
[20] sequence req18: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[20] sequence req18: pushing timestamp of txn 00000004 above 11.000000000,1
[20] sequence req18: pusher pushed pushee to 11.000000000,2
[20] sequence req18: resolving intent ‹"kRCHigh2"› for txn 00000004 with PENDING status and clock observation {1 123.000000000,27}
[20] sequence req18: lock wait-queue event: done waiting
[20] sequence req18: conflicted with ‹00000004-0000-0000-0000-000000000000› on ‹"kRCHigh2"› for 0.000s
[20] sequence req18: acquiring latches
[20] sequence req18: scanning lock table for conflicting locks
[20] sequence req18: sequencing complete, returned guard

finish req=req18
----
[-] finish req18: finishing request

# -------------------------------------------------------------
# Pushee: isolation=read-committed, priority=high
# Pusher: isolation=read-committed, priority=normal
#
# Explanation: RC transactions can always be pushed.
# -------------------------------------------------------------

new-request name=req19 txn=txnRCNormalPusher ts=12,1
  get key=kRCHigh3
----

sequence req=req19
----
[21] sequence req19: sequencing request
[21] sequence req19: acquiring latches
[21] sequence req19: scanning lock table for conflicting locks
[21] sequence req19: waiting in lock wait-queues
[21] sequence req19: lock wait-queue event: wait for txn 00000004 holding lock @ key ‹"kRCHigh3"› (queuedLockingRequests: 0, queuedReaders: 1)
[21] sequence req19: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[21] sequence req19: pushing timestamp of txn 00000004 above 12.000000000,1
[21] sequence req19: pusher pushed pushee to 12.000000000,2
[21] sequence req19: resolving intent ‹"kRCHigh3"› for txn 00000004 with PENDING status and clock observation {1 123.000000000,29}
[21] sequence req19: lock wait-queue event: done waiting
[21] sequence req19: conflicted with ‹00000004-0000-0000-0000-000000000000› on ‹"kRCHigh3"› for 0.000s
[21] sequence req19: acquiring latches
[21] sequence req19: scanning lock table for conflicting locks
[21] sequence req19: sequencing complete, returned guard

finish req=req19
----
[-] finish req19: finishing request

# -------------------------------------------------------------
# Pushee: isolation=read-committed, priority=high
# Pusher: isolation=read-committed, priority=high
#
# Explanation: RC transactions can always be pushed.
# -------------------------------------------------------------

new-request name=req20 txn=txnRCHighPusher ts=13,1
  get key=kRCHigh4
----

sequence req=req20
----
[22] sequence req20: sequencing request
[22] sequence req20: acquiring latches
[22] sequence req20: scanning lock table for conflicting locks
[22] sequence req20: waiting in lock wait-queues
[22] sequence req20: lock wait-queue event: wait for txn 00000004 holding lock @ key ‹"kRCHigh4"› (queuedLockingRequests: 0, queuedReaders: 1)
[22] sequence req20: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = true, wait policy error = false
[22] sequence req20: pushing timestamp of txn 00000004 above 13.000000000,1
[22] sequence req20: pusher pushed pushee to 13.000000000,2
[22] sequence req20: resolving intent ‹"kRCHigh4"› for txn 00000004 with PENDING status and clock observation {1 123.000000000,31}
[22] sequence req20: lock wait-queue event: done waiting
[22] sequence req20: conflicted with ‹00000004-0000-0000-0000-000000000000› on ‹"kRCHigh4"› for 0.000s
[22] sequence req20: acquiring latches
[22] sequence req20: scanning lock table for conflicting locks
[22] sequence req20: sequencing complete, returned guard

finish req=req20
----
[-] finish req20: finishing request

debug-lock-table
----
num=0

reset
----
