为什么返回 Java 对象引用比返回基元慢得多

2022-08-31 13:09:00

我们正在开发一个对延迟敏感的应用程序,并且一直在微模板标记各种方法(使用jmh)。在微基准标记了查找方法并对结果感到满意之后,我实现了最终版本,结果发现最终版本比我刚刚基准测试的版本慢3倍

罪魁祸首是实现的方法返回对象而不是 .以下是基准测试代码的简化版本:enumint

@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Thread)
public class ReturnEnumObjectVersusPrimitiveBenchmark {

    enum Category {
        CATEGORY1,
        CATEGORY2,
    }

    @Param( {"3", "2", "1" })
    String value;

    int param;

    @Setup
    public void setUp() {
        param = Integer.parseInt(value);
    }

    @Benchmark
    public int benchmarkReturnOrdinal() {
        if (param < 2) {
            return Category.CATEGORY1.ordinal();
        }
        return Category.CATEGORY2.ordinal();        
    }


    @Benchmark
    public Category benchmarkReturnReference() {
        if (param < 2) {
            return Category.CATEGORY1;
        }
        return Category.CATEGORY2;      
    }


    public static void main(String[] args) throws RunnerException {
            Options opt = new OptionsBuilder().include(ReturnEnumObjectVersusPrimitiveBenchmark.class.getName()).warmupIterations(5)
                .measurementIterations(4).forks(1).build();
        new Runner(opt).run();
    }

}

上述基准测试结果:

# VM invoker: C:\Program Files\Java\jdk1.7.0_40\jre\bin\java.exe
# VM options: -Dfile.encoding=UTF-8

Benchmark                   (value)   Mode  Samples     Score     Error   Units
benchmarkReturnOrdinal            3  thrpt        4  1059.898 ±  71.749  ops/us
benchmarkReturnOrdinal            2  thrpt        4  1051.122 ±  61.238  ops/us
benchmarkReturnOrdinal            1  thrpt        4  1064.067 ±  90.057  ops/us
benchmarkReturnReference          3  thrpt        4   353.197 ±  25.946  ops/us
benchmarkReturnReference          2  thrpt        4   350.902 ±  19.487  ops/us
benchmarkReturnReference          1  thrpt        4   339.578 ± 144.093  ops/us

仅更改函数的返回类型,性能就将近 3 倍。

我认为返回枚举对象与整数之间的唯一区别是,一个返回64位值(引用),另一个返回32位值。我的一位同事猜测,返回枚举会增加额外的开销,因为需要跟踪潜在 GC 的参考。(但考虑到枚举对象是静态的最终引用,它需要这样做似乎很奇怪)。

性能差异的解释是什么?


更新

我在这里分享了maven项目,以便任何人都可以克隆它并运行基准测试。如果有人有时间/兴趣,看看其他人是否可以复制相同的结果将是有帮助的。(我已经在2台不同的机器上复制了Windows 64和Linux 64,两者都使用Oracle Java 1.7 JVM)。@ZhekaKozlov说,他没有看到这些方法之间的任何区别。

运行:(克隆存储库后)

mvn clean install
java -jar .\target\microbenchmarks.jar function.ReturnEnumObjectVersusPrimitiveBenchmark -i 5 -wi 5 -f 1

答案 1

TL;DR:你不应该盲目信任任何事情。

首先:在从中得出结论之前,验证实验数据很重要。仅仅声称某物的速度快/慢3倍是奇怪的,因为你真的需要跟进性能差异的原因,而不仅仅是信任数字。这对于像您这样的纳米基准尤其重要。

其次,实验者应该清楚地了解他们控制什么,不控制什么。在您的特定示例中,您正在从方法返回值,但是您能否合理地确定外部调用方将对基元和引用执行相同的操作?如果你问自己这个问题,那么你就会意识到你基本上是在测量测试基础设施。@Benchmark

直截了当。在我的机器(i5-4210U,Linux x86_64,JDK 8u40)上,测试结果如下:

Benchmark                    (value)   Mode  Samples  Score   Error   Units
...benchmarkReturnOrdinal          3  thrpt        5  0.876 ± 0.023  ops/ns
...benchmarkReturnOrdinal          2  thrpt        5  0.876 ± 0.009  ops/ns
...benchmarkReturnOrdinal          1  thrpt        5  0.832 ± 0.048  ops/ns
...benchmarkReturnReference        3  thrpt        5  0.292 ± 0.006  ops/ns
...benchmarkReturnReference        2  thrpt        5  0.286 ± 0.024  ops/ns
...benchmarkReturnReference        1  thrpt        5  0.293 ± 0.008  ops/ns

好的,所以参考测试看起来慢了3倍。但是等等,它使用旧的JMH(1.1.1),让我们更新到当前的最新(1.7.1):

Benchmark                    (value)   Mode  Cnt  Score   Error   Units
...benchmarkReturnOrdinal          3  thrpt    5  0.326 ± 0.010  ops/ns
...benchmarkReturnOrdinal          2  thrpt    5  0.329 ± 0.004  ops/ns
...benchmarkReturnOrdinal          1  thrpt    5  0.329 ± 0.004  ops/ns
...benchmarkReturnReference        3  thrpt    5  0.288 ± 0.005  ops/ns
...benchmarkReturnReference        2  thrpt    5  0.288 ± 0.005  ops/ns
...benchmarkReturnReference        1  thrpt    5  0.288 ± 0.002  ops/ns

哎呀,现在它们只是慢了一点。顺便说一句,这也告诉我们测试是基础设施绑定的。好吧,我们能看到到底发生了什么吗?

如果你构建了基准测试,并环顾了一下究竟是什么调用了你的方法,那么你会看到如下内容:@Benchmark

public void benchmarkReturnOrdinal_thrpt_jmhStub(InfraControl control, RawResults result, ReturnEnumObjectVersusPrimitiveBenchmark_jmh l_returnenumobjectversusprimitivebenchmark0_0, Blackhole_jmh l_blackhole1_1) throws Throwable {
    long operations = 0;
    long realTime = 0;
    result.startTime = System.nanoTime();
    do {
        l_blackhole1_1.consume(l_longname.benchmarkReturnOrdinal());
        operations++;
    } while(!control.isDone);
    result.stopTime = System.nanoTime();
    result.realTime = realTime;
    result.measuredOps = operations;
}

它有一个方法,它“消耗”值(有关基本原理,请参见)。 具有引用基元的重载,仅此一点就足以证明性能差异的合理性。l_blackhole1_1consumeBlackholeBlackhole.consume

这些方法看起来不同是有原因的:它们试图尽可能快地进行论证类型。即使我们尝试匹配它们,它们也不一定表现出相同的性能特征,因此较新的JMH的结果更加对称。现在,您甚至可以转到查看为测试生成的代码,并了解为什么性能不同,但这超出了此处的范围。-prof perfasm

如果您真的了解返回基元和/或引用在性能方面有何不同,则需要进入一个细微差别的性能基准测试的可怕灰色地带。例如,像这样的测试:

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(5)
public class PrimVsRef {

    @Benchmark
    public void prim() {
        doPrim();
    }

    @Benchmark
    public void ref() {
        doRef();
    }

    @CompilerControl(CompilerControl.Mode.DONT_INLINE)
    private int doPrim() {
        return 42;
    }

    @CompilerControl(CompilerControl.Mode.DONT_INLINE)
    private Object doRef() {
        return this;
    }

}

...这对基元和引用产生相同的结果:

Benchmark       Mode  Cnt  Score   Error  Units
PrimVsRef.prim  avgt   25  2.637 ± 0.017  ns/op
PrimVsRef.ref   avgt   25  2.634 ± 0.005  ns/op

正如我上面所说,这些测试需要跟进结果的原因。在这种情况下,为两者生成的代码几乎相同,这解释了结果。

拘谨:

                  [Verified Entry Point]
 12.69%    1.81%    0x00007f5724aec100: mov    %eax,-0x14000(%rsp)
  0.90%    0.74%    0x00007f5724aec107: push   %rbp
  0.01%    0.01%    0x00007f5724aec108: sub    $0x30,%rsp         
 12.23%   16.00%    0x00007f5724aec10c: mov    $0x2a,%eax   ; load "42"
  0.95%    0.97%    0x00007f5724aec111: add    $0x30,%rsp
           0.02%    0x00007f5724aec115: pop    %rbp
 37.94%   54.70%    0x00007f5724aec116: test   %eax,0x10d1aee4(%rip)        
  0.04%    0.02%    0x00007f5724aec11c: retq  

裁判:

                  [Verified Entry Point]
 13.52%    1.45%    0x00007f1887e66700: mov    %eax,-0x14000(%rsp)
  0.60%    0.37%    0x00007f1887e66707: push   %rbp
           0.02%    0x00007f1887e66708: sub    $0x30,%rsp         
 13.63%   16.91%    0x00007f1887e6670c: mov    %rsi,%rax     ; load "this"
  0.50%    0.49%    0x00007f1887e6670f: add    $0x30,%rsp
  0.01%             0x00007f1887e66713: pop    %rbp
 39.18%   57.65%    0x00007f1887e66714: test   %eax,0xe3e78e6(%rip)
  0.02%             0x00007f1887e6671a: retq   

[讽刺]看看它是多么容易![/讽刺]

模式是:问题越简单,你就越需要努力做出一个合理而可靠的答案。


答案 2

为了清除某些人陷入的对引用内存的误解(@Mzf),让我们深入研究Java虚拟机规范。但是在去那里之前,必须澄清一件事 - 一个对象永远不能从内存中检索,只有它的字段可以。实际上,没有操作码可以执行如此广泛的操作。

本文档将引用定义为第一类的堆栈类型(因此它可能是对堆栈执行操作的指令的结果或参数) - 采用单个堆栈字(32位)的类型类别。见表2.3A list of Java Stack Types

此外,如果方法调用根据规范正常完成,则从堆栈顶部弹出的值将推送到方法调用程序堆栈上(第 2.6.4 节)。

你的问题是导致执行时间差异的原因。第2章前言答案:

不属于 Java 虚拟机规范的实现细节将不必要地限制实现者的创造力。例如,运行时数据区域的内存布局、使用的垃圾回收算法以及 Java 虚拟机指令的任何内部优化(例如,将它们转换为机器代码)都由实现者自行决定。

换句话说,由于逻辑原因,文档中没有说明有关引用使用的执行惩罚这样的事情(它最终只是一个堆栈单词,或者是),所以你只能搜索实现的源代码,或者根本没有发现。intfloat

在某种程度上,我们实际上不应该总是责怪实现,在寻找答案时,你可以采取一些线索。Java 定义了用于操作数字和引用的单独指令。引用操作指令以 (例如 、 或 ) 开头,是允许与引用一起使用的唯一指令。特别是,您可能有兴趣查看 的实现。aastorealoadareturnareturn


推荐