From 8f5c9aebec9ee1cc2b7c6dbcc4bac22370593a55 Mon Sep 17 00:00:00 2001
From: Doug Lawrie <doug@neverfear.org>
Date: Fri, 11 Aug 2017 15:57:44 +0100
Subject: [PATCH] Linked queues: Refactoring node construction and variable
 names

Construction of a new LinkedQueueNode or new LinkedQueueAtomicNode is done in the base class

Some parameter variable names homogenized
---
 .../org/jctools/queues/BaseLinkedQueue.java   | 16 +++++++++----
 .../org/jctools/queues/MpscLinkedQueue.java   | 14 +++++------
 .../org/jctools/queues/SpscLinkedQueue.java   | 11 ++++-----
 .../queues/atomic/BaseLinkedAtomicQueue.java  | 24 +++++++++++--------
 .../queues/atomic/MpscLinkedAtomicQueue.java  | 10 ++++----
 .../queues/atomic/SpscLinkedAtomicQueue.java  |  4 ++--
 6 files changed, 43 insertions(+), 36 deletions(-)

diff --git a/jctools-core/src/main/java/org/jctools/queues/BaseLinkedQueue.java b/jctools-core/src/main/java/org/jctools/queues/BaseLinkedQueue.java
index 23ed03db..8f27213f 100644
--- a/jctools-core/src/main/java/org/jctools/queues/BaseLinkedQueue.java
+++ b/jctools-core/src/main/java/org/jctools/queues/BaseLinkedQueue.java
@@ -39,8 +39,8 @@ abstract class BaseLinkedQueueProducerNodeRef<E> extends BaseLinkedQueuePad0<E>
 
     protected LinkedQueueNode<E> producerNode;
 
-    protected final void spProducerNode(LinkedQueueNode<E> node) {
-        producerNode = node;
+    protected final void spProducerNode(LinkedQueueNode<E> newValue) {
+        producerNode = newValue;
     }
 
     @SuppressWarnings("unchecked")
@@ -73,8 +73,8 @@ abstract class BaseLinkedQueueConsumerNodeRef<E> extends BaseLinkedQueuePad1<E>
 
     protected LinkedQueueNode<E> consumerNode;
 
-    protected final void spConsumerNode(LinkedQueueNode<E> node) {
-        consumerNode = node;
+    protected final void spConsumerNode(LinkedQueueNode<E> newValue) {
+        consumerNode = newValue;
     }
 
     @SuppressWarnings("unchecked")
@@ -112,6 +112,14 @@ public String toString() {
         return this.getClass().getName();
     }
     
+    protected final LinkedQueueNode<E> newNode() {
+        return new LinkedQueueNode<E>();
+    }
+    
+    protected final LinkedQueueNode<E> newNode(E e) {
+        return new LinkedQueueNode<E>(e);
+    }
+    
     /**
      * {@inheritDoc} <br>
      * <p>
diff --git a/jctools-core/src/main/java/org/jctools/queues/MpscLinkedQueue.java b/jctools-core/src/main/java/org/jctools/queues/MpscLinkedQueue.java
index 623b2ed7..fd76bb77 100644
--- a/jctools-core/src/main/java/org/jctools/queues/MpscLinkedQueue.java
+++ b/jctools-core/src/main/java/org/jctools/queues/MpscLinkedQueue.java
@@ -47,7 +47,7 @@ public static <E> MpscLinkedQueue<E> newMpscLinkedQueue() {
     }
     
     protected MpscLinkedQueue() {
-        LinkedQueueNode<E> node = new LinkedQueueNode<E>();
+        LinkedQueueNode<E> node = newNode();
         spConsumerNode(node);
         xchgProducerNode(node);// this ensures correct construction: StoreLoad
     }
@@ -75,7 +75,7 @@ public final boolean offer(final E e) {
         if (null == e) {
             throw new NullPointerException();
         }
-        final LinkedQueueNode<E> nextNode = new LinkedQueueNode<E>(e);
+        final LinkedQueueNode<E> nextNode = newNode(e);
         final LinkedQueueNode<E> prevProducerNode = xchgProducerNode(nextNode);
         // Should a producer thread get interrupted here the chain WILL be broken until that thread is resumed
         // and completes the store in prev.next.
@@ -106,8 +106,7 @@ public final E poll() {
         LinkedQueueNode<E> nextNode = currConsumerNode.lvNext();
         if (nextNode != null) {
             return getSingleConsumerNodeValue(currConsumerNode, nextNode);
-        }
-        else if (currConsumerNode != lvProducerNode()) {
+        } else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
             while ((nextNode = currConsumerNode.lvNext()) == null);
             // got the next node...
@@ -123,8 +122,7 @@ public final E peek() {
         LinkedQueueNode<E> nextNode = currConsumerNode.lvNext();
         if (nextNode != null) {
             return nextNode.lpValue();
-        }
-        else if (currConsumerNode != lvProducerNode()) {
+        } else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
             while ((nextNode = currConsumerNode.lvNext()) == null);
             // got the next node...
@@ -146,10 +144,10 @@ public int fill(Supplier<E> s) {
     @Override
     public int fill(Supplier<E> s, int limit) {
         if (limit == 0) return 0;
-        LinkedQueueNode<E> tail = new LinkedQueueNode<E>(s.get());
+        LinkedQueueNode<E> tail = newNode(s.get());
         final LinkedQueueNode<E> head = tail;
         for (int i = 1; i < limit; i++) {
-            final LinkedQueueNode<E> temp = new LinkedQueueNode<E>(s.get());
+            final LinkedQueueNode<E> temp = newNode(s.get());
             tail.soNext(temp);
             tail = temp;
         }
diff --git a/jctools-core/src/main/java/org/jctools/queues/SpscLinkedQueue.java b/jctools-core/src/main/java/org/jctools/queues/SpscLinkedQueue.java
index 9a1d7dee..c4611699 100644
--- a/jctools-core/src/main/java/org/jctools/queues/SpscLinkedQueue.java
+++ b/jctools-core/src/main/java/org/jctools/queues/SpscLinkedQueue.java
@@ -32,7 +32,7 @@
 public class SpscLinkedQueue<E> extends BaseLinkedQueue<E> {
 
     public SpscLinkedQueue() {
-        LinkedQueueNode<E> node = new LinkedQueueNode<E>();
+        LinkedQueueNode<E> node = newNode();
         spProducerNode(node);
         spConsumerNode(node);
         node.soNext(null); // this ensures correct construction: StoreStore
@@ -58,7 +58,7 @@ public boolean offer(final E e) {
         if (null == e) {
             throw new NullPointerException();
         }
-        final LinkedQueueNode<E> nextNode = new LinkedQueueNode<E>(e);
+        final LinkedQueueNode<E> nextNode = newNode(e);
         lpProducerNode().soNext(nextNode);
         spProducerNode(nextNode);
         return true;
@@ -102,10 +102,10 @@ public int fill(Supplier<E> s) {
     @Override
     public int fill(Supplier<E> s, int limit) {
         if (limit == 0) return 0;
-        LinkedQueueNode<E> tail = new LinkedQueueNode<E>(s.get());
+        LinkedQueueNode<E> tail = newNode(s.get());
         final LinkedQueueNode<E> head = tail;
         for (int i = 1; i < limit; i++) {
-            final LinkedQueueNode<E> temp = new LinkedQueueNode<E>(s.get());
+            final LinkedQueueNode<E> temp = newNode(s.get());
             tail.soNext(temp);
             tail = temp;
         }
@@ -115,13 +115,12 @@ public int fill(Supplier<E> s, int limit) {
         return limit;
     }
 
-
     @Override
     public void fill(Supplier<E> s, WaitStrategy wait, ExitCondition exit) {
         LinkedQueueNode<E> chaserNode = producerNode;
         while (exit.keepRunning()) {
             for (int i = 0; i < 4096; i++) {
-                final LinkedQueueNode<E> nextNode = new LinkedQueueNode<E>(s.get());
+                final LinkedQueueNode<E> nextNode = newNode(s.get());
                 chaserNode.soNext(nextNode);
                 chaserNode = nextNode;
                 this.producerNode = chaserNode;
diff --git a/jctools-core/src/main/java/org/jctools/queues/atomic/BaseLinkedAtomicQueue.java b/jctools-core/src/main/java/org/jctools/queues/atomic/BaseLinkedAtomicQueue.java
index ce8f2821..7ef660c1 100644
--- a/jctools-core/src/main/java/org/jctools/queues/atomic/BaseLinkedAtomicQueue.java
+++ b/jctools-core/src/main/java/org/jctools/queues/atomic/BaseLinkedAtomicQueue.java
@@ -17,8 +17,6 @@
 import java.util.Iterator;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 
-import org.jctools.queues.MessagePassingQueue;
-
 abstract class BaseLinkedAtomicQueuePad0<E> extends AbstractQueue<E> {
     long p00, p01, p02, p03, p04, p05, p06, p07;
     long p10, p11, p12, p13, p14, p15, p16;
@@ -29,8 +27,8 @@ abstract class BaseLinkedAtomicQueueProducerNodeRef<E> extends BaseLinkedAtomicQ
 
     protected volatile LinkedQueueAtomicNode<E> producerNode;
     
-    protected final void spProducerNode(LinkedQueueAtomicNode<E> node) {
-        P_NODE_UPDATER.lazySet(this, node);
+    protected final void spProducerNode(LinkedQueueAtomicNode<E> newValue) {
+        P_NODE_UPDATER.lazySet(this, newValue);
     }
     
     protected final LinkedQueueAtomicNode<E> lvProducerNode() {
@@ -41,8 +39,8 @@ protected final LinkedQueueAtomicNode<E> lpProducerNode() {
         return lvProducerNode();
     }
     
-    protected final LinkedQueueAtomicNode<E> xchgProducerNode(LinkedQueueAtomicNode<E> node) {
-        return P_NODE_UPDATER.getAndSet(this, node);
+    protected final LinkedQueueAtomicNode<E> xchgProducerNode(LinkedQueueAtomicNode<E> newValue) {
+        return P_NODE_UPDATER.getAndSet(this, newValue);
     }
 }
 
@@ -56,8 +54,8 @@ abstract class BaseLinkedAtomicQueueConsumerNodeRef<E> extends BaseLinkedAtomicQ
 
     protected volatile LinkedQueueAtomicNode<E> consumerNode;
     
-    protected final void spConsumerNode(LinkedQueueAtomicNode<E> node) {
-        C_NODE_UPDATER.lazySet(this, node);
+    protected final void spConsumerNode(LinkedQueueAtomicNode<E> newValue) {
+        C_NODE_UPDATER.lazySet(this, newValue);
     }
     
     protected final LinkedQueueAtomicNode<E> lvConsumerNode() {
@@ -86,6 +84,14 @@ public String toString() {
         return this.getClass().getName();
     }
     
+    protected final LinkedQueueAtomicNode<E> newNode() {
+        return new LinkedQueueAtomicNode<E>();
+    }
+    
+    protected final LinkedQueueAtomicNode<E> newNode(E e) {
+        return new LinkedQueueAtomicNode<E>(e);
+    }
+    
     public final int size() {
         // Read consumer first, this is important because if the producer is node is 'older' than the consumer
         // the consumer may overtake it (consume past it). This will lead to an infinite loop below.
@@ -116,8 +122,6 @@ public final int size() {
      * Queue is empty when producerNode is the same as consumerNode. An alternative implementation would be to
      * observe the producerNode.value is null, which also means an empty queue because only the
      * consumerNode.value is allowed to be null.
-     *
-     * @see MessagePassingQueue#isEmpty()
      */
     @Override
     public final boolean isEmpty() {
diff --git a/jctools-core/src/main/java/org/jctools/queues/atomic/MpscLinkedAtomicQueue.java b/jctools-core/src/main/java/org/jctools/queues/atomic/MpscLinkedAtomicQueue.java
index 2e6ca52f..15fbef95 100644
--- a/jctools-core/src/main/java/org/jctools/queues/atomic/MpscLinkedAtomicQueue.java
+++ b/jctools-core/src/main/java/org/jctools/queues/atomic/MpscLinkedAtomicQueue.java
@@ -30,7 +30,7 @@
 public final class MpscLinkedAtomicQueue<E> extends BaseLinkedAtomicQueue<E> {
 
     public MpscLinkedAtomicQueue() {
-        LinkedQueueAtomicNode<E> node = new LinkedQueueAtomicNode<E>();
+        LinkedQueueAtomicNode<E> node = newNode();
         spConsumerNode(node);
         xchgProducerNode(node);// this ensures correct construction: StoreLoad
     }
@@ -55,7 +55,7 @@ public final boolean offer(final E e) {
         if (null == e) {
             throw new NullPointerException();
         }
-        final LinkedQueueAtomicNode<E> nextNode = new LinkedQueueAtomicNode<E>(e);
+        final LinkedQueueAtomicNode<E> nextNode = newNode(e);
         final LinkedQueueAtomicNode<E> prevProducerNode = xchgProducerNode(nextNode);
         // Should a producer thread get interrupted here the chain WILL be broken until that thread is resumed
         // and completes the store in prev.next.
@@ -86,8 +86,7 @@ public final E poll() {
         LinkedQueueAtomicNode<E> nextNode = currConsumerNode.lvNext();
         if (nextNode != null) {
             return getSingleConsumerNodeValue(currConsumerNode, nextNode);
-        }
-        else if (currConsumerNode != lvProducerNode()) {
+        } else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
             while ((nextNode = currConsumerNode.lvNext()) == null);
             // got the next node...
@@ -103,8 +102,7 @@ public final E peek() {
         LinkedQueueAtomicNode<E> nextNode = currConsumerNode.lvNext();
         if (nextNode != null) {
             return nextNode.lpValue();
-        }
-        else if (currConsumerNode != lvProducerNode()) {
+        } else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
             while ((nextNode = currConsumerNode.lvNext()) == null);
             // got the next node...
diff --git a/jctools-core/src/main/java/org/jctools/queues/atomic/SpscLinkedAtomicQueue.java b/jctools-core/src/main/java/org/jctools/queues/atomic/SpscLinkedAtomicQueue.java
index 156acd96..8e1227c5 100644
--- a/jctools-core/src/main/java/org/jctools/queues/atomic/SpscLinkedAtomicQueue.java
+++ b/jctools-core/src/main/java/org/jctools/queues/atomic/SpscLinkedAtomicQueue.java
@@ -31,7 +31,7 @@
 public final class SpscLinkedAtomicQueue<E> extends BaseLinkedAtomicQueue<E> {
 
     public SpscLinkedAtomicQueue() {
-        LinkedQueueAtomicNode<E> node = new LinkedQueueAtomicNode<E>();
+        LinkedQueueAtomicNode<E> node = newNode();
         spProducerNode(node);
         spConsumerNode(node);
         node.soNext(null); // this ensures correct construction: StoreStore
@@ -57,7 +57,7 @@ public boolean offer(final E e) {
         if (null == e) {
             throw new NullPointerException();
         }
-        final LinkedQueueAtomicNode<E> nextNode = new LinkedQueueAtomicNode<E>(e);
+        final LinkedQueueAtomicNode<E> nextNode = newNode(e);
         lpProducerNode().soNext(nextNode);
         spProducerNode(nextNode);
         return true;