Add an LF typechecking benchmark (#11276)

changelog_begin
changelog_end

daml-lf/validation/BUILD.bazel

@@ -3,6 +3,7 @@
 
 load(
     "//bazel_tools:scala.bzl",
+    "da_scala_benchmark_jmh",
     "da_scala_library",
     "da_scala_test",
     "lf_scalacopts",
@@ -53,3 +54,29 @@ da_scala_test(
         "//daml-lf/parser",
     ],
 )
+
+da_scala_benchmark_jmh(
+    name = "typechecking-benchmark",
+    srcs = glob(["src/bench/**/*.scala"]),
+    data = [
+        "//ledger/test-common:model-tests-1.14.dar",
+    ],
+    scala_deps = [
+        "@maven//:org_scalaz_scalaz_core",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//bazel_tools/runfiles:scala_runfiles",
+        "//daml-lf/archive:daml_lf_archive_reader",
+        "//daml-lf/archive:daml_lf_dev_archive_proto_java",
+        "//daml-lf/data",
+        "//daml-lf/engine",
+        "//daml-lf/interpreter",
+        "//daml-lf/language",
+        "//daml-lf/scenario-interpreter",
+        "//daml-lf/transaction",
+        "//daml-lf/validation",
+        "//ledger/test-common:dar-files-default-lib",
+        "@maven//:com_google_protobuf_protobuf_java",
+    ],
+)

daml-lf/validation/src/bench/com/daml/lf/validation/TypecheckingBench.scala

@@ -0,0 +1,66 @@
+// Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.daml.lf
+package validation
+
+import com.daml.lf.data.Ref.{ModuleName, PackageId}
+import com.daml.lf.archive._
+import com.daml.lf.language.Ast._
+import com.daml.lf.language.PackageInterface
+import com.daml.bazeltools.BazelRunfiles.rlocation
+import com.daml.ledger.test.ModelTestDar
+import com.daml.lf.archive.DarDecoder
+import java.io.File
+import org.openjdk.jmh.annotations._
+
+@State(Scope.Benchmark)
+class TypecheckingBench {
+
+  @Param(Array(""))
+  var darPath: String = _
+
+  @Param(Array(""))
+  var moduleName: String = _
+
+  private var dar: Dar[(PackageId, Package)] = _
+  private var darMap: Map[PackageId, Package] = _
+  private var interface: PackageInterface = _
+  private var module: Option[(PackageId, Module)] = None
+
+  @Setup(Level.Trial)
+  def setup(): Unit = {
+    val darFile = new File(
+      if (darPath.isEmpty)
+        rlocation(ModelTestDar.path)
+      else darPath
+    )
+    dar = DarDecoder.assertReadArchiveFromFile(darFile)
+    darMap = dar.all.toMap
+    interface = PackageInterface(darMap)
+
+    if (!moduleName.isEmpty) {
+      dar.all.foreach { case (pkgId, pkg) =>
+        pkg.modules.foreach { case (name, m) =>
+          if (name == ModuleName.assertFromString(moduleName)) {
+            module = Some((pkgId, m))
+          }
+        }
+      }
+      if (module.isEmpty) {
+        sys.error(s"Module name $moduleName could not be found in DAR")
+      }
+    }
+  }
+
+  @Benchmark
+  def bench(): Unit = {
+    val r = module match {
+      case Some((pkgId, m)) =>
+        Validation.checkModule(interface, pkgId, m)
+      case None =>
+        Validation.checkPackages(interface, darMap)
+    }
+    assert(r.isRight)
+  }
+}

daml-lf/validation/src/main/scala/com/digitalasset/daml/lf/validation/Validation.scala

@@ -20,9 +20,21 @@ object Validation {
   def checkPackages(pkgs: Map[PackageId, Package]): Either[ValidationError, Unit] =
     runSafely {
       val interface = PackageInterface(pkgs)
-      pkgs.foreach { case (pkgId, pkg) => unsafeCheckPackage(interface, pkgId, pkg) }
+      unsafeCheckPackages(interface, pkgs)
     }
 
+  private[lf] def checkPackages(
+      interface: PackageInterface,
+      pkgs: Map[PackageId, Package],
+  ): Either[ValidationError, Unit] =
+    runSafely(unsafeCheckPackages(interface, pkgs))
+
+  private[lf] def unsafeCheckPackages(
+      interface: PackageInterface,
+      pkgs: Map[PackageId, Package],
+  ): Unit =
+    pkgs.foreach { case (pkgId, pkg) => unsafeCheckPackage(interface, pkgId, pkg) }
+
   def checkPackage(
       interface: PackageInterface,
       pkgId: PackageId,