updated readme

Author: wolfram77

EliminationBackoffStack.java

@@ -4,7 +4,12 @@
 
 // Elimination-backoff stack is an unbounded lock-free LIFO
 // linked list, that eliminates concurrent pairs of pushes
-// and pops with exchanges.
+// and pops with exchanges.  It uses compare-and-set (CAS)
+// atomic operation to provide concurrent access with
+// obstruction freedom. In order to support even greater
+// concurrency, in case a push/pop fails, it tries to
+// pair it with another pop/push to eliminate the operation
+// through exchange of values.
 
 class EliminationBackoffStack<T> {
   AtomicReference<Node<T>> top;

README.md

@@ -1,21 +1,29 @@
-Backoff stack is an unbounded lock-free LIFO linked
-list, where pushes and pops synchronize at a single
-location. It is compare-and-set (CAS) atomic operation
-to provide concurrent access with obstruction freedom.
+Elimination-backoff stack is an unbounded lock-free LIFO
+linked list, that eliminates concurrent pairs of pushes
+and pops with exchanges.  It uses compare-and-set (CAS)
+atomic operation to provide concurrent access with
+obstruction freedom. In order to support even greater
+concurrency, in case a push/pop fails, it tries to
+pair it with another pop/push to eliminate the operation
+through exchange of values.
 
 ```java
 push():
-1. Create node for value.
-2. Try pushing node to stack.
-2a. If successful, return.
-2b. Otherwise, backoff and try again.
+1. Create a new node with given value.
+2. Try pushing it to stack.
+3a. If successful, return.
+3b. Otherwise, try exchanging on elimination array.
+4a. If found a matching pop, return.
+4b. Otherwise, retry 2.
 ```
 
 ```java
 pop():
 1. Try popping a node from stack.
-1a. If successful, return its value.
-1b. Otherwise, backoff and try again.
+2a. If successful, return node's value
+2b. Otherwise, try exchanging on elimination array.
+3a. If found a matching push, return its value.
+3b. Otherwise, retry 1.
 ```
 
 ```java
@@ -32,35 +40,56 @@ tryPop():
 ```
 
 ```java
-backoff():
-1. Get a random wait duration.
-2. Sleep for the duration.
-3. Double the max random wait duration.
+EliminationArray.visit():
+1. Try exchanging value on a random exchanger.
+```
+
+```java
+Exchanger.exchange():
+1. Calculate last wait time.
+2. If wait time exceeded, then throw expection.
+3. Get slot value and stamp.
+4a. If slot is EMPTY (no value):
+4b. Try adding 1st value to slot, else retry 2.
+4c. Try getting 2nd value from slot, within time limit.
+5a. If slot is WAITING (has 1st value):
+5b. Try adding 2nd value to slot, else retry 2.
+5c. Return 1st value.
+6a. If slot is BUSY (has 2nd value):
+6b. Retry 2.
 ```
 
 ```bash
 ## OUTPUT
 Starting 10 threads with sequential stack
-1: failed pop
+4: failed push
+2: failed pop
 3: failed pop
-4: failed pop
-1: popped 2/1000 values
-1: has duplicate value 9999
-1: has duplicate value 9998
-3: popped 79/1000 values
-3: has duplicate value 3761
-4: popped 886/1000 values
+0: failed pop
+5: failed pop
+1: failed pop
+0: popped 346/1000 values
+1: popped 403/1000 values
+2: popped 1/1000 values
+2: has duplicate value 9881
+3: popped 6/1000 values
+3: has duplicate value 9654
+3: has duplicate value 9652
+4: popped 0/1000 values
+5: popped 6/1000 values
+5: has duplicate value 9359
+7: has duplicate value 9247
 Was LIFO? false
 
-Starting 10 threads with backoff stack
+Starting 10 threads with elimination backoff stack
 Was LIFO? true
 ```
 
-See [BackoffStack.java] for code, [Main.java] for test, and [repl.it] for output.
+See [EliminationBackoffStack.java] for code, [Main.java] for test, and [repl.it] for output.
 
-[BackoffStack.java]: https://repl.it/@wolfram77/backoff-stack#BackoffStack.java
-[Main.java]: https://repl.it/@wolfram77/backoff-stack#Main.java
-[repl.it]: https://backoff-stack.wolfram77.repl.run
+[EliminationBackoffStack.java]: https://repl.it/@wolfram77/elimination-backoff-stack#EliminationBackoffStack.java
+[Main.java]: https://repl.it/@wolfram77/elimination-backoff-stack#Main.java
+[repl.it]: https://elimination-backoff-stack.wolfram77.repl.run
 
 
 ### references