使用 JMH 做 Kotlin 的基准测试

一. 基准测试

基准测试是指通过设计科学的测试方法、测试工具和测试系统，实现对一类测试对象的某项性能指标进行定量的和可对比的测试。

基准测试是一种测量和评估软件性能指标的活动。你可以在某个时候通过基准测试建立一个已知的性能水平（称为基准线），当系统的软硬件环境发生变化之后再进行一次基准测试以确定那些变化对性能的影响。

二. JMH

JMH(Java Microbenchmark Harness) 是专门用于进行代码的微基准测试的一套工具API，也支持基于JVM的语言例如 Scala、Groovy、Kotlin。它是由 OpenJDK/Oracle 里面那群开发了 Java 编译器的大牛们所开发的工具。

三. 举例

首先，在 build.gradle 中添加 JMH 所需的依赖

1. plugins {

2.    id 'java'

3.    id 'org.jetbrains.kotlin.jvm' version '1.3.10'

4.    id "org.jetbrains.kotlin.kapt" version "1.3.10"

5. }

6. 
   

7. ...

8. 
   

9. dependencies {

10.    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8"

11.    compile "org.jetbrains.kotlin:kotlin-reflect:1.3.10"

12.    testCompile group: 'junit', name: 'junit', version: '4.12'

13. 
    

14.    compile "org.openjdk.jmh:jmh-core:1.21"

15.    kapt "org.openjdk.jmh:jmh-generator-annprocess:1.21"

16.    ......

17. }

3.1 对比 Sequence 和 List

在 Kotlin 1.2.70 的 release note 上曾说明：

使用 Sequence 有助于避免不必要的临时分配开销，并且可以显着提高复杂处理 PipeLines 的性能。

所以，有必要下面编写一个例子来证实这个说法：

1. import org.openjdk.jmh.annotations.*

2. import org.openjdk.jmh.results.format.ResultFormatType

3. import org.openjdk.jmh.runner.Runner

4. import org.openjdk.jmh.runner.options.OptionsBuilder

5. import java.util.concurrent.TimeUnit

6. 
   

7. /**

8. * Created by tony on 2018-12-10.

9. */

10. @BenchmarkMode(Mode.Throughput) // 基准测试的模式，采用整体吞吐量的模式

11. @Warmup(iterations = 3) // 预热次数

12. @Measurement(iterations = 10, time = 5, timeUnit = TimeUnit.SECONDS) // 测试参数，iterations = 10 表示进行10轮测试

13. @Threads(8) // 每个进程中的测试线程数

14. @Fork(2)  // 进行 fork 的次数，表示 JMH 会 fork 出两个进程来进行测试

15. @OutputTimeUnit(TimeUnit.MILLISECONDS) // 基准测试结果的时间类型

16. open class SequenceBenchmark {

17. 
    

18.    @Benchmark

19.    fun testSequence():Int {

20. 
    

21.        return sequenceOf(1,2,3,4,5,6,7,8,9,10)

22.                .map{ it * 2 }

23.                .filter { it % 3  == 0 }

24.                .map{ it+1 }

25.                .sum()

26.    }

27. 
    

28.    @Benchmark

29.    fun testList():Int {

30. 
    

31.        return listOf(1,2,3,4,5,6,7,8,9,10)

32.                .map{ it * 2 }

33.                .filter { it % 3  == 0 }

34.                .map{ it+1 }

35.                .sum()

36.    }

37. }

38. 
    

39. fun main() {

40. 
    

41.    val options = OptionsBuilder()

42.            .include(SequenceBenchmark::class.java.simpleName)

43.            .output("benchmark_sequence.log")

44.            .build()

45.    Runner(options).run()

46. }

在运行上述代码之前，需要先执行 ./gradlew build

然后，再运行main函数，得到如下的结果。

1. # Run complete. Total time: 00:05:23

2. 
   

3. REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on

4. why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial

5. experiments, perform baseline and negative tests that provide experimental control, make sure

6. the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.

7. Do not assume the numbers tell you what you want them to tell.

8. 
   

9. Benchmark                        Mode  Cnt      Score     Error   Units

10. SequenceBenchmark.testList      thrpt   20  15924.272 ± 305.825  ops/ms

11. SequenceBenchmark.testSequence  thrpt   20  23099.938 ± 515.524  ops/ms

果然，经过多次链式调用时 Sequence 比起 List 具有更高的效率。

如果把结果导出成json格式，还可以借助 jmh 相关的 gradle 插件生成可视化的报告。

1. fun main() {

2. 
   

3.    val options = OptionsBuilder()

4.            .include(SequenceBenchmark::class.java.simpleName)

5.            .resultFormat(ResultFormatType.JSON)

6.            .result("benchmark_sequence.json")

7.            .output("benchmark_sequence.log")

8.            .build()

9.    Runner(options).run()

10. }

需要依赖到这个插件：https://github.com/jzillmann/gradle-jmh-report

借助 gradle-jmh-report 生成如下的报告：

3.2 内联函数和非内联函数

Kotlin 的内联函数从编译器角度将函数的函数体复制到调用处实现内联，减少了使用高阶函数带来的隐性成本。

尝试编写一个例子：

1. @BenchmarkMode(Mode.Throughput) // 基准测试的模式，采用整体吞吐量的模式

2. @Warmup(iterations = 3) // 预热次数

3. @Measurement(iterations = 10, time = 5, timeUnit = TimeUnit.SECONDS) // 测试参数，iterations = 10 表示进行10轮测试

4. @Threads(8) // 每个进程中的测试线程数

5. @Fork(2)  // 进行 fork 的次数，表示 JMH 会 fork 出两个进程来进行测试

6. @OutputTimeUnit(TimeUnit.MILLISECONDS) // 基准测试结果的时间类型

7. open class InlineBenchmark {

8. 
   

9.    fun nonInlined(block: () -> Unit) { // 不用内联的函数

10.        block()

11.    }

12. 
    

13.    inline fun inlined(block: () -> Unit) { // 使用内联的函数

14.        block()

15.    }

16. 
    

17.    @Benchmark

18.    fun testNonInlined() {

19. 
    

20.        nonInlined {

21.            println("")

22.        }

23.    }

24. 
    

25.    @Benchmark

26.    fun testInlined() {

27. 
    

28.        inlined {

29.            println("")

30.        }

31.    }

32. 
    

33. }

得到如下的结果。

1. # Run complete. Total time: 00:05:23

2. 
   

3. REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on

4. why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial

5. experiments, perform baseline and negative tests that provide experimental control, make sure

6. the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.

7. Do not assume the numbers tell you what you want them to tell.

8. 
   

9. Benchmark                        Mode  Cnt   Score   Error   Units

10. InlineBenchmark.testInlined     thrpt   20  95.866 ± 4.085  ops/ms

11. InlineBenchmark.testNonInlined  thrpt   20  92.736 ± 3.085  ops/ms

果然，内联更高效一些。

3.3 协程和RxJava

自从 Kotlin 有协程这个功能之后，经常会有人提起协程和RxJava的比对。

于是，我也尝试编写一个例子，此例子使用的 Kotlin 1.3.10 ，协程的版本1.0.1，RxJava 2.2.4

1. @BenchmarkMode(Mode.Throughput) // 基准测试的模式，采用整体吞吐量的模式

2. @Warmup(iterations = 3) // 预热次数

3. @Measurement(iterations = 10, time = 5, timeUnit = TimeUnit.SECONDS) // 测试参数，iterations = 10 表示进行10轮测试

4. @Threads(8) // 每个进程中的测试线程数

5. @Fork(2)  // 进行 fork 的次数，表示 JMH 会 fork 出两个进程来进行测试

6. @OutputTimeUnit(TimeUnit.MILLISECONDS) // 基准测试结果的时间类型

7. @State(Scope.Thread) // 为每个线程独享

8. open class CoroutinesBenchmark {

9. 
   

10.    var counter1 = AtomicInteger()

11.    var counter2 = AtomicInteger()

12. 
    

13.    @Setup

14.    fun prepare() {

15. 
    

16.        counter1.set(0)

17.        counter2.set(0)

18.    }

19. 
    

20.    fun calculate(counter:AtomicInteger): Double {

21. 
    

22.        val result = ArrayList<Int>()

23. 
    

24.        for (i in 0 until 10_000) {

25. 
    

26.            result.add(counter.incrementAndGet())

27.        }

28. 
    

29.        return result.asSequence().filter { it % 3 ==0 }.map { it *2 + 1 }.average()

30.    }

31. 
    

32.    @Benchmark

33.    fun testCoroutines() = runBlocking {

34. 
    

35.        calculate(counter1)

36.    }

37. 
    

38.    @Benchmark

39.    fun testRxJava() = Observable.fromCallable { calculate(counter2) }.blockingFirst()

40. 
    

41. }

执行结果如下：

1. # Run complete. Total time: 00:05:23

2. 
   

3. REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on

4. why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial

5. experiments, perform baseline and negative tests that provide experimental control, make sure

6. the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.

7. Do not assume the numbers tell you what you want them to tell.

8. 
   

9. Benchmark                            Mode  Cnt   Score   Error   Units

10. CoroutinesBenchmark.testCoroutines  thrpt   20  17.719 ± 2.249  ops/ms

11. CoroutinesBenchmark.testRxJava      thrpt   20  18.151 ± 0.429  ops/ms

此基准测试采用的是 Throughput 模式，得分越高则性能越好。从得分来看，两者差距不大。（对于两者的比较，我还没有做更多的测试。）

总结

基准测试有很多典型的应用场景，例如想比较某些方法的执行时间，对比接口不同实现在相同条件下的吞吐量等等。在这些场景下，使用 JMH 都是很不错的选择。

关注【Java与Android技术栈】

更多精彩内容请关注扫码：