Move Stack classes to wrapper classes to fix non-deterministic build issue

sql-plugin/src/main/scala-2.12/com/nvidia/spark/rapids/ScalaStack.scala → sql-plugin/src/main/scala-2.12/com/nvidia/spark/rapids/RapidsStack.scala

@@ -18,4 +18,36 @@ package com.nvidia.spark.rapids
 
 import scala.collection.mutable.ArrayStack
 
-class ScalaStack[T] extends ArrayStack[T]
+class RapidsStack[T] extends Proxy {
+  private val stack = new ArrayStack[T]()
+
+  override def self = stack
+
+  def push(elem1: T): Unit = {
+    self.push(elem1)
+  }
+
+  def pop(): T = {
+    self.pop()
+  }
+
+  def isEmpty: Boolean = {
+    self.isEmpty
+  }
+
+  def nonEmpty: Boolean = {
+    self.nonEmpty
+  }
+
+  def size: Int = {
+    self.size
+  }
+
+  def toSeq: Seq[T] = {
+    self.toSeq
+  }
+
+  def clear(): Unit = {
+    self.clear()
+  }
+}

sql-plugin/src/main/scala-2.13/com/nvidia/spark/rapids/ScalaStack.scala → sql-plugin/src/main/scala-2.13/com/nvidia/spark/rapids/RapidsStack.scala

@@ -18,4 +18,36 @@ package com.nvidia.spark.rapids
 
 import scala.collection.mutable.Stack
 
-class ScalaStack[T] extends Stack[T]
+class RapidsStack[T] extends Proxy {
+  private val stack = new Stack[T]()
+  override def self = stack
+
+  def push(elem1: T): RapidsStack[T] = {
+    self.push(elem1)
+    this
+  }
+
+  def pop(): T = {
+    self.pop()
+  }
+
+  def isEmpty: Boolean = {
+    self.isEmpty
+  }
+
+  def nonEmpty: Boolean = {
+    self.nonEmpty
+  }
+
+  def size(): Int = {
+    self.size
+  }
+
+  def toSeq(): Seq[T] = {
+    self.toSeq
+  }
+
+  def clear(): Unit = {
+    self.clear()
+  }
+}

sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuSortExec.scala

@@ -450,8 +450,8 @@ case class GpuOutOfCoreSortIterator(
     while (!pending.isEmpty && sortedSize < targetSize) {
       // Keep going until we have enough data to return
       var bytesLeftToFetch = targetSize
-      val pendingSort = new ScalaStack[SpillableColumnarBatch]()
-      closeOnExcept(pendingSort) { _ =>
+      val pendingSort = new RapidsStack[SpillableColumnarBatch]()
+      closeOnExcept(pendingSort.toSeq) { _ =>
         while (!pending.isEmpty &&
             (bytesLeftToFetch - pending.peek().buffer.sizeInBytes >= 0 || pendingSort.isEmpty)) {
           val buffer = pending.poll().buffer

sql-plugin/src/main/scala/com/nvidia/spark/rapids/SortUtils.scala

@@ -242,9 +242,9 @@ class GpuSorter(
    * @return the sorted data.
    */
   final def mergeSortAndCloseWithRetry(
-      spillableBatches: ScalaStack[SpillableColumnarBatch],
+      spillableBatches: RapidsStack[SpillableColumnarBatch],
       sortTime: GpuMetric): SpillableColumnarBatch = {
-    closeOnExcept(spillableBatches) { _ =>
+    closeOnExcept(spillableBatches.toSeq) { _ =>
       assert(spillableBatches.nonEmpty)
     }
     withResource(new NvtxWithMetrics("merge sort", NvtxColor.DARK_GREEN, sortTime)) { _ =>
@@ -277,9 +277,9 @@ class GpuSorter(
             }
           }
         } else {
-          closeOnExcept(spillableBatches) { _ =>
-            val batchesToMerge = new ScalaStack[SpillableColumnarBatch]()
-            closeOnExcept(batchesToMerge) { _ =>
+          closeOnExcept(spillableBatches.toSeq) { _ =>
+            val batchesToMerge = new RapidsStack[SpillableColumnarBatch]()
+            closeOnExcept(batchesToMerge.toSeq) { _ =>
               while (spillableBatches.nonEmpty || batchesToMerge.size > 1) {
                 // pop a spillable batch if there is one, and add it to `batchesToMerge`.
                 if (spillableBatches.nonEmpty) {
@@ -299,7 +299,7 @@ class GpuSorter(
 
                   // we no longer care about the old batches, we closed them
                   closeOnExcept(merged) { _ =>
-                    batchesToMerge.safeClose()
+                    batchesToMerge.toSeq.safeClose()
                     batchesToMerge.clear()
                   }