Question

我正在使用Scala宏替换Java程序中的一些代码生成组件，并且遇到了Java虚拟机对单个方法（64 KB）生成的字节代码大小的限制。

例如，假设我们有一个大型XML文件，它表示我们要在程序中使用的从整数到整数的映射。我们希望避免在运行时解析此文件，因此我们将编写一个宏，它将在编译时进行解析并使用该文件的内容来创建方法的主体：

import scala.language.experimental.macros
import scala.reflect.macros.Context

object BigMethod {
  // For this simplified example we'll just make some data up.
  val mapping = List.tabulate(7000)(i => (i, i + 1))

  def lookup(i: Int): Int = macro lookup_impl
  def lookup_impl(c: Context)(i: c.Expr[Int]): c.Expr[Int] = {
    import c.universe._

    val switch = reify(new scala.annotation.switch).tree
    val cases = mapping map {
      case (k, v) => CaseDef(c.literal(k).tree, EmptyTree, c.literal(v).tree)
    }

    c.Expr(Match(Annotated(switch, i.tree), cases))
  }
}

在这种情况下，编译后的方法只是超出了大小限制，但是没有一个很好的错误说，我们给了一个巨大的堆栈跟踪，有大量的TreePrinter.printSeq调用，并被告知我们已经杀了编译器。

我有a solution涉及将案例拆分为固定大小的组，为每个组创建单独的方法，并添加一个顶级匹配，将输入值调度到适当的组方法。它有效，但它很不愉快，而且每次我编写一个宏时，我都不希望使用这种方法，其中生成的代码的大小取决于某些外部资源。

有没有更清洁的方法来解决这个问题？更重要的是，有没有办法更优雅地处理这种编译器错误？我不喜欢库用户得到一个难以理解的“该条目似乎已经杀死了编译器”错误消息的想法，因为一些宏处理的XML文件已超过一些（相当低的）大小阈值。

Answer 1

Imo将数据放入.class并不是一个好主意。它们也被解析，它们只是二进制的。但是将它们存储在JVM中可能会对garbagge收集器和JIT编译器的性能产生负面影响。

在您的情况下，我会将XML预编译为适当格式的二进制文件并解析它。使用现有工具的可格式格式可以是例如。 FastRPC或旧的DBF。或者，如果您需要快速高级查找和搜索，可以预先填充ElasticSearch存储库。后者的一些实现也可能提供基本的索引，甚至可以解析 - 应用程序只会读取相应的偏移量。

Answer 2

由于有人要说些什么，我按照Importers的说明尝试编译树，然后再返回。

如果给编译器足够的堆栈，它将正确报告错误。

（它似乎不知道如何处理切换注释，留作未来的练习。）

apm@mara:~/tmp/bigmethod$ skalac bigmethod.scala ; skalac -J-Xss2m biguser.scala ; skala bigmethod.Test
Error is java.lang.RuntimeException: Method code too large!
Error is java.lang.RuntimeException: Method code too large!
biguser.scala:5: error: You ask too much of me.
  Console println s"5 => ${BigMethod.lookup(5)}"
                                           ^
one error found

而不是

apm@mara:~/tmp/bigmethod$ skalac -J-Xss1m biguser.scala 
Error is java.lang.StackOverflowError
Error is java.lang.StackOverflowError
biguser.scala:5: error: You ask too much of me.
  Console println s"5 => ${BigMethod.lookup(5)}"
                                           ^

客户端代码只是：

package bigmethod

object Test extends App {
  Console println s"5 => ${BigMethod.lookup(5)}"
}

我第一次使用这个API，但不是我的最后一次。谢谢你让我开始。

package bigmethod

import scala.language.experimental.macros
import scala.reflect.macros.Context

object BigMethod {
  // For this simplified example we'll just make some data up.
  //final val size = 700
  final val size = 7000
  val mapping = List.tabulate(size)(i => (i, i + 1))

  def lookup(i: Int): Int = macro lookup_impl
  def lookup_impl(c: Context)(i: c.Expr[Int]): c.Expr[Int] = {

    def compilable[T](x: c.Expr[T]): Boolean = {
      import scala.reflect.runtime.{ universe => ru }
      import scala.tools.reflect._
      //val mirror = ru.runtimeMirror(c.libraryClassLoader)
      val mirror = ru.runtimeMirror(getClass.getClassLoader)
      val toolbox = mirror.mkToolBox()
      val importer0 = ru.mkImporter(c.universe)
      type ruImporter = ru.Importer { val from: c.universe.type }
      val importer = importer0.asInstanceOf[ruImporter]
      val imported = importer.importTree(x.tree)
      val tree = toolbox.resetAllAttrs(imported.duplicate)
      try {
        toolbox.compile(tree)
        true
      } catch {
        case t: Throwable =>
          Console println s"Error is $t"
          false
      }
    }
    import c.universe._

    val switch = reify(new scala.annotation.switch).tree
    val cases = mapping map {
      case (k, v) => CaseDef(c.literal(k).tree, EmptyTree, c.literal(v).tree)
    }

    //val res = c.Expr(Match(Annotated(switch, i.tree), cases))
    val res = c.Expr(Match(i.tree, cases))

    // before returning a potentially huge tree, try compiling it
    //import scala.tools.reflect._
    //val x = c.Expr[Int](c.resetAllAttrs(res.tree.duplicate))
    //val y = c.eval(x)
    if (!compilable(res)) c.abort(c.enclosingPosition, "You ask too much of me.")

    res
  }
}

Scala宏和JVM的方法大小限制

2 个答案: