json - 使用 Circe Json 为什么隐式解析在运行时变慢

Question

与将隐式解码器保存到 val 相比，为什么使用隐式解码器查找的 Circe Json 更慢。

我希望这些是相同的，因为隐式解析是在运行时完成的。

import io.circe._
import io.circe.generic.auto._
import io.circe.jackson
import io.circe.syntax._

private val decoder = implicitly[Decoder[Data.Type]]
def decode(): Either[Error, Type] = {
  jackson.decode[Data.Type](Data.json)(decoder)
}

def decodeAuto(): Either[Error, Type] = {
  jackson.decode[Data.Type](Data.json)
}


[info] DecodeTest.circeJackson             thrpt  200   69157.472 ± 283.285  ops/s
[info] DecodeTest.circeJacksonAuto         thrpt  200   67946.734 ± 315.876  ops/s

完整的 repo 可以在这里找到。
https://github.com/stephennancekivell/some-jmh-json-benchmarks-circe-jackson

Answer 1

考虑这个更简单的情况，它根本不涉及 circe 或泛型推导:

package demo

import org.openjdk.jmh.annotations._

@State(Scope.Thread)
@BenchmarkMode(Array(Mode.Throughput))
class OrderingBench {
  val items: List[(Char, Int)] = List('z', 'y', 'x').zipWithIndex
  val tupleOrdering: Ordering[(Char, Int)] = implicitly

  @Benchmark
  def sortWithResolved(): List[(Char, Int)] = items.sorted

  @Benchmark
  def sortWithVal(): List[(Char, Int)] = items.sorted(tupleOrdering)    
}

在我的台式机 2.11 上，我得到了这个:

Benchmark                        Mode  Cnt         Score        Error  Units
OrderingBench.sortWithResolved  thrpt   40  15940745.279 ± 102634.860  ps/s
OrderingBench.sortWithVal       thrpt   40  16420078.932 ± 102901.418  ops/s

如果您查看分配，则差异会更大一些:

Benchmark                                            Mode  Cnt    Score   Error   Units
OrderingBench.sortWithResolved:gc.alloc.rate.norm  thrpt   20  176.000 ±  0.001    B/op
OrderingBench.sortWithVal:gc.alloc.rate.norm       thrpt   20  152.000 ±  0.001    B/op

你可以通过打断 reify 来判断发生了什么:

scala> val items: List[(Char, Int)] = List('z', 'y', 'x').zipWithIndex
items: List[(Char, Int)] = List((z,0), (y,1), (x,2))

scala> import scala.reflect.runtime.universe._
import scala.reflect.runtime.universe._

scala> showCode(reify(items.sorted).tree)
res0: String = $read.items.sorted(Ordering.Tuple2(Ordering.Char, Ordering.Int))

Ordering.Tuple2这是一个实例化 Ordering[(Char, Int)] 的通用方法.这与我们定义 tupleOrdering 时发生的事情完全相同。 ，但不同的是在 val如果它发生一次，而在隐式解析的情况下它每次都会发生 sorted叫做。

所以你看到的区别只是实例化 Decoder 的成本实例在每个操作中，而不是在基准代码之外的开始时实例化它。这个成本相对较小，对于更大的基准测试，它会更难看到。