Simpler and faster lock-free linked list #1565
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
|
|
|
elizarov
force-pushed
the
faster-list
branch
3 times, most recently
from
d381216 to
5f6d127
Compare
|
Not ready for review yet. There is a potential problem with broken lists structure that should be investigate (still |
elizarov
force-pushed
the
faster-list
branch
2 times, most recently
from
5a6a7d9 to
94b644f
Compare
elizarov
changed the title
elizarov
force-pushed
the
faster-list
branch
from
94b644f to
03b6d1d
Compare
elizarov
changed the title
|
It is ready for review now. Due to the previously merged improvements to |
Lock-free list implementation is considerably simplified, taking into account a limited number of operations that it needs to support. * prev pointers in the list are not marked for removal, since we don't need to support linearizable backwards iteration. * helpDelete method is completely removed. All "delete-helping" is performed only by correctPrev method. * correctPrev method bails out when the node it works on is removed to reduce contention during concurrent removals. * Special open methods "isRemoved" and "nextIfRemoved" are introduced and are overridden in list head class (which is never removed). This ensures that on long list "removeFist" operation (touching head) does not interfere with "addLast" (touch tail). There is still sharing of cache-lines in this case, but no helping between them. All in all, this improvement reduces the size of implementation code and makes it considerably faster. Operations on LinkedListChannel are now much faster (see timings of ChannelSendReceiveStressTest).
elizarov
force-pushed
the
faster-list
branch
from
03b6d1d to
0d59d15
Compare
qwwdfsad
approved these changes
Mar 4, 2020
elizarov
added a commit
that referenced
this pull request
Mar 5, 2020
* The problem was introduced by #1565. When doing concurrent add+removeFirst the following can happen: - "add" completes, but has not correct prev pointer in next node yet - "removeFirst" removes freshly added element - "add" performs "finishAdd" that adjust prev pointer of the next node and thus removed element is pointed from the list again * A separate LockFreeLinkedListAddRemoveStressTest is added that reproduces this problem. * The old LockFreeLinkedListAtomicLFStressTest is refactored a bit.
qwwdfsad
pushed a commit
that referenced
this pull request
Mar 6, 2020
…st (#1845) * The problem was introduced by #1565. When doing concurrent add+removeFirst the following can happen: - "add" completes, but has not correct prev pointer in next node yet - "removeFirst" removes freshly added element - "add" performs "finishAdd" that adjust prev pointer of the next node and thus removed element is pointed from the list again * A separate LockFreeLinkedListAddRemoveStressTest is added that reproduces this problem. * The old LockFreeLinkedListAtomicLFStressTest is refactored a bit.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Lock-free list implementation is considerably simplified, taking into
account a limited number of operations that it needs to support.
don't need to support linearizable backwards iteration.
performed only by correctPrev method.
reduce contention during concurrent removals.
and are overriden in list head class (which is never removed).
This ensures that on long list "removeFist" operation (touching head)
does not interfere with "addLast" (touch tail). There is still
sharing of cache-lines in this case, but no helping between them.
All in all, this improvement reduces the size of implementation code
and makes it considerably faster. Operations on LinkedListChannel are
now much faster (see timings of ChannelSendReceiveStressTest).