Scala 宏和 JVM 的方法大小限制

java jvm scala macros scala-macros

2022-09-01 07:02:13

我正在用 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

我有一个解决方案，涉及将事例拆分为固定大小的组，为每个组创建一个单独的方法，并添加一个顶级匹配项，将输入值调度到相应组的方法。它可以工作，但它令人不快，我宁愿每次编写宏时都不必使用此方法，其中生成的代码的大小取决于某些外部资源。

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

答案 1

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

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

答案 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
  }
}