Reduce time spent in lubs

Reduce time spent in lubs by making depth more adaptive. It now takes into account separately the depth of the lub types and the maximal depth of theior base type sequences. It cuts depth more aggressively if it is the base types  instead of the types themselves that grow deep.

The old truncation behavior is retained under option -Xfull-lubs

Another change is that we now track depth more precisely, which should also help or at least allow better statistics.

Also added statistics that measure #lubs and time spent in them.

1 files changed, 38 insertions, 0 deletions

diff --git a/test/files/pos/t5862.scala b/test/files/pos/t5862.scala
new file mode 100644
index 0000000000..e3006ddc3f
--- /dev/null
+++ b/test/files/pos/t5862.scala
@@ -0,0 +1,38 @@
+package test
+
+import java.io.DataOutput
+import java.io.DataInput
+
+/** Interface for writing outputs from a DoFn. */
+trait Emitter[A] {
+  def emit(value: A): Unit
+}
+
+/** A wrapper for a 'map' function tagged for a specific output channel. */
+abstract class TaggedMapper[A, K, V]
+    (val tags: Set[Int])
+    (implicit val mA: Manifest[A], val wtA: WireFormat[A],
+              val mK: Manifest[K], val wtK: WireFormat[K], val ordK: Ordering[K],
+              val mV: Manifest[V], val wtV: WireFormat[V])
+  extends Serializable {
+}
+
+/** Type-class for sending types across the Hadoop wire. */
+trait WireFormat[A]
+
+class MapReduceJob {
+  trait DataSource
+
+  import scala.collection.mutable.{ Set => MSet, Map => MMap }
+  private val mappers: MMap[DataSource, MSet[TaggedMapper[_, _, _]]] = MMap.empty
+
+  def addTaggedMapper[A, K, V](input: DataSource, m: TaggedMapper[A, K, V]): Unit = {
+    if (!mappers.contains(input))
+      mappers += (input -> MSet(m))
+    else
+      mappers(input) += m // : Unit
+
+    m.tags.foreach { tag =>
+    }
+  }
+}