Lazy fields null out fields that are used only ...

Lazy fields null out fields that are used only in their initializer.
When the lazy value is forced, it will null out all private fields that
are used only by the current lazy value. This should reduce memory
leaks, see scala#720

Author: dragos

src/compiler/scala/tools/nsc/backend/icode/GenICode.scala

@@ -69,7 +69,7 @@ abstract class GenICode extends SubComponent  {
     override def apply(unit: CompilationUnit): Unit = {
       this.unit = unit
       unit.icode.clear
-      log("Generating icode for " + unit)
+      informProgress("Generating icode for " + unit)
       gen(unit.body)
       this.unit = null
     }

src/compiler/scala/tools/nsc/transform/Mixin.scala

@@ -9,9 +9,8 @@ package transform
 
 import symtab._
 import Flags._
-import scala.collection.mutable.ListBuffer
 import scala.tools.nsc.util.{Position,NoPosition}
-import scala.collection.mutable.HashMap
+import collection.mutable.{ListBuffer, HashMap}
 
 abstract class Mixin extends InfoTransform with ast.TreeDSL {
   import global._
@@ -364,6 +363,50 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
       tp
   }
 
+  import scala.collection._
+
+  /** Return a map of single-use fields to the lazy value that uses them during initialization.
+   *  Each field has to be private and defined in the enclosing class, and there must
+   *  be exactly one lazy value using it.
+   *
+   *  Such fields will be nulled after the initializer has memoized the lazy value.
+   */
+  def singleUseFields(templ: Template): collection.Map[Symbol, List[Symbol]] = {
+    val usedIn = new mutable.HashMap[Symbol, List[Symbol]] {
+      override def default(key: Symbol) = Nil
+    }
+
+    object SingleUseTraverser extends Traverser {
+      override def traverse(tree: Tree) {
+        tree match {
+          case Assign(lhs, rhs) => traverse(rhs) // assignments don't count
+          case _ =>
+            if (tree.hasSymbol && tree.symbol != NoSymbol) {
+              val sym = tree.symbol
+              if ((sym.hasFlag(ACCESSOR) || (sym.isTerm && !sym.isMethod))
+                  && sym.hasFlag(PRIVATE)
+                  && !(currentOwner.isGetter && currentOwner.accessed == sym) // getter
+                  && !definitions.isValueClass(sym.tpe.resultType.typeSymbol)
+                  && sym.owner == templ.symbol.owner
+                  && !tree.isDef) {
+                log("added use in: " + currentOwner + " -- " + tree)
+                usedIn(sym) ::= currentOwner
+
+              }
+            }
+            super.traverse(tree)
+        }
+      }
+    }
+    SingleUseTraverser(templ)
+    log("usedIn: " + usedIn)
+    usedIn filter { pair =>
+      val member = pair._2.head
+      (member.isValue
+         && member.hasFlag(LAZY)
+         && pair._2.tail.isEmpty) }
+  }
+
 // --------- term transformation -----------------------------------------------
 
   protected def newTransformer(unit: CompilationUnit): Transformer =
@@ -384,6 +427,9 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
     private var localTyper: erasure.Typer = _
     private def typedPos(pos: Position)(tree: Tree) = localTyper typed { atPos(pos)(tree) }
 
+    /** Map lazy values to the fields they should null after initialization. */
+    private var lazyValNullables: mutable.MultiMap[Symbol, Symbol] = _
+
     import scala.collection._
 
     /** Map a field symbol to a unique integer denoting its position in the class layout.
@@ -612,17 +658,27 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
        *  where bitmap$n is an int value acting as a bitmap of initialized values. It is
        *  the 'n' is (offset / 32), the MASK is (1 << (offset % 32)).
        */
-      def mkLazyDef(clazz: Symbol, init: List[Tree], retVal: Tree, offset: Int): Tree = {
+      def mkLazyDef(clazz: Symbol, lzyVal: Symbol, init: List[Tree], retVal: Tree, offset: Int): Tree = {
+        def nullify(sym: Symbol): Tree = {
+          val sym1 = if (sym.hasFlag(ACCESSOR)) sym.accessed else sym
+          Select(This(clazz), sym1) === LIT(null)
+        }
+
+
         val bitmapSym = bitmapFor(clazz, offset)
         val mask      = LIT(1 << (offset % FLAGS_PER_WORD))
         def cond      = mkTest(clazz, mask, bitmapSym, true)
+        val nulls     = (lazyValNullables(lzyVal).toList.sort(_.id < _.id) map nullify)
         def syncBody  = init ::: List(mkSetFlag(clazz, offset), UNIT)
 
+        log("nulling fields inside " + lzyVal + ": " + nulls)
         val result    =
-          IF (cond) THEN gen.mkSynchronized(
-            gen mkAttributedThis clazz,
-            IF (cond) THEN BLOCK(syncBody: _*) ENDIF
-          ) ENDIF
+          IF (cond) THEN BLOCK(
+            (gen.mkSynchronized(
+              gen mkAttributedThis clazz,
+              IF (cond) THEN BLOCK(syncBody: _*) ENDIF
+            )
+            :: nulls): _*) ENDIF
 
         typedPos(init.head.pos)(BLOCK(result, retVal))
       }
@@ -653,10 +709,10 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
             if sym.hasFlag(LAZY) && rhs != EmptyTree && !clazz.isImplClass =>
               assert(fieldOffset.isDefinedAt(sym))
               val rhs1 = if (sym.tpe.resultType.typeSymbol == UnitClass)
-                mkLazyDef(clazz, List(rhs), UNIT, fieldOffset(sym))
+                mkLazyDef(clazz, sym, List(rhs), UNIT, fieldOffset(sym))
               else {
                 val Block(stats, res) = rhs
-                mkLazyDef(clazz, stats, Select(This(clazz), res.symbol), fieldOffset(sym))
+                mkLazyDef(clazz, sym, stats, Select(This(clazz), res.symbol), fieldOffset(sym))
               }
               treeCopy.DefDef(stat, mods, name, tp, vp, tpt, rhs1)
 
@@ -790,13 +846,13 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
                     if (sym.hasFlag(LAZY) && sym.isGetter) {
                       val rhs1 =
                         if (sym.tpe.resultType.typeSymbol == UnitClass)
-                          mkLazyDef(clazz, List(Apply(staticRef(initializer(sym)), List(gen.mkAttributedThis(clazz)))), UNIT, fieldOffset(sym))
+                          mkLazyDef(clazz, sym, List(Apply(staticRef(initializer(sym)), List(gen.mkAttributedThis(clazz)))), UNIT, fieldOffset(sym))
                         else {
                           val assign = atPos(sym.pos) {
                             Assign(Select(This(sym.accessed.owner), sym.accessed) /*gen.mkAttributedRef(sym.accessed)*/ ,
                                 Apply(staticRef(initializer(sym)), gen.mkAttributedThis(clazz) :: Nil))
                           }
-                          mkLazyDef(clazz, List(assign), Select(This(clazz), sym.accessed), fieldOffset(sym))
+                          mkLazyDef(clazz, sym, List(assign), Select(This(clazz), sym.accessed), fieldOffset(sym))
                         }
                       rhs1
                     } else if (sym.getter(sym.owner).tpe.resultType.typeSymbol == UnitClass) {
@@ -855,6 +911,22 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
       stats1
     }
 
+    private def nullableFields(templ: Template) = {
+      val nullables = new mutable.HashMap[Symbol, mutable.Set[Symbol]] with mutable.MultiMap[Symbol, Symbol] {
+        override def default(key: Symbol) = mutable.Set.empty
+      }
+
+      // if there are no lazy fields, take the fast path and save a traversal of the whole AST
+      if (templ.symbol.owner.info.decls.exists(_.hasFlag(LAZY))) {
+        // check what fields can be nulled for
+        val uses = singleUseFields(templ)
+        for ((field, users) <- uses; lazyFld <- users) {
+          nullables.addBinding(lazyFld, field)
+        }
+      }
+      nullables
+    }
+
     /** The transform that gets applied to a tree after it has been completely
      *  traversed and possible modified by a preTransform.
      *  This step will
@@ -884,6 +956,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
           // change parents of templates to conform to parents in the symbol info
           val parents1 = currentOwner.info.parents map (t => TypeTree(t) setPos tree.pos)
 
+          lazyValNullables = nullableFields(tree.asInstanceOf[Template])
           // add all new definitions to current class or interface
           val body1 = addNewDefs(currentOwner, body)
 

test/files/run/lazy-leaks.scala

@@ -0,0 +1,18 @@
+class Lazy(f: => Int) {
+     lazy val get: Int = f
+}
+
+object Test extends Application
+{
+     val buffer = new scala.collection.mutable.ListBuffer[Lazy]
+
+     // This test requires 4 Mb of RAM if Lazy is discarding thunks
+     // It consumes 4 Gb of RAM if Lazy is not discarding thunks
+
+     for (val idx <- Iterator.range(0, 1024)) {
+         val data = new Array[Int](1024*1024)
+         val lz: Lazy = new Lazy(data.length)
+         buffer += lz
+         lz.get
+     }
+}