new-txn name=txn1 ts=10,1 epoch=0
----

new-txn name=txn2 ts=12,1 epoch=0
----

new-txn name=txn3 ts=14,1 epoch=0
----

# -------------------------------------------------------------
# Simple read-only request
# -------------------------------------------------------------

new-request name=req1 txn=txn1 ts=10,1
  get  key=k
  scan key=k endkey=k2
----

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

debug-latch-manager
----
write count: 0
 read count: 1

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

reset
----

# -------------------------------------------------------------
# Simple read-write request that acquires a lock
# -------------------------------------------------------------

new-request name=req2 txn=txn2 ts=12,1
  put key=k value=v
----

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

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

debug-lock-table
----
num=1
 lock: "k"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 12.000000000,1, info: unrepl [(str: Exclusive seq: 0)]

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

debug-lock-table
----
num=1
 lock: "k"
  holder: txn: 00000002-0000-0000-0000-000000000000 epoch: 0, iso: Serializable, ts: 12.000000000,1, info: unrepl [(str: Exclusive seq: 0)]

reset
----

# Demonstrate that 'reset' clears the lock table.
debug-lock-table
----
num=0

# -------------------------------------------------------------
# 1. Acquire a lock
# 2. Read-only requests blocks on lock
# 3. Lock is released
# 4. Read-only request proceeds
# 5. Read-write request blocks on latches
# 6. Requests proceed in order
# -------------------------------------------------------------

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

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

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

new-request name=req3 txn=txn3 ts=14,1
  get  key=k
  scan key=k endkey=k2
----

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

debug-advance-clock ts=123
----

on-txn-updated txn=txn2 status=committed
----
[-] update txn: committing txn2
[2] sequence req3: resolving intent ‹"k"› for txn 00000002 with COMMITTED status
[2] sequence req3: lock wait-queue event: done waiting
[2] sequence req3: conflicted with ‹00000002-0000-0000-0000-000000000000› on ‹"k"› for 123.000s
[2] sequence req3: acquiring latches
[2] sequence req3: scanning lock table for conflicting locks
[2] sequence req3: sequencing complete, returned guard

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

new-request name=req4 txn=txn1 ts=10,1
  put key=k value=v
----

sequence req=req4
----
[3] sequence req4: sequencing request
[3] sequence req4: acquiring latches
[3] sequence req4: waiting to acquire write latch ‹k›@10.000000000,1 for request Put [‹"k"›], [txn: 00000001], held by read latch ‹k{-2}›@14.000000000,1 for request Get [‹"k"›], Scan [‹"k"›,‹"k2"›), [txn: 00000003]
[3] sequence req4: blocked on select in spanlatch.(*Manager).waitForSignal

debug-latch-manager
----
write count: 1
 read count: 1

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

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

reset
----

# -------------------------------------------------------------
# 1. Acquire a lock
# 2. Two read-only requests block on lock, one pushes
# 3. Txn is updated to a timestamp above the read's
# 4. Read-only request proceeds
# 5. Read-write request blocks on lock
# 6. Lock is released
# 7. Read-write request blocks on latches
# 8. Requests proceed in order
# -------------------------------------------------------------

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

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

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

new-request name=req5 txn=none ts=14,1
  scan key=a endkey=m
----

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

new-request name=req6 txn=none ts=16,1
  scan key=c endkey=z
----

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

debug-advance-clock ts=123
----

on-txn-updated txn=txn2 status=pending ts=18,1
----
[-] update txn: increasing timestamp of txn2
[2] sequence req5: resolving intent ‹"k"› for txn 00000002 with PENDING status and clock observation {1 246.000000000,0}
[2] sequence req5: lock wait-queue event: done waiting
[2] sequence req5: conflicted with ‹00000002-0000-0000-0000-000000000000› on ‹"k"› for 123.000s
[2] sequence req5: acquiring latches
[2] sequence req5: scanning lock table for conflicting locks
[2] sequence req5: sequencing complete, returned guard
[3] sequence req6: resolving intent ‹"k"› for txn 00000002 with PENDING status and clock observation {1 246.000000000,1}
[3] sequence req6: lock wait-queue event: done waiting
[3] sequence req6: conflicted with ‹00000002-0000-0000-0000-000000000000› on ‹"k"› for 123.000s
[3] sequence req6: acquiring latches
[3] sequence req6: scanning lock table for conflicting locks
[3] sequence req6: sequencing complete, returned guard

new-request name=req7 txn=none ts=12,1
  put key=k value=v
----

sequence req=req7
----
[4] sequence req7: sequencing request
[4] sequence req7: acquiring latches
[4] sequence req7: waiting to acquire write latch ‹k›@12.000000000,1 for request Put [‹"k"›], held by read latch ‹{a-m}›@14.000000000,1 for request Scan [‹"a"›,‹"m"›)
[4] sequence req7: blocked on select in spanlatch.(*Manager).waitForSignal

finish req=req5
----
[-] finish req5: finishing request
[4] sequence req7: waiting to acquire write latch ‹k›@12.000000000,1 for request Put [‹"k"›], held by read latch ‹{c-z}›@16.000000000,1 for request Scan [‹"c"›,‹"z"›)
[4] sequence req7: blocked on select in spanlatch.(*Manager).waitForSignal

finish req=req6
----
[-] finish req6: finishing request
[4] sequence req7: scanning lock table for conflicting locks
[4] sequence req7: waiting in lock wait-queues
[4] sequence req7: lock wait-queue event: wait for txn 00000002 holding lock @ key ‹"k"› (queuedLockingRequests: 1, queuedReaders: 0)
[4] sequence req7: pushing after 0s for: deadlock/liveness detection = true, timeout enforcement = false, priority enforcement = false, wait policy error = false
[4] sequence req7: pushing txn 00000002 to abort
[4] sequence req7: blocked on select in concurrency_test.(*cluster).PushTransaction

debug-advance-clock ts=123
----

on-txn-updated txn=txn2 status=committed
----
[-] update txn: committing txn2
[4] sequence req7: resolving intent ‹"k"› for txn 00000002 with COMMITTED status
[4] sequence req7: lock wait-queue event: done waiting
[4] sequence req7: conflicted with ‹00000002-0000-0000-0000-000000000000› on ‹"k"› for 123.000s
[4] sequence req7: acquiring latches
[4] sequence req7: scanning lock table for conflicting locks
[4] sequence req7: sequencing complete, returned guard

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

reset
----
