使用 Circe Json 为什么隐式解析在运行时较慢
With Circe Json why is implicit resolution slower at runtime
为什么 Circe Json 使用隐式解码器查找比将隐式解码器保存到 val 更慢。
我希望它们是相同的,因为隐式解析是在运行时完成的。
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
完整的回购可以在这里找到。
https://github.com/stephennancekivell/some-jmh-json-benchmarks-circe-jackson
考虑这个更简单的案例,它根本不涉及 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
的情况下它发生一次,而在隐式解析的情况下它每次发生 [=19] =] 被调用。
所以您看到的区别只是在每个操作中实例化 Decoder
实例的成本,而不是在基准测试代码之外的开头实例化它一次。这个成本相对较小,对于更大的基准测试来说,它会更难看到。
为什么 Circe Json 使用隐式解码器查找比将隐式解码器保存到 val 更慢。
我希望它们是相同的,因为隐式解析是在运行时完成的。
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
完整的回购可以在这里找到。 https://github.com/stephennancekivell/some-jmh-json-benchmarks-circe-jackson
考虑这个更简单的案例,它根本不涉及 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
的情况下它发生一次,而在隐式解析的情况下它每次发生 [=19] =] 被调用。
所以您看到的区别只是在每个操作中实例化 Decoder
实例的成本,而不是在基准测试代码之外的开头实例化它一次。这个成本相对较小,对于更大的基准测试来说,它会更难看到。