I now have two replacement implementations. After implementing an
Iterable version based on an explicit linked list, I realized that my
solutions to ensuring termination and handling non-Iterator removal
could also be applied to an implementation based on
java.util.ConcurrentLinkedList. In some performance tests, the
ConcurrentLinkedList version appears to be more scalable as I increase
the number of threads.
I can't compare them to the original on the most demanding test, because
the rate and combination of operations that probe the performance of the
new implementations make the original lose nodes or crash. On a
simplified test, all three appear to have similar performance.
Based on these results, and a general expectation that CLQ should have
good scaling, I plan to go with the CLQ-based implementation.
The remaining work is:
Do another round of review and write up my correctness reasoning.
Document and edit to River standards.
Plug it into Outrigger. Modify FastList users to use the Iterable
interface instead of head and next.
Add a unit test.
Create a performance area and add my benchmark and results to it.
Check in the changes to the failing QA test to make it harder.
There will be a two week gap, during which I'll have limited Internet
access and no access to my development system. I'll pick this up and
finish it in late January. (This e-mail is partly intended to remind me
of the steps I need to take to finish this.)
Patricia
