【问题标题】:Performance issue with logback with slf4j API使用 slf4j API 进行 logback 的性能问题
【发布时间】:2016-05-21 07:48:45
【问题描述】:

我正在使用 windows 机器来获取 logback + slf4j 的性能结果

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;

public class LogPerformanceAnalyser {
    private static final Logger LOG =
            LoggerFactory.getLogger(LogPerformanceAnalyser.class);

    public LogPerformanceAnalyser() {
        ((ch.qos.logback.classic.Logger) LOG).setLevel(Level.ERROR);
    }

    public long getTimeWithCheck() {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("This log is {} check", "with");
            }
        }
        return System.currentTimeMillis() - startTime;
    }

    public long getTimeWithoutCheck() {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            LOG.debug("This log is {} check", "without");
        }
        return System.currentTimeMillis() - startTime;
    }
}

注意 - 1.调试关闭 2. 跑10次取平均值。

性能结果是:

Total Time getTimeWithoutCheck: 26900 ms
Total Time getTimeWithCheck : 22536 ms

结果是,在记录之前进行检查为 217 亿条日志节省了约 3.5 秒。

如果我将 Logger 更改为非静态:

private final Logger LOG = 
        LoggerFactory.getLogger(LogPerformanceAnalyser.class);

我得到以下信息:

Total Time getTimeWithoutCheck: 37095 ms
Total Time getTimeWithCheck : 47006 ms

谁能解释一下?

【问题讨论】:

  • java JIT + 分支预测可能会成功。

标签: java performance logging


【解决方案1】:

首先,您需要正确的基准。在 Java 世界中,JMH 是基准测试的事实标准。

基准测试:

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class LogBench {
    private static final Logger LOG = LoggerFactory.getLogger(LogBench.class);

    private final Logger localLog = LoggerFactory.getLogger(LogBench.class);


    @Benchmark
    public long baseline() {
        return 0;
    }

    @Benchmark
    public void getTimeWithCheck() {
        if (LOG.isTraceEnabled()) {
            LOG.trace("This log is {} check", "with");
        }
    }

    @Benchmark
    public void getTimeWithoutCheck() {
        LOG.trace("This log is {} check", "without");
    }

    @Benchmark
    public void getTimeWithCheckBenchLocal() {
        if (localLog.isTraceEnabled()) {
            localLog.trace("This log is {} check", "with");
        }
    }

    @Benchmark
    public void getTimeWithoutCheckLocal() {
        localLog.trace("This log is {} check", "without");
    }
}

我将调试更改为跟踪以避免强制转换的可能影响。

结果

    Benchmark                                     Mode   Samples        Score  Score error    Units
    o.o.j.s.LogBench.baseline                     avgt         3        0.539        0.047    ns/op
    o.o.j.s.LogBench.getTimeWithCheck             avgt         3        1.030        0.083    ns/op
    o.o.j.s.LogBench.getTimeWithCheckLocal        avgt         3        1.637        0.571    ns/op
    o.o.j.s.LogBench.getTimeWithoutCheck          avgt         3        1.140        0.112    ns/op
    o.o.j.s.LogBench.getTimeWithoutCheckLocal     avgt         3        1.628        0.311    ns/op

可以看到,这里条件检查没用,但是静态版本比本地快1.6倍。让我们开始探索getTimeWithCheckLocal和getTimeWithCheck的区别。

静态 LOG 程序集

Beginning of getTimeWithCheck:
[Verified Entry Point]
  0x00007f06b920b440: mov    DWORD PTR [rsp-0x14000],eax
  0x00007f06b920b447: push   rbp
  0x00007f06b920b448: sub    rsp,0x20           ;*synchronization entry
                                            ; - org.openjdk.jmh.samples.LogBench::getTimeWithoutCheck@-1 (line 65)

execution:
  0x00007f06b920b44c: movabs r10,0x76d8bdfd0    ;   {oop(a 'ch/qos/logback/classic/Logger')}
  0x00007f06b920b456: mov    r11d,DWORD PTR [r10+0x28] ;*getfield loggerContext
  0x00007f06b920b45a: mov    r9d,DWORD PTR [r12+r11*8+0x60]  ;*getfield turboFilterList
  0x00007f06b920b45f: mov    r8d,DWORD PTR [r12+r9*8+0x10] ;*getfield array
...     

非静态 LOG 程序集

[Verified Entry Point]
  0x00007f1c592111e0: mov    DWORD PTR [rsp-0x14000],eax
  0x00007f1c592111e7: push   rbp
  0x00007f1c592111e8: sub    rsp,0x30           ;*synchronization entry
                                            ; - org.openjdk.jmh.samples.LogBench::getTimeWithoutCheckLocal@-1 (line 77)

  0x00007f1c592111ec: mov    r11d,DWORD PTR [rsi+0xc]  ;*getfield localLog
  0x00007f1c592111f0: mov    r10d,DWORD PTR [r12+r11*8+0x8] ; implicit exception: dispatches to 0x00007f1c59211281
  0x00007f1c592111f5: cmp    r10d,0xf80154ad    ;   {metadata('ch/qos/logback/classic/Logger')}
  0x00007f1c592111fc: jne    0x00007f1c5921123c

execution:
  0x00007f1c592111fe: lea    r8,[r12+r11*8]     ;*invokeinterface debug
  0x00007f1c59211202: mov    ecx,DWORD PTR [r8+0x28]  ;*getfield loggerContext                                                                                     

您可以注意到,在第二个实验中,JIT 必须执行额外的 Logger 字段值加载:lea r9,[r12+r10*8]。

让我们用 perfasm profiler 再次运行基准测试

0.04%    0.04%  │↗  0x00007f6c25229320: mov    r10d,DWORD PTR [r8+0xc]  ;*getfield localLog
                ││                                                ; - org.openjdk.jmh.samples.LogBench::getTimeWithoutCheckLocal@1 (line 77)
                ││                                                ; - org.openjdk.jmh.samples.generated.LogBench_getTimeWithoutCheckLocal_jmhTest::getTimeWithoutCheckLocal_avgt_jmhStub@14 (line 163)
6.80%    7.29%  ││  0x00007f6c25229324: mov    r11d,DWORD PTR [r12+r10*8+0x8]
                ││                                                ; implicit exception: dispatches to 0x00007f6c252294a5
         0.02%  ││  0x00007f6c25229329: cmp    r11d,0xf80197b1    ;   {metadata(&apos;ch/qos/logback/classic/Logger&apos;)}
                ││  0x00007f6c25229330: jne    0x00007f6c2522939b
                ││  0x00007f6c25229332: lea    r9,[r12+r10*8]     ;*invokeinterface debug
                ││  0x00007f6c25229336: mov    ecx,DWORD PTR [r9+0x28]  ;*getfield loggerContext

正如您所见,这种额外的加载并不是免费的。这是因为存在很多改变最终变量的方法,所以对字段进行这种优化是不安全的。

由于实验功能 jvm 有一个特殊的选项-XX:+TrustFinalNonStaticFields,它必须与-XX:+UnlockExperimentalVMOptions 一起使用。如果您使用此选项运行基准测试,您将看到另一个结果:

Benchmark                            Mode  Cnt  Score   Error  Units
LogBench.baseline                    avgt    3  2.124 ± 0.907  ns/op
LogBench.getTimeWithCheck            avgt    3  0.695 ± 0.231  ns/op
LogBench.getTimeWithCheckBenchLocal  avgt    3  1.608 ± 0.140  ns/op
LogBench.getTimeWithoutCheck         avgt    3  0.675 ± 0.075  ns/op
LogBench.getTimeWithoutCheckLocal    avgt    3  1.613 ± 0.176  ns/op

结果很奇怪,虽然现在没有额外加载局部变量,内联被破坏了,asm代码包含直接调用:

0x00007f2355205d33: call   0x00007f2355046020  ; OopMap{off=120}
                                            ;*invokespecial filterAndLog_1

结论

  • JVM 不能信任 final 字段,因此每次在基准测试中它都必须从内存中加载它(但在 99.999999% 的应用程序中不会出现问题)
  • JVM 有 experimental option TrustFinalNonStaticFields 这似乎很不稳定,因为它破坏了 CHA 优化

【讨论】:

  • 分析不错,但结论错误。所有这些都与空检查无关。非静态版本只需要执行额外的字段加载。
  • @apangin,哦,我觉得有点奇怪。但我仍然有疑问,为cmp 加载mov r10d,DWORD PTR [r8+0xc] 似乎比加载字段r11d,DWORD PTR [rsi+0xc] 慢得多,不是吗?
  • @apangin,哦,明白了。你是对的,仍然想知道为什么它不在 r11 中进一步使用 Logger 指针
  • 它不能,因为基准循环包含一个作为屏障的易失负载。因此每次基准迭代都会加载localLog 字段并一次又一次地检查其类型。
  • @SerCe,感谢您的努力,但结果不同。你能看看我的答案吗?
【解决方案2】:

结果或多或少与字段访问占总运行时间 10000 毫秒的假设一致。没有检查,你有一次这个开销,有检查你有两次。

差别如此之大还是让人吃惊。

【讨论】:

  • 建议不要使用静态记录器。 wiki.apache.org/commons/Logging/StaticLog slf4j.org/faq.html#declared_static slf4j.org/faq.html#logging_performance 所以我尝试了同样的方法,但我很困惑我应该在 log.debug 之前使用 if(Log.isDebugEnabled)。
  • 在大多数情况下,您不需要这个额外的检查。仅当您同时保护多个日志语句或参数表达式的计算成本很高时才有用。
  • @Ravi "we" 不应该使用静态日志引用,如果一个白痴刚刚在我们上方的层次结构中添加了日志记录,因此初始化发生在我们的代码之前。
猜你喜欢
  • 2016-11-02
  • 1970-01-01
  • 1970-01-01
  • 2019-05-04
  • 2017-05-06
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多