Can you further explain your "check" and "set" storage example? I feel like you might be begging the question. "check" and "set" seem like they describe another lock. How does that lock time out?
You want to modify locked resource X. You set X.currlock = token. Then you read, do whatever you want, and when you write, you "write-if-currlock == token". If another client did X.currlock = somethingelse, the transaction fails.
Edit: note that I noticed some confusion about this. Any other client is free to replace X.currlock even if set to a past value.
try
token=lock.aquire
val=raw(shared, key, token)
do_things
awar(shared, key, val, token)
except fail("Can't do!")
finally lock.release
Where a shared object has:
1) a key to store a value being changed in the critical section; 2) a currlock to store a random fence token associated with a lock.
The raw reads the shared key's value after the currlock was written to the shared object.
The awar does an atomic write of the value to the key, only if the currlock has an expected token (i.e. is unchanged).When things go wrong, the do_things may be executed more than once, in parallel, but the key is safe and guaranteed to have no lost updates to its value.
Doesn't it mean that this can happen?
A: X.currlock = Token_ID_A
A: resource read
A: is X.currlock still Token_ID_A? yes
B: X.currlock = Token_ID_B
B: resource read
B: is X.currlock still Token_ID_B? yes
B: resource write
A: resource write
Is there anything that makes the "write-if-currlock == token" operation atomic? https://en.wikipedia.org/wiki/Test-and-set
Or the more efficient test and test and set? https://en.wikipedia.org/wiki/Test_and_test-and-set