Replaced primitive stacks with eclipse-collections

community/index/src/main/java/org/neo4j/index/internal/gbptree/TreeNodeDynamicSize.java

@@ -19,10 +19,13 @@
  */
 package org.neo4j.index.internal.gbptree;
 
+import org.eclipse.collections.api.stack.primitive.IntStack;
+import org.eclipse.collections.api.stack.primitive.MutableIntStack;
+import org.eclipse.collections.impl.stack.mutable.primitive.IntArrayStack;
+
 import java.util.Arrays;
 import java.util.StringJoiner;
 
-import org.neo4j.collection.primitive.PrimitiveIntStack;
 import org.neo4j.io.pagecache.PageCursor;
 
 import static java.lang.String.format;
@@ -90,8 +93,8 @@ public class TreeNodeDynamicSize<KEY, VALUE> extends TreeNode<KEY,VALUE>
     private static final int LEAST_NUMBER_OF_ENTRIES_PER_PAGE = 2;
     private static final int MINIMUM_ENTRY_SIZE_CAP = Long.SIZE;
     private final int keyValueSizeCap;
-    private final PrimitiveIntStack deadKeysOffset = new PrimitiveIntStack();
-    private final PrimitiveIntStack aliveKeysOffset = new PrimitiveIntStack();
+    private final MutableIntStack deadKeysOffset = new IntArrayStack();
+    private final MutableIntStack aliveKeysOffset = new IntArrayStack();
     private final int maxKeyCount = pageSize / (bytesKeyOffset() + SIZE_KEY_SIZE + SIZE_VALUE_SIZE);
     private final int[] oldOffset = new int[maxKeyCount];
     private final int[] newOffset = new int[maxKeyCount];
@@ -471,25 +474,25 @@ For each dead space of size X (can be multiple consecutive dead keys)
         int deadRangeOffset; // Everything between this point and aliveRangeOffset is dead space
 
         // Rightmost alive keys does not need to move
-        while ( deadKeysOffset.peek() < aliveKeysOffset.peek() )
+        while ( peek( deadKeysOffset ) < peek( aliveKeysOffset ) )
         {
-            aliveRangeOffset = aliveKeysOffset.poll();
+            aliveRangeOffset = poll( aliveKeysOffset );
         }
 
         do
         {
             // Locate next range of dead keys
             deadRangeOffset = aliveRangeOffset;
-            while ( aliveKeysOffset.peek() < deadKeysOffset.peek() )
+            while ( peek( aliveKeysOffset ) < peek( deadKeysOffset ) )
             {
-                deadRangeOffset = deadKeysOffset.poll();
+                deadRangeOffset = poll( deadKeysOffset );
             }
 
             // Locate next range of alive keys
             int moveOffset = deadRangeOffset;
-            while ( deadKeysOffset.peek() < aliveKeysOffset.peek() )
+            while ( peek( deadKeysOffset ) < peek( aliveKeysOffset ) )
             {
-                int moveKey = aliveKeysOffset.poll();
+                int moveKey = poll( aliveKeysOffset );
                 oldOffset[oldOffsetCursor++] = moveKey;
                 moveOffset = moveKey;
             }
@@ -551,6 +554,16 @@ For each dead space of size X (can be multiple consecutive dead keys)
         setDeadSpace( cursor, 0 );
     }
 
+    private static int peek( IntStack stack )
+    {
+        return stack.isEmpty() ? -1 : stack.peek();
+    }
+
+    private static int poll( MutableIntStack stack )
+    {
+        return stack.isEmpty() ? -1 : stack.pop();
+    }
+
     @Override
     boolean leafUnderflow( PageCursor cursor, int keyCount )
     {
@@ -855,7 +868,7 @@ private int getAllocSpace( PageCursor cursor, int keyCount, Type type )
         return allocOffset - endOfOffsetArray;
     }
 
-    private void recordDeadAndAliveLeaf( PageCursor cursor, PrimitiveIntStack deadKeysOffset, PrimitiveIntStack aliveKeysOffset )
+    private void recordDeadAndAliveLeaf( PageCursor cursor, MutableIntStack deadKeysOffset, MutableIntStack aliveKeysOffset )
     {
         int currentOffset = getAllocOffset( cursor );
         while ( currentOffset < pageSize )
@@ -878,7 +891,7 @@ private void recordDeadAndAliveLeaf( PageCursor cursor, PrimitiveIntStack deadKe
         }
     }
 
-    private void recordDeadAndAliveInternal( PageCursor cursor, PrimitiveIntStack deadKeysOffset, PrimitiveIntStack aliveKeysOffset )
+    private void recordDeadAndAliveInternal( PageCursor cursor, MutableIntStack deadKeysOffset, MutableIntStack aliveKeysOffset )
     {
         int currentOffset = getAllocOffset( cursor );
         while ( currentOffset < pageSize )

community/kernel/src/main/java/org/neo4j/unsafe/impl/batchimport/cache/idmapping/string/ParallelSort.java

@@ -19,10 +19,12 @@
  */
 package org.neo4j.unsafe.impl.batchimport.cache.idmapping.string;
 
+import org.eclipse.collections.api.stack.primitive.MutableLongStack;
+import org.eclipse.collections.impl.stack.mutable.primitive.LongArrayStack;
+
 import java.util.Arrays;
 import java.util.concurrent.ThreadLocalRandom;
 
-import org.neo4j.collection.primitive.PrimitiveLongStack;
 import org.neo4j.helpers.progress.ProgressListener;
 import org.neo4j.unsafe.impl.batchimport.Utils;
 import org.neo4j.unsafe.impl.batchimport.Utils.CompareType;
@@ -311,13 +313,13 @@ else if ( comparator.ge( right, pivot ) )
 
         private void qsort( long initialStart, long initialEnd )
         {
-            PrimitiveLongStack stack = new PrimitiveLongStack( 100 );
+            final MutableLongStack stack = new LongArrayStack();
             stack.push( initialStart );
             stack.push( initialEnd );
             while ( !stack.isEmpty() )
             {
-                long end = stack.poll();
-                long start = stack.poll();
+                long end = stack.isEmpty() ? -1 : stack.pop();
+                long start = stack.isEmpty() ? -1 : stack.pop();
                 long diff = end - start;
                 if ( diff < 2 )
                 {