LockFreeLinkedSet: refactor to use SynchronizationObject

Author: ianks

lib/concurrent/edge/lock_free_linked_set.rb

@@ -14,8 +14,7 @@ def initialize(initial_size = 0, val = nil)
 
         initial_size.times do
           val = block_given? ? yield : val
-
-          self.add val
+          add val
         end
       end
 
@@ -37,12 +36,12 @@ def add(item)
           pred, curr = window.pred, window.curr
 
           # Item already in set
-          if curr == item
-            return false
-          else
-            node = Node.new item, curr
+          return false if curr == item
+
+          node = Node.new item, curr
 
-            return true if pred.succ.compare_and_set curr, node, false, false
+          if pred.SuccessorReference.compare_and_set curr, node, false, false
+            return true
           end
         end
       end
@@ -73,8 +72,8 @@ def contains?(item)
         curr = @head
 
         while curr < item
-          curr = curr.next
-          marked = curr.succ.marked?
+          curr = curr.next_node
+          marked = curr.SuccessorReference.marked?
         end
 
         curr == item && !marked
@@ -92,18 +91,16 @@ def remove(item)
           window = Window.find @head, item
           pred, curr = window.pred, window.curr
 
-          if curr != item
-            return false
-          else
-            succ = curr.next
-            snip = curr.succ.compare_and_set succ, succ, false, true
+          return false if curr != item
 
-            next unless snip
+          succ = curr.next_node
+          removed = curr.SuccessorReference.compare_and_set succ, succ, false, true
 
-            pred.succ.compare_and_set curr, succ, false, false
+          next_node unless removed
 
-            return true
-          end
+          pred.SuccessorReference.compare_and_set curr, succ, false, false
+
+          return true
         end
       end
 
@@ -121,10 +118,10 @@ def each
         curr = @head
 
         until curr.last?
-          curr = curr.next
-          marked = curr.succ.marked?
+          curr = curr.next_node
+          marked = curr.SuccessorReference.marked?
 
-          yield curr.data if !marked
+          yield curr.Data unless marked
         end
 
         self

lib/concurrent/edge/lock_free_linked_set/node.rb

@@ -3,26 +3,30 @@
 module Concurrent
   module Edge
     class LockFreeLinkedSet
-      class Node
+      class Node < Synchronization::Object
         include Comparable
 
-        attr_reader :data, :succ, :key
+        attr_reader :Data, :SuccessorReference, :Key
 
-        def initialize(data = nil, succ = nil)
-          @succ = AtomicMarkableReference.new(succ || Tail.new)
-          @data = data
-          @key = key_for data
+        def initialize(data = nil, successor = nil)
+          super()
+
+          @SuccessorReference = AtomicMarkableReference.new(successor || Tail.new)
+          @Data = data
+          @Key = key_for data
+
+          ensure_ivar_visibility!
         end
 
         # Check to see if the node is the last in the list.
         def last?
-          @succ.value.is_a? Tail
+          @SuccessorReference.value.is_a? Tail
         end
 
         # Next node in the list. Note: this is not the AtomicMarkableReference
         # of the next node, this is the actual Node itself.
-        def next
-          @succ.value
+        def next_node
+          @SuccessorReference.value
         end
 
         # This method provides a unqiue key for the data which will be used for
@@ -36,16 +40,16 @@ def key_for(data)
         # can be configurable in the future; for example, you could enforce a
         # split-ordering on the nodes in the set.
         def <=>(other)
-          @key <=> other.hash
+          @Key <=> other.hash
         end
       end
 
       # Internal sentinel node for the Tail. It is always greater than all
       # other nodes, and  it is self-referential; meaning its successor is
       # a self-loop.
       class Tail < Node
-        def initialize(data = nil, _succ = nil)
-          @succ = AtomicMarkableReference.new self
+        def initialize(_data = nil, _succ = nil)
+          @SuccessorReference = AtomicMarkableReference.new self
         end
 
         # Always greater than other nodes. This means that traversal will end

lib/concurrent/edge/lock_free_linked_set/window.rb

@@ -16,20 +16,20 @@ def self.find(head, item)
         loop do
           break_inner_loops = false
           pred = head
-          curr = pred.next
+          curr = pred.next_node
 
           loop do
-            succ, marked = curr.succ.get
+            succ, marked = curr.SuccessorReference.get
 
             # Remove sequence of marked nodes
             while marked
-              removed = pred.succ.compare_and_set curr, succ, false, false
+              removed = pred.SuccessorReference.compare_and_set curr, succ, false, false
 
               # If could not remove node, try again
               break_inner_loops = true && break unless removed
 
               curr = succ
-              succ, marked = curr.succ.get
+              succ, marked = curr.SuccessorReference.get
             end
 
             break if break_inner_loops