1. The document describes the process of invalidation checking and metadata updating for a concurrent data structure using delta chains. 2. It involves traversing the delta chain from the initial node to check if the key-value pairs in each delta node are valid compared to the previous node. If invalid, the node's validation bit is set. 3. No matter which order nodes are checked, one node will be found valid while another will be set invalid, since the key-value pairs become out of order during concurrent modifications by multiple threads.

1. PID Ptr
1 TAS
( )
1. metadata update
2. invalidation check
Invalidation Check
next node ~~~ delta chain lookup
insert
1. <key, value> insert node
2. update node <key, value>
delete
1. <key, value> delete node
2. update node <key, value>
update
1. <key, value> delete node
2. <key, value> insert node
3. <key, value> update node
4. <key, value> update node
Implementation

2. PID Ptr
0
1 2
node ( )1 2 node
1 -> 2 TAS
Implementation

3. PID Ptr
0
1 2
node ( )1 2 node
1 -> 2 TAS
1: TAS == . Delta chain lookup
Implementation

4. PID Ptr
0
1
1 2 node
1 -> 2 TAS
1: TAS == . Delta chain lookup
2: TAS 1 . 0
delta chain lookup
2
node ( )
Implementation

5. PID Ptr
0
1 2 3 4 5
Delta Chain Lookup
1: -
2: 1
3: 1~2
4: 1~3
5: 1~4
1~5 delta node
Delta Node Insertion Workflow
Previous:
do {
check abort
create delta node
} while (CAS)
TAS:
check abort
create delta node
TAS
Invalidation check & metadata update
Invalidation check & metadata update: node (
delta node ) .
length < # of threads
Invalidation Check

6. PID Ptr
0
1 2 3 4 5
1~5 delta node
:
1. Invalidation check node ?
valid / invalid
2. Abort delta node handling issue
invalid node ?
1) prev node next pointer next pointer =>
TAS ?
2) node validation bit
Invalidation Check

7. PID Ptr
i <5, 5> i <4, 4> i <3, 3> i <2, 2> i <1, 1>
1: i <6, 6> 2: i <7, 7> 3: i <6, 6> 4: d <5, 5> 5: d <5, 5>
Traverse
1~5 delta node
Invalidation Check not yet finished. (Consider as Valid)
Invalid delta node.
Valid delta node.
Node Traverse(lookup) requested by other thread.
Invalidation Check in progress

8. PID Ptr
i <5, 5> i <4, 4> i <3, 3> i <2, 2> i <1, 1>
1: i <6, 6> 2: i <7, 7> 3: i <6, 6> 4: d <5, 5> 5: d <5, 5>
Traverse
present_set
i <6, 6>
i <7, 7>
i <6, 6>
i <5, 5>
i <4, 4>
i <3, 3>
i <2, 2>
i <1, 1>
deleted_set
d <5, 5>
d <5, 5>
=
<1, 1>
<2, 2>
<3, 3>
<4, 4>
<5, 5>
<6, 6>
<7, 7>

9. PID Ptr
0: i <5, 5> i <4, 4> i <3, 3> i <2, 2> i <1, 1>
1: i <6, 6> 2: i <7, 7> 3: i <6, 6> 4: d <5, 5> 5: d <5, 5>
Traverse
Check delta Node 2 & 1
(since node 0 is initial starting point)
2: i <7, 7> => OK
1: i <6, 6> => invariant doesn't hold.
set invalid bit

10. PID Ptr
0: i <5, 5> i <4, 4> i <3, 3> i <2, 2> i <1, 1>
1: i <6, 6> 2: i <7, 7> 3: i <6, 6> 4: d <5, 5> 5: d <5, 5>
Traverse
present_set
i <6, 6>
i <7, 7>
i <6, 6>
i <5, 5>
i <4, 4>
i <3, 3>
i <2, 2>
i <1, 1>
deleted_set
d <5, 5>
d <5, 5>
=
<1, 1>
<2, 2>
<3, 3>
<4, 4>
<5, 5>
<6, 6>
<7, 7>

11. PID Ptr
0: i <5, 5> i <4, 4> i <3, 3> i <2, 2> i <1, 1>
1: i <6, 6> 2: i <7, 7> 3: i <6, 6> 4: d <5, 5> 5: d <5, 5>
Traverse
Check delta Node until reaching node 0
(since node 0 is initial starting point)
Both delta node is valid.

12. PID Ptr
0: i <5, 5> i <4, 4> i <3, 3> i <2, 2> i <1, 1>
1: i <6, 6> 2: i <7, 7> 3: i <6, 6> 4: d <5, 5> 5: d <5, 5>
Traverse
Check delta Node until reaching node 0
(since node 0 is initial starting point)
No matter which node starts
invalidation check first,
node 4 will be checked as valid
and node 5 will set invalid bit.

13. PID Ptr
0: i <5, 5> i <4, 4> i <3, 3> i <2, 2> i <1, 1>
1: i <6, 6> 2: i <7, 7> 3: i <6, 6> 4: d <5, 5> 5: d <5, 5>
Traverse
present_set
i <6, 6>
i <7, 7>
i <6, 6>
i <5, 5>
i <4, 4>
i <3, 3>
i <2, 2>
i <1, 1>
deleted_set
d <5, 5>
d <5, 5>
=
<1, 1>
<2, 2>
<3, 3>
<4, 4>
<5, 5>
<6, 6>
<7, 7>

14. PID Ptr
0: i <5, 5> i <4, 4> i <3, 3> i <2, 2> i <1, 1>
1: i <6, 6> 2: i <7, 7> 3: i <6, 6> 4: d <5, 5> 5: d <5, 5>
Traverse
<1, 1>
<2, 2>
<3, 3>
<4, 4>
<5, 5>
<6, 6>
<7, 7>
node traverse .
delta node .
e.g.) i <8, 8> & d <8, 8>
<8, 8> : abort i <8, 8>
<8, 8> : abort d <8, 8>