java内核_测量时间：从Java到内核再到

今天药忘吃喽~ 2023-02-25 03:59 50阅读 0赞

java内核

## 问题陈述 ##

当您深入研究时，即使是最基本的问题也会变得很有趣。 今天，我想深入研究一下Java时间。 我们将从Java API的最基础知识开始，然后逐步降低堆栈：通过OpenJDK源代码glibc一直到Linux内核。 我们将研究各种环境下的性能开销，并尝试对结果进行推理。

我们将探索经过时间的度量：从某个活动的开始事件到结束事件所经过的时间。 这对于性能改进，操作监视和超时执行很有用。

以下伪代码是我们几乎可以在任何代码库中看到的常见用法：

START_TIME = getCurrentTime()  executeAction()  ELAPSED_TIME = getCurrentTime() - START_TIME

有时它不太明确。 我们可以使用面向方面的编程原则来避免本质上与操作有关的污染我们的业务代码，但是它仍然以一种或另一种形式存在。

## Java中经过的时间 ##

Java提供了两个用于测量时间的基本原语： `System.currentTimeMillis()`和`System.nanoTime()` 。 这两个调用之间有几个区别，让我们对其进行分解。

### 1.起点的稳定性 ###

`System.currentTimeMillis()`返回自Unix纪元开始（1970年1月1日UTC）以来的毫秒数。 另一方面， `System.nanoTime()`返回自过去某个任意点以来的纳秒数。

这立即告诉我们`currentTimeMillis()`的最佳粒度为1毫秒。 它使得不可能测量任何短于1ms的东西。 `currentTimeMillis()`使用1970年1月1日UTC作为参考点的事实是好事。

为什么好呢？ 我们可以比较两个不同的JVM甚至两个不同的计算机返回的`currentTimeMillis()`值。  
为什么不好？ 当我们的计算机没有同步时间时，比较将不会很有用。 典型服务器场中的时钟未完全同步，并且始终会有一些差距。 如果我要比较两个不同系统的日志文件，这仍然可以接受：如果时间戳记未完全同步，则可以。 但是，有时这种差距可能导致灾难性的结果，例如，当将其用于分布式系统中的冲突解决时。

### 2.时钟单调性 ###

另一个问题是，不能保证返回值会单调增加。 这是什么意思？ 当您连续两次调用`currentTimeMillis()` ，第二个调用返回的值可能小于第一个。 这是违反直觉的，并且可能导致无意义的结果，例如经过时间为负数。 显然， `currentTimeMillis()`不是衡量应用程序内部经过时间的好选择。 那`nanoTime()`呢？

`System.nanoTime()`不使用Unix纪元作为参考点，而是过去的一些未指定点。 在执行一次JVM的过程中，问题仍然存在，仅此而已。 因此，甚至比较在同一台计算机上运行的两个不同JVM返回的`nanoTime()`值也毫无意义，更不用说在单独的计算机上了。 参考点通常与上一次计算机启动有关，但这纯粹是实现细节，我们根本不能依赖它。 这样做的好处是，即使计算机中的挂钟时间由于某种原因而倒退，也不会对`nanoTime()`产生任何影响。 这就是为什么`nanoTime()`是一个不错的工具，可以测量单个JVM上两个事件之间的经过时间，但是我们无法比较两个不同JVM上的时间戳。

## Java实现 ##

让我们探讨一下Java中如何实现`currentTimeMillis()`和`nanoTime()` 。 我将使用来自[OpenJDK 14][]当前[负责人的资源][OpenJDK 14] 。 `System.currentTimeMillis()`是一种[本地方法，][Link 1]因此我们的Java IDE不会告诉我们它是如何实现的。 [这个本地代码][Link 2]看起来更好一些：

JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)) 
       JVMWrapper( "JVM_CurrentTimeMillis" ); 
       return os::javaTimeMillis();  JVM_END

我们可以看到，这只是委派，因为实现因操作系统而异。 这是[Linux的实现][Linux] ：

jlong os::javaTimeMillis() { 
       timeval time; 
       int status = gettimeofday(&time, NULL); 
       assert (status != - 1 , "linux error" ); 
       return jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000 );  }

该代码委托给Posix函数[`gettimeofday()`][gettimeofday] 。 该函数返回一个简单的结构：

struct timeval { 
       time_t tv_sec; /* seconds */ 
       suseconds_t tv_usec; /* microseconds */  };

该结构包含自该纪元以来的秒数和给定秒数内的微秒数。 `currentTimeMillis()`的约定是返回自该纪元以来的毫秒数，因此它必须进行简单的转换： `jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000)`

函数`gettimeofday()`由glibc实现，它最终会调用Linux内核。 稍后我们将更深入地了解。

让我们看一下`nanoTime()`的实现方式：事实并没有太大不同– `System.nanoTime()`也是一种本地方法： `public static native long nanoTime();` 和`jvm.cpp`委托给特定于操作系统的实现：

JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored)) 
       JVMWrapper( "JVM_NanoTime" ); 
       return os::javaTimeNanos();  JVM_END

[javaTimeNanos（）][javaTimeNanos]的[Linux实现][javaTimeNanos]非常有趣：

jlong os::javaTimeNanos() { 
       if (os::supports_monotonic_clock()) { 
         struct timespec tp; 
         int status = os::Posix::clock_gettime(CLOCK_MONOTONIC, &tp); 
         assert (status == 0 , "gettime error" ); 
         jlong result = jlong(tp.tv_sec) * ( 1000 * 1000 * 1000 ) + jlong(tp.tv_nsec); 
         return result; 
       } else { 
         timeval time; 
         int status = gettimeofday(&time, NULL); 
         assert (status != - 1 , "linux error" ); 
         jlong usecs = jlong(time.tv_sec) * ( 1000 * 1000 ) + jlong(time.tv_usec); 
         return 1000 * usecs; 
       }  }

有两个分支：如果操作系统支持单调时钟，它将使用它，否则它将委托给我们的老朋友`gettimeofday()` 。 `Gettimeofday()`与Posix调用的`System.currentTimeMillis()`相同！ 显然，随着`nanoTime()`粒度更高，转换看起来有些不同，但这是相同的Posix调用！ 这意味着在某些情况下， `System.nanoTime()`使用Unix纪元作为参考，因此它可以回到过去！ 换句话说：它不能保证是单调的！

好消息是，据我所知，所有现代Linux发行版都支持单调时钟。 我认为该分支是为了与早期版本的kernel / glibc兼容。 如果您对HotSpot如何检测操作系统是否支持单调时钟的详细信息感兴趣，请参见[以下代码][Link 3] 。 对于我们大多数人来说，重要的是要知道OpenJDK实际上总是调用Posix函数`clock_gettime()` ，该函数在glibc和Linux内核的glibc委托中实现。

## 基准I –本地笔记本电脑 ##

至此，我们对如何实现`nanoTime()`和`currentTimeMillis()`有了一些直觉。 让我们看看他们是快闪还是慢速。 这是一个简单的JMH基准：

@BenchmarkMode (Mode.AverageTime)  @OutputTimeUnit (TimeUnit.NANOSECONDS)  public class Bench { 
       @Benchmark 
       public long nano() { 
         return System.nanoTime(); 
       } 
       @Benchmark 
       public long millis() { 
         return System.currentTimeMillis(); 
       }  }

当我在装有Ubuntu 19.10的笔记本电脑上运行此基准测试时，得到以下结果：

<table> 
 <tbody> 
  <tr> 
   <th> 基准测试 </th> 
   <th> 模式 </th> 
   <th> 碳纳米管 </th> 
   <th> 得分 </th> 
   <th> 错误 </th> 
   <th> 单位 </th> 
  </tr> 
  <tr> 
   <td> 板凳 </td> 
   <td> 平均 </td> 
   <td> 25 </td> 
   <td> 29.625 </td> 
   <td> ±2.172 </td> 
   <td> ns / op </td> 
  </tr> 
  <tr> 
   <td> Benchnano </td> 
   <td> 平均 </td> 
   <td> 25 </td> 
   <td> 25.368 </td> 
   <td> ±0.643 </td> 
   <td> ns / op </td> 
  </tr> 
 </tbody> 
</table>

每个调用`System.currentTimeMillis()`大约需要29纳秒，而`System.nanoTime()`大约需要25纳秒。 不好，不可怕。 这意味着使用`System.nano()`测量花费少于几十纳秒的任何东西可能是不明智的，因为我们仪器的开销会高于所测量的间隔。 我们还应该避免在紧密的循环中使用`nanoTime()` ，因为延迟会Swift增加。 另一方面，使用`nanoTime()`来衡量例如来自远程服务器的响应时间或昂贵的计算时间似乎是明智的。

## 基准II – AWS ##

在便携式计算机上运行基准测试很方便，但不是很实用，除非您愿意放弃便携式计算机并将其用作应用程序的生产环境。 相反，让我们在AWS EC2中运行相同的基准测试。

让我们使用Ubuntu 16.04 LTS启动一台c5.xlarge机器，并使用出色的[SDKMAN][]工具安装由[AdoptOpenJDK][]项目上的杰出人士构建的Java 13：

板凳

结果如下：

<table> 
 <tbody> 
  <tr> 
   <th> 基准测试 </th> 
   <th> 模式 </th> 
   <th> 碳纳米管 </th> 
   <th> 得分 </th> 
   <th> 错误 </th> 
   <th> 单位 </th> 
  </tr> 
  <tr> 
   <td> 板凳 </td> 
   <td> 平均 </td> 
   <td> 25 </td> 
   <td> 28.467 </td> 
   <td> ±0.034 </td> 
   <td> ns / op </td> 
  </tr> 
  <tr> 
   <td> Benchnano </td> 
   <td> 平均 </td> 
   <td> 25 </td> 
   <td> 27.331 </td> 
   <td> ±0.003 </td> 
   <td> ns / op </td> 
  </tr> 
 </tbody> 
</table>

这几乎与笔记本电脑上的一样，还不错。 现在让我们尝试c3.large实例。 它是较老的一代，但仍经常使用：

<table> 
 <tbody> 
  <tr> 
   <th> 基准测试 </th> 
   <th> 模式 </th> 
   <th> 碳纳米管 </th> 
   <th> 得分 </th> 
   <th> 错误 </th> 
   <th> 单位 </th> 
  </tr> 
  <tr> 
   <td> 板凳 </td> 
   <td> 平均 </td> 
   <td> 25 </td> 
   <td> 362.491 </td> 
   <td> ±0.072 </td> 
   <td> ns / op </td> 
  </tr> 
  <tr> 
   <td> Benchnano </td> 
   <td> 平均 </td> 
   <td> 25 </td> 
   <td> 367.348 </td> 
   <td> ±6.100 </td> 
   <td> ns / op </td> 
  </tr> 
 </tbody> 
</table>

这看起来一点都不好！ c3.large是一个较早且较小的实例，因此预计会有所降低，但这太多了！ `currentTimeMillis()`和`nanoTime()`都慢一个数量级。 起初360 ns听起来可能还不错，但是请考虑一下：要仅测量一次经过时间，您需要两次调用。 因此，每次测量花费大约0.7μs。 如果您有10个探针测量不同的执行阶段，则您的时间为7μs。 透视一下：40gbit网卡的往返行程约为10μs。 这意味着向我们的热路径添加一堆探针可能会对延迟产生非常大的影响！

## 一点内核调查 ##

为什么C3实例比笔记本电脑或C5实例慢得多？ 事实证明，这与Linux时钟源有关，更重要的是与glibc-kernel接口有关。 我们已经知道，每次调用`nanoTime()`或`currentTimeMillis()`调用OpenJDK中的本地代码，该本地代码调用glibc，后者又调用Linux内核。

有趣的部分是glibc-Linux内核转换：通常，当进程调用Linux内核函数（也称为syscall）时，它涉及从用户模式切换到内核模式，然后再返回。 此过渡是一个相对昂贵的操作，涉及许多步骤：

*  将CPU寄存器存储在内核堆栈中
 *  使用实际功能运行内核代码
 *  将结果从内核空间复制到用户空间
 *  从内核堆栈恢复CPU寄存器
 *  跳回用户代码

这从来都不是便宜的操作，并且随着[边信道安全攻击][Link 4]和相关缓解技术的出现，它变得越来越昂贵。

对性能敏感的应用程序通常会尽力避免用户到内核的转换。 Linux内核本身提供了一些非常频繁的系统调用的捷径，称为[vDSO –虚拟动态共享对象][vDSO] 。 它实质上导出了一些功能，并将它们映射到进程的地址空间中。 用户进程可以调用这些函数，就像它们是普通共享库中的常规函数一样。 事实证明， `clock_gettime()`和`gettimeofday()`都实现了这样的快捷方式，因此，当glibc调用`clock_gettime()` ，它实际上只是跳转到内存地址而无需进行昂贵的用户到内核转换。

所有这些听起来像是一个有趣的理论，但是并不能解释为什么`System.nanoTime()`在c3实例上这么慢。

## 实验时间 ##

我们将使用另一个出色的Linux工具来监视系统调用的数量： [`perf`][perf] 。 我们可以做的最简单的测试是启动基准测试并计算操作系统中的所有系统调用。 `perf`语法很简单：  
`sudo perf stat -e raw_syscalls:sys_enter -I 1000 -a`  
这将为我们提供每秒的系统调用总数。 一个重要的细节：它将仅向我们提供真正的系统调用，以及完整的用户模式-内核模式转换。 vDSO调用不计算在内。 这是在c5实例上运行时的外观：

板凳

您可以看到每秒大约有130个系统调用。 鉴于我们基准测试的每次迭代都少于30 ns，因此很明显，该应用程序使用vDSO绕过了系统调用。

这是在c3实例上的外观：

板凳

每秒超过1,300,000个系统调用！ 同样， `nanoTime()`和`currentTimeMillis()`的延迟大约翻了一番，达到700ns /操作。 这是每个基准测试迭代都会调用真实系统调用的有力指示！

让我们使用另一个`perf`命令来收集其他证据。 此命令将计算5秒钟内调用的所有系统调用并按名称分组：  
`sudo perf stat -e 'syscalls:sys_enter_*' -a sleep 5`  
在c5实例上运行时，没有任何异常情况。 但是，在c3实例上运行时，我们可以看到以下内容：

板凳

这是我们的吸烟枪！ 非常有力的证据表明，当基准测试在c3框上运行时，它将进行真正的`gettimeofday()`系统调用！ 但为什么？

[这是][Link 5] 4.4内核（在Ubuntu 16.04中使用） [的相关部分][Link 5] ：

板凳

它是映射到用户内存中的函数，当Java调用`System.currentTimeMillis()`时由glibc调用。 它调用`do_realtime()` ，该`struct tv`使用当前时间填充`struct tv` ，然后返回给调用者。 重要的是所有这些操作均在用户模式下执行，而没有任何缓慢的系统调用。 好吧，除非`do_realtime()`返回`VCLOCK_NONE` 。 在这种情况下，它将调用`vdso_fallback_gtod()` ，这将执行缓慢的系统调用。

为什么c3实例执行回退做系统调用而c5不做？ 好吧，这与虚拟化技术的变化有关！ 自成立以来，AWS一直在使用[Xen虚拟化][Xen] 。 大约2年前， [他们宣布][Link 6]从Xen过渡到[KVM虚拟化][KVM] 。 C3实例使用Xen虚拟化，较新的c5实例使用KVM。 对我们而言重要的是，每种技术都使用Linux Clock的不同实现。 Linux在`/sys/devices/system/clocksource/clocksource0/current_clocksource`显示当前时钟源。

这是c3：

板凳

这是c5：

板凳

原来，KVM-时钟实现[套`vclock_mode`到`VCLOCK_PVCLOCK`][vclock_mode_VCLOCK_PVCLOCK]这意味着慢回退分支以上不采取。 Xen时钟源根本没有设置此[模式][Link 7] ，而是停留在`VCLOCK_NONE` 。 这将导致跳入`vdso_fallback_gtod()`函数，该函数最终将启动实际的系统调用！

板凳

关于Linux的好处是它是高度可配置的，并且经常给我们足够的绳索来吊死自己。 我们可以尝试更改c3上的时钟源并重新运行基准测试。 可通过`$ cat /sys/devices/system/clocksource/clocksource0/available_clocksource xen tsc hpet acpi_pm` `$ cat /sys/devices/system/clocksource/clocksource0/available_clocksource xen tsc hpet acpi_pm`

TSC代表[时间戳计数器][Link 8] ，它是一种非常快速的资源，并且对我们而言重要的是适当的vDSO实施。 让我们将c3实例中的时钟源从Xen切换到TSC：

板凳

检查它是否真的被切换：

板凳

看起来挺好的！ 现在我们可以重新运行基准测试：

<table> 
 <tbody> 
  <tr> 
   <th> 基准测试 </th> 
   <th> 模式 </th> 
   <th> 碳纳米管 </th> 
   <th> 得分 </th> 
   <th> 错误 </th> 
   <th> 单位 </th> 
  </tr> 
  <tr> 
   <td> 板凳 </td> 
   <td> 平均 </td> 
   <td> 25 </td> 
   <td> 25.558 </td> 
   <td> ±0.070 </td> 
   <td> ns / op </td> 
  </tr> 
  <tr> 
   <td> Benchnano </td> 
   <td> 平均 </td> 
   <td> 25 </td> 
   <td> 24.101 </td> 
   <td> ±0.037 </td> 
   <td> ns / op </td> 
  </tr> 
 </tbody> 
</table>

数字看起来不错！ 实际上比具有kvm-clock的c5实例更好。 每秒系统调用数与c5实例处于同一级别：

板凳

有人建议即使使用Xen虚拟化，也要将时钟源切换为TSC。 我对它可能产生的副作用还不太了解，但是显然，即使是一些[大公司][Link 9]也在生产中做到了这一点。 显然，这并不证明它是安全的，但这表明它对某些人有效。

## 最后的话 ##

我们已经看到了底层实现细节如何对普通Java调用的性能产生重大影响。 这不仅仅是在微基准测试中可见的理论问题， [实际系统也会受到影响][Link 10] 。 您可以直接在[Linux内核源代码树中][Linux 1]阅读有关vDSO的更多信息。

没有我在[Hazelcast的][Hazelcast]出色同事，我将无法进行调查。 这是一支世界一流的团队，我从他们那里学到了很多东西！ 我要感谢布伦丹·格雷格（Brendan Gregg）收集的各种[技巧][Link 11] ，我的记忆力一直很差，布伦丹创造了一个很棒的备忘单。

最后但并非最不重要的一点：如果您对性能，运行时或分布式系统感兴趣，请[关注我][Link 12] ！

> 翻译自: [https://www.javacodegeeks.com/2019/12/measuring-time-from-java-to-kernel-and-back.html][https_www.javacodegeeks.com_2019_12_measuring-time-from-java-to-kernel-and-back.html]

java内核

[OpenJDK 14]: https://github.com/openjdk/jdk/tree/f3e90595aad15529f306969c9f7bc9a485a3bf43
[Link 1]: https://github.com/openjdk/jdk/blob/f3e90595aad15529f306969c9f7bc9a485a3bf43/src/java.base/share/classes/java/lang/System.java#L427
[Link 2]: https://github.com/openjdk/jdk/blob/161333eeba1d4ac163991d6697c24f3a59148b2b/src/hotspot/share/prims/jvm.cpp#L273-L276
[Linux]: https://github.com/openjdk/jdk/blob/161333eeba1d4ac163991d6697c24f3a59148b2b/src/hotspot/os/linux/os_linux.cpp#L1376-L1381
[gettimeofday]: http://man7.org/linux/man-pages/man2/gettimeofday.2.html
[javaTimeNanos]: https://github.com/openjdk/jdk/blob/161333eeba1d4ac163991d6697c24f3a59148b2b/src/hotspot/os/linux/os_linux.cpp#L1417-L1431
[Link 3]: https://github.com/openjdk/jdk/blob/53263049c9a33cd3f3d53540107291f613b73fed/src/hotspot/os/posix/os_posix.cpp#L1642-L1656
[SDKMAN]: https://sdkman.io/
[AdoptOpenJDK]: https://adoptopenjdk.net/
[Link 4]: https://meltdownattack.com/
[vDSO]: https://en.wikipedia.org/wiki/VDSO
[perf]: https://perf.wiki.kernel.org/index.php/Main_Page
[Link 5]: https://github.com/torvalds/linux/blob/v4.4/arch/x86/entry/vdso/vclock_gettime.c#L308-L321
[Xen]: https://xenproject.org/
[Link 6]: https://medium.com/@dbclin/aws-just-announced-a-move-from-xen-towards-kvm-so-what-is-kvm-2091f123991
[KVM]: https://www.linux-kvm.org/page/Main_Page
[vclock_mode_VCLOCK_PVCLOCK]: https://github.com/torvalds/linux/blob/v4.4/arch/x86/kernel/kvmclock.c#L335
[Link 7]: https://github.com/torvalds/linux/blob/v4.4/arch/x86/include/asm/clocksource.h
[Link 8]: https://en.wikipedia.org/wiki/Time_Stamp_Counter
[Link 9]: https://news.ycombinator.com/item?id=13813936
[Link 10]: https://www.google.com/search?q=vdso+xen
[Linux 1]: https://github.com/torvalds/linux/blob/v4.4/Documentation/ABI/stable/vdso
[Hazelcast]: https://hazelcast.org/
[Link 11]: http://www.brendangregg.com/perf.html
[Link 12]: https://twitter.com/jerrinot
[https_www.javacodegeeks.com_2019_12_measuring-time-from-java-to-kernel-and-back.html]: https://www.javacodegeeks.com/2019/12/measuring-time-from-java-to-kernel-and-back.html