LockFreeStack fast constructors for 1,2 elements

Author: pitr-ch

lib/concurrent/edge/lock_free_stack.rb

@@ -4,7 +4,11 @@ class LockFreeStack < Synchronization::Object
     safe_initialization!
 
     class Node
+      # TODO (pitr-ch 20-Dec-2016): Could be unified with Stack class?
+
       attr_reader :value, :next_node
+      # allow to nil-ify to free GC when the entry is no longer relevant, not synchronised
+      attr_writer :value
 
       def initialize(value, next_node)
         @value     = value
@@ -24,9 +28,17 @@ def next_node
 
     private(*attr_atomic(:head))
 
-    def initialize
+    def self.of1(value)
+      new Node[value, EMPTY]
+    end
+
+    def self.of2(value1, value2)
+      new Node[value1, Node[value2, EMPTY]]
+    end
+
+    def initialize(head = EMPTY)
       super()
-      self.head = EMPTY
+      self.head = head
     end
 
     def empty?(head = self.head)
@@ -87,6 +99,10 @@ def clear_if(head)
       compare_and_set_head head, EMPTY
     end
 
+    def replace_if(head, new_head)
+      compare_and_set_head head, new_head
+    end
+
     def clear_each(&block)
       while true
         current_head = head

lib/concurrent/edge/promises.rb

@@ -1358,14 +1358,15 @@ def self.new_blocked1(blocker, *args, &block)
       def self.new_blocked2(blocker1, blocker2, *args, &block)
         blocker_delayed1 = blocker1.promise.delayed
         blocker_delayed2 = blocker2.promise.delayed
+        # TODO (pitr-ch 23-Dec-2016): use arrays when we know it will not grow (only flat adds delay)
         delayed          = if blocker_delayed1
                              if blocker_delayed2
-                               LockFreeStack.new2(blocker_delayed1, blocker_delayed2)
+                               LockFreeStack.of2(blocker_delayed1, blocker_delayed2)
                              else
-                               LockFreeStack.new1(blocker_delayed1)
+                               LockFreeStack.of1(blocker_delayed1)
                              end
                            else
-                             blocker_delayed2 ? LockFreeStack.new1(blocker_delayed2) : nil
+                             blocker_delayed2 ? LockFreeStack.of1(blocker_delayed2) : nil
                            end
         promise          = new(delayed, 2, *args, &block)
       ensure
@@ -1384,7 +1385,7 @@ def self.add_delayed(delayed, blocker)
         blocker_delayed = blocker.promise.delayed
         if blocker_delayed
           delayed = unless delayed
-                      LockFreeStack.new1(blocker_delayed)
+                      LockFreeStack.of1(blocker_delayed)
                     else
                       delayed.push(blocker_delayed)
                     end