ToB企服应用市场:ToB评测及商务社交产业平台

标题: MappedByteBuffer VS FileChannel：从内核层面对比两者的性能差异 [打印本页]
作者: 老婆出轨    时间: 2024-5-15 16:34
标题: MappedByteBuffer VS FileChannel：从内核层面对比两者的性能差异
本文基于 Linux 内核 5.4 版本进行讨论
自上篇文章《从 Linux 内核角度探秘 JDK MappedByteBuffer》 发布之后，很多读者朋侪私信我说，文章的信息量太大了，此中很多章节先容的内容都是各人非常想要了解，而且是频繁被搜索的内容，以是根据读者朋侪的建议，笔者决定将一些重要的章节内容独立出来，更好的方便各人检索。
关于 MappedByteBuffer 和 FileChannel 的话题，网上有很多，但大部分都在讨论 MappedByteBuffer 相较于传统 FileChannel 的上风，但好像很少有人来写一写 MappedByteBuffer 的劣势，以是笔者这里想写一点不一样的，来和各人讨论讨论 MappedByteBuffer 的劣势有哪些。
但在开始讨论这个话题之前，笔者想了想还是不能免俗，仍然需要把 MappedByteBuffer 和 FileChannel 放在一起重新到尾对比一下，基于这个思路，我们先来重新简要梳理一下 FileChannel 和 MappedByteBuffer 读写文件的流程。
1. FileChannel 读写文件过程

在之前的文章《从 Linux 内核角度探秘 JDK NIO 文件读写本质》中，由于当时我们还未先容 DirectByteBuffer 以及 MappedByteBuffer，以是笔者以 HeapByteBuffer 为例来先容 FileChannel 读写文件的整个源码实现逻辑。
当我们使用 HeapByteBuffer 传入 FileChannel 的 read or write 方法对文件进行读写时，JDK 会首先创建一个临时的 DirectByteBuffer，对于 FileChannel#read 来说，JDK 在 native 层会将 read 系统调用从文件中读取的内容首先存放到这个临时的  DirectByteBuffer 中，然后在拷贝到 HeapByteBuffer 中返回。
对于  FileChannel#write 来说，JDK 会首先将 HeapByteBuffer 中的待写入数据拷贝到临时的 DirectByteBuffer 中，然后在 native 层通过 write 系统调用将 DirectByteBuffer 中的数据写入到文件的 page cache 中。
  1. public class IOUtil {
  3.    static int read(FileDescriptor fd, ByteBuffer dst, long position,
  4.                     NativeDispatcher nd)
  5.         throws IOException
  6.     {
  7.         // 如果我们传入的 dst 是 DirectBuffer，那么直接进行文件的读取
  8.         // 将文件内容读取到 dst 中
  9.         if (dst instanceof DirectBuffer)
  10.             return readIntoNativeBuffer(fd, dst, position, nd);
  11.   
  12.         // 如果我们传入的 dst 是一个 HeapBuffer，那么这里就需要创建一个临时的 DirectBuffer
  13.         // 在调用 native 方法底层利用 read  or write 系统调用进行文件读写的时候
  14.         // 传入的只能是 DirectBuffer
  15.         ByteBuffer bb = Util.getTemporaryDirectBuffer(dst.remaining());
  16.         try {
  17.             // 底层通过 read 系统调用将文件内容拷贝到临时 DirectBuffer 中
  18.             int n = readIntoNativeBuffer(fd, bb, position, nd);   
  19.             if (n > 0)
  20.                 // 将临时 DirectBuffer 中的文件内容在拷贝到 HeapBuffer 中返回
  21.                 dst.put(bb);
  22.             return n;
  23.         }
  24.     }
  26.     static int write(FileDescriptor fd, ByteBuffer src, long position,
  27.                      NativeDispatcher nd) throws IOException
  28.     {
  29.         // 如果传入的 src 是 DirectBuffer，那么直接将 DirectBuffer 中的内容拷贝到文件 page cache 中
  30.         if (src instanceof DirectBuffer)
  31.             return writeFromNativeBuffer(fd, src, position, nd);
  32.         // 如果传入的 src 是 HeapBuffer，那么这里需要首先创建一个临时的 DirectBuffer
  33.         ByteBuffer bb = Util.getTemporaryDirectBuffer(rem);
  34.         try {
  35.             // 首先将 HeapBuffer 中的待写入内容拷贝到临时的 DirectBuffer 中
  36.             // 随后通过 write 系统调用将临时 DirectBuffer 中的内容写入到文件 page cache 中
  37.             int n = writeFromNativeBuffer(fd, bb, position, nd);     
  38.             return n;
  39.         }
  40.     }
  41. }
复制代码
当时有很多读者朋侪给我留言提问说，为什么必须要在 DirectByteBuffer 中做一次中转，直接将 HeapByteBuffer 传给 native 层不可吗 ？
答案是肯定不可的，在本文开头笔者为各人先容过 JVM 历程的假造内存空间结构，如下图所示：

HeapByteBuffer 和 DirectByteBuffer 从本质上来说均是 JVM 历程地点空间内的一段假造内存，对于 Java 程序来说 HeapByteBuffer 被用来特定表现 JVM 堆中的内存，而 DirectByteBuffer 就是一个普通的 C++ 程序通过 malloc 系统调用向操作系统申请的一段 Native Memory 位于 JVM 堆之外。
既然 HeapByteBuffer 是位于 JVM 堆中的内存，那么它必然会受到 GC 的管理，当发生 GC 的时候，如果我们选择的垃圾回收器接纳的是  Mark-Copy 大概 Mark-Compact 算法的时候（Mark-Swap 除外），GC 会来回移动存活的对象，这就导致了存活的 Java 对象比如这里的 HeapByteBuffer 在 GC 之后它背后的内存地点可能已经发生了变革。
而 JVM 中的这些 native 方法是处于 safepoint 之下的，执行 native 方法的线程由于是处于 safepoint 中，以是在执行 native 方法的过程中可能会有 GC 的发生。
如果我们把一个 HeapByteBuffer 通报给 native  层进行文件读写的时候不巧发生了 GC，那么 HeapByteBuffer 背后的内存地点就会变革，这样一来，如果我们在读取文件的话，内核将会把文件内容拷贝到另一个内存地点中。如果我们在写入文件的话，内核将会把另一个内存地点中的内存写入到文件的 page cache 中。
以是我们在通过 native 方法执行相干系统调用的时候必须要保证传入的内存地点是不会变革的，由于 DirectByteBuffer 背后所依靠的 Native Memory 位于 JVM 堆之外，是不会受到 GC 管理的，因此不管发不发生 GC，DirectByteBuffer 所引用的这些 Native Memory 地点是不会发生变革的。
以是我们在调用 native 方法进行文件读写的时候需要传入 DirectByteBuffer，如果我们用得是 HeapByteBuffer ，那么就需要一个临时的 DirectByteBuffer 作为中转。
这时可能有读者朋侪又会问了，我们在使用 HeapByteBuffer 通过 FileChannel#write 对文件进行写入的时候，首先会将 HeapByteBuffer 中的内容拷贝到临时的 DirectByteBuffer 中，那如果在这个拷贝的过程中发生了 GC，HeapByteBuffer 背后引用内存的地点发生了变革，那么拷贝到 DirectByteBuffer 中的内容仍然是错的啊。
事实上在这个拷贝的过程中是不会发生 GC 的，因为 JVM  这里会使用 Unsafe#copyMemory 方法来实现 HeapByteBuffer 到 DirectByteBuffer 的拷贝操作，copyMemory 被 JVM 实现为一个 intrinsic 方法，中间是没有 safepoint 的，执行 copyMemory 的线程由于不在 safepoint 中，以是在拷贝的过程中是不会发生 GC 的。
  1. public final class Unsafe {
  2.   // intrinsic 方法
  3.   public native void copyMemory(Object srcBase, long srcOffset,
  4.                                   Object destBase, long destOffset,
  5.                                   long bytes);  
  6. }
复制代码
在交代完这个遗留的问题之后，下面我们就以 DirectByteBuffer 为例来重新简要回顾下传统 FileChannel 对文件的读写流程：

从以上过程我们可以看到，当使用 FileChannel#read 对文件读取的时候，如果文件数据在 page cache 中，涉及到的性能开销点主要有两次上下文切换，以及一次 CPU 拷贝。此中上下文切换是主要的性能开销点。
下面是通过 FileChannel#write 写入文件的整个过程：

从以上过程我们可以看到，当使用 FileChannel#write 对文件写入的时候，如果不思量脏页回写的情况，单纯对于 JVM 这个历程来说涉及到的性能开销点主要有两次上下文切换，以及一次 CPU 拷贝。此中上下文切换仍然是主要的性能开销点。
2. MappedByteBuffer 读写文件过程

下面我们来看下通过 MappedByteBuffer 对文件进行读写的过程：

首先我们需要通过 FileChannel#map 将文件的某个区域映射到 JVM 历程的假造内存空间中，从而获得一段文件映射的假造内存区域 MappedByteBuffer。由于底层使用到了 mmap 系统调用，以是这个过程也涉及到了两次上下文切换。
如上图所示，当 MappedByteBuffer 在刚刚映射出来的时候，它只是历程地点空间中的一段假造内存，其对应在历程页表中的页表项还是空的，背后还没有映射物理内存。此时映射文件对应的 page cache 也是空的，我们要映射的文件内容此时还静静地躺在磁盘中。
当 JVM 历程开始对 MappedByteBuffer 进行读写的时候，就会触发缺页中断，内核会将映射的文件内容从磁盘中加载到 page cache 中，然后在历程页表中建立 MappedByteBuffer 与 page cache  的映射关系。由于这里涉及到了缺页中断的处置惩罚，因此也会有两次上下文切换的开销。

后面 JVM  历程对 MappedByteBuffer 的读写就相当于是直接读写 page cache 了，关于这一点，很多读者朋侪会有这样的疑问：page cache 是内核态的部分，为什么我们通过用户态的 MappedByteBuffer 就可以直接访问内核态的东西了？
这里各人不要被内核态这三个字给唬住了，虽然 page cache 是属于内核部分的，但其本质上还是一块普通的物理内存，想想我们是怎么访问内存的 ？ 不就是先有一段假造内存，然后在申请一段物理内存，末了通过历程页表将假造内存和物理内存映射起来么，历程在访问假造内存的时候，通过页表找到其映射的物理内存地点，然后直接通过物理内存地点访问物理内存。
回到我们讨论的内容中，这段假造内存不就是 MappedByteBuffer 吗，物理内存就是 page cache 啊，在通过页表映射起来之后，历程在通过 MappedByteBuffer 访问 page cache 的过程就和访问普通内存的过程是一模一样的。
也正因为 MappedByteBuffer 背后映射的物理内存是内核空间的 page cache，以是它不会消耗任何用户空间的物理内存（JVM  的堆外内存），因此也不会受到 -XX:MaxDirectMemorySize 参数的限制。
3. MappedByteBuffer VS FileChannel

现在我们已经清楚了 FileChannel 以及 MappedByteBuffer 进行文件读写的整个过程，下面我们就来把两种文件读写方式放在一起来对比一下，但这里有一个对比的条件：
因为笔者认为只有基于这个条件来对比两者的性能差异才有意义。
从上面的对比我们可以看出使用 MappedByteBuffer 来读写文件既没有上下文切换的开销，也没有数据拷贝的开销（可忽略），简直是完爆 FileChannel。
既然 MappedByteBuffer 这么屌，那我们何不干脆在所有文件的读写场景中全部使用 MappedByteBuffer，这样岂不省事 ？JDK 为何还保留了 FileChannel 的 read , write 方法呢 ？让我们来带着这个疑问继续下面的内容~~
4. 通过 Benchmark 从内核层面对比两者的性能差异

到现在为止，笔者已经带着各人完整的剖析了 mmap，read，write 这些系统调用在内核中的源码实现，并基于源码对 MappedByteBuffer 和 FileChannel 两者进行了性能开销上的对比。
虽然祭出了源码，但毕竟还是 talk is cheap，本末节我们就来对两者进行一次 Benchmark，来看一下 MappedByteBuffer 与 FileChannel 对文件读写的实际性能体现如何 ？ 是否和我们从源码中分析的结果一致。
我们从两个方面来对比 MappedByteBuffer 和 FileChannel 的文件读写性能：
具体的测试思路是，用 MappedByteBuffer 和 FileChannel 分别以
64B ,128B ,512B ,1K ,2K ,4K ,8K ,32K ,64K ,1M ,32M ,64M ,512M 为单位依次对 1G 大小的文件进行读写，从以上两个方面对比两者在不同读写单位下的性能体现。

需要提醒各人的是本末节中得出的读写性能具体数值是没有参考价值的，因为不同软硬件环境下测试得出的具体性能数值都不一样，值得参考的是 MappedByteBuffer 和 FileChannel 在不同数据集大小下的读写性能趋势走向。笔者的软硬件测试环境如下：
测试代码：https://github.com/huibinliupush/benchmark , 各人也可以在自己的测试环境中运行一下，然后将跑出的结果提交到这个仓库中。这样方便各人在不同的测试环境下对比两者的文件读写性能差异 —— 众人拾柴火焰高。
4.1 文件数据在 page cache 中

由于这里我们要测试 MappedByteBuffer 和 FileChannel 直接对 page cache 的读写性能，以是笔者让 MappedByteBuffer ，FileChannel 只针对同一个文件进行读写测试。
在对文件进行读写之前，首先通过 mlock 系统调用将文件数据提前加载到 page cache 中并主动触发缺页处置惩罚，在历程页表中建立好 MappedByteBuffer 和 page cache 的映射关系。末了将 page cache 锁定在内存中不答应 swap。
下面是 MappedByteBuffer 和 FileChannel 在不同数据集下对 page cache 的读取性能测试：

运行结果如下：

为了直观的让各人一眼看出 MappedByteBuffer 和 FileChannel 在对 page cache 读取的性能差异，笔者根据上面跑出的性能数据绘制成下面这幅柱状图，方便各人观察两者的性能趋势走向。

这里我们可以看出，MappedByteBuffer 在 4K 之前具有明显的压倒性上风，在 [8K , 32M] 这个区间内，MappedByteBuffer 依然具有上风但已经不是十分明显了，从 64M 开始 FileChannel 实现了一点点反超。
我们可以得到的性能趋势是，在 [64B, 2K] 这个单次读取数据量级范围内，MappedByteBuffer 读取的性能越来越快，并在 2K 这个数据量级下达到了性能最高值，仅消耗了 73 ms。从 4K 开始读取性能在一点一点的逐渐降落，并在 64M 这个数据量级下被 FileChannel 反超。
而 FileChannel 的读取性能会随着数据量的增大反而越来越好，并在某一个数据量级下性能会反超 MappedByteBuffer。FileChannel 的最佳读取性能点是在 64K 处，消耗了 167ms 。
因此 MappedByteBuffer 适合频繁读取小数据量的场景，具体多小，需要各人根据自己的环境进行测试，本末节我们得出的数据是 4K 以下。
FileChannel 适合大数据量的批量读取场景，具体多大，还是需要各人根据自己的环境进行测试，本末节我们得出的数据是 64M 以上。

下面是 MappedByteBuffer 和 FileChannel 在不同数据集下对 page cache 的写入性能测试：

运行结果如下：

MappedByteBuffer 和 FileChannel 在不同数据集下对 page cache 的写入性能的趋势走向柱状图：

这里我们可以看到 MappedByteBuffer 在 8K 之前具有明显的写入上风，它的写入性能趋势是在 [64B , 8K] 这个数据集方位内，写入性能随着数据量的增大而越来越快，直到在 8K 这个数据集下达到了最佳写入性能。
而在 [32K, 32M] 这个数据集范围内，MappedByteBuffer 仍然具有上风，但已经不是十分明显了，最终在 64M 这个数据集下被 FileChannel 反超。
和前面的读取性能趋势一样，FileChannel 的写入性能也是随着数据量的增大反而越来越好，最佳的写入性能是在 64K 处，仅消耗了 160 ms 。

4.2 文件数据不在 page cache 中

在这一末节中，我们将缺页中断和磁盘 IO 的影响加入进来，不添加任何的优化本领纯粹地测一下 MappedByteBuffer 和 FileChannel 对文件读写的性能。
为了避免被 page cache 影响，以是我们需要在每一个测试数据集下，单独分别为 MappedByteBuffer 和 FileChannel 创建各自的测试文件。
下面是 MappedByteBuffer 和 FileChannel 在不同数据集下对文件的读取性能测试：

运行结果：

从这里我们可以看到，在加入了缺页中断和磁盘 IO 的影响之后，MappedByteBuffer 在缺页中断的影响下平均比之前多出了 500 ms 的开销。FileChannel 在磁盘 IO 的影响下在 [64B , 512B] 这个数据集范围内比之前平均多出了 1000 ms 的开销，在 [1K, 512M] 这个数据集范围内比之前平均多出了 100 ms 的开销。

在 2K 之前， MappedByteBuffer 具有明显的读取性能上风，最佳的读取性能出现在 512B 这个数据集下，从 512B 今后，MappedByteBuffer 的读取性能趋势总体成降落趋势，并在 4K 这个地方被 FileChannel 反超。
FileChannel 则是在 [64B, 1M] 这个数据集范围内，读取性能会随着数据集的增大而进步，并在 1M 这个地方达到了 FileChannel 的最佳读取性能，仅消耗了 258 ms，在 [32M ， 512M] 这个范围内 FileChannel 的读取性能在逐渐降落，但是比  MappedByteBuffer 的性能高出了一倍。

读到这里各人不禁要问了，理论上来讲 MappedByteBuffer 应该是完爆 FileChannel 才对啊，因为 MappedByteBuffer 没有系统调用的开销，为什么性能在后面反而被 FileChannel 逾越了近一倍之多呢 ?
要明白这个问题，我们就需要分别把 MappedByteBuffer 和 FileChannel 在读写文件时候所涉及到的性能开销点一一枚举出来，并对这些性能开销点进行详细对比，这样答案就有了。
首先 MappedByteBuffer 的主要性能开销是在缺页中断，而 FileChannel 的主要开销是在系统调用，两者都会涉及上下文的切换。
FileChannel 在读写文件的时候有磁盘IO，有预读。同样 MappedByteBuffer 的缺页中断也有磁盘IO 也有预读。现在来看他俩一比一打平。
但别忘了 MappedByteBuffer 是需要历程页表支持的，在实际访问内存的过程中会遇到页表竞争以及 TLB shootdown 等问题。另有就是 MappedByteBuffer 刚刚被映射出来的时候，其在历程页表中对应的各级页表以及页目录可能都是空的。以是缺页中断这里需要做的一件非常重要的事情就是补齐完善 MappedByteBuffer 在历程页表中对应的各级页目录表和页表，并在页表项中将 page cache 映射起来，末了还要刷新 TLB 等硬件缓存。
想更多了解缺页中断细节的读者可以看下之前的文章——
《一文聊透 Linux 缺页非常的处置惩罚 —— 图解 Page Faults》
而 FileChannel 并不会涉及上面的这些开销，以是 MappedByteBuffer 的缺页中断要比 FileChannel 的系统调用开销要大，这一点我们可以在上末节和本末节的读写性能对比中看得出来。
文件数据在 page cache 中与不在 page cache 中，MappedByteBuffer 前后的读取性能平均差了 500 ms，而 FileChannel 前后却只平均差了 100 ms。
MappedByteBuffer 的缺页中断是平均每 4K 触发一次，而 FileChannel 的系统调用开销则是每次都会触发。当两者单次按照小数据量读取 1G 文件的时候，MappedByteBuffer 的缺页中断较少触发，而 FileChannel 的系统调用却在频繁触发，以是在这种情况下，FileChannel 的系统调用是主要的性能瓶颈。
这也就解释了当我们在频繁读写小数据量的时候，MappedByteBuffer 的性能具有压倒性上风。当单次读写的数据量越来越大的时候，FileChannel 调用的次数就会越来越少，这时候缺页中断就会成为 MappedByteBuffer 的性能瓶颈，到某一个点之后，FileChannel 就会反超 MappedByteBuffer。因此当我们需要高吞吐量读写文件的时候 FileChannel 反而是最合适的。
除此之外，内核的脏页回写也会对 MappedByteBuffer 以及 FileChannel 的文件写入性能有非常大的影响，无论是我们在用户态中调用 fsync 大概 msync 主动触发脏页回写还是内核通过 pdflush 线程异步脏页回写，当我们使用 MappedByteBuffer 大概 FileChannel 写入 page cache 的时候，如果恰巧遇到文件页的回写，那么写入操作都会有非常大的延迟，这个在 MappedByteBuffer 身上体现的更为明显。
为什么这么说呢 ？ 我们还是到内核源码中去探寻原因，先来看脏页回写对 FileChannel 的写入影响。下面是 FileChannel 文件写入在内核中的核心实现：
  1. ssize_t generic_perform_write(struct file *file,
  2.     struct iov_iter *i, loff_t pos)
  3. {
  4.    // 从 page cache 中获取要写入的文件页并准备记录文件元数据日志工作
  5.   status = a_ops->write_begin(file, mapping, pos, bytes, flags,
  6.       &page, &fsdata);
  7.    // 将用户空间缓冲区 DirectByteBuffer 中的数据拷贝到 page cache 中的文件页中
  8.   copied = iov_iter_copy_from_user_atomic(page, i, offset, bytes);
  9.   // 将写入的文件页标记为脏页并完成文件元数据日志的写入
  10.   status = a_ops->write_end(file, mapping, pos, bytes, copied,
  11.       page, fsdata);
  12.   // 判断是否需要同步回写脏页
  13.   balance_dirty_pages_ratelimited(mapping);
  14. }
复制代码
首先内核会在 write_begin 函数中通过 grab_cache_page_write_begin 从文件 page  cache 中获取要写入的文件页。
  1. struct page *grab_cache_page_write_begin(struct address_space *mapping,
  2.           pgoff_t index, unsigned flags)
  3. {
  4.   struct page *page;
  5.   // 在 page cache 中查找写入数据的缓存页
  6.   page = pagecache_get_page(mapping, index, fgp_flags,
  7.       mapping_gfp_mask(mapping));
  8.   if (page)
  9.     wait_for_stable_page(page);
  10.   return page;
  11. }
复制代码
在这里会调用一个非常重要的函数 wait_for_stable_page，这个函数的作用就是判定当前 page cache 中的这个文件页是否正在被回写，如果正在回写到磁盘，那么当前历程就会阻塞直到脏页回写完毕。
  1. /**
  2. * wait_for_stable_page() - wait for writeback to finish, if necessary.
  3. * @page:        The page to wait on.
  4. *
  5. * This function determines if the given page is related to a backing device
  6. * that requires page contents to be held stable during writeback.  If so, then
  7. * it will wait for any pending writeback to complete.
  8. */
  9. void wait_for_stable_page(struct page *page)
  10. {
  11.         if (bdi_cap_stable_pages_required(inode_to_bdi(page->mapping->host)))
  12.                 wait_on_page_writeback(page);
  13. }
  14. EXPORT_SYMBOL_GPL(wait_for_stable_page);
复制代码
比及脏页回写完毕之后，历程才会调用 iov_iter_copy_from_user_atomic 将待写入数据拷贝到 page cache 中，末了在 write_end 中调用 mark_buffer_dirty 将写入的文件页标志为脏页。
除了正在回写的脏页会阻塞 FileChannel 的写入过程之外，如果此时系统中的脏页太多了，凌驾了 dirty_ratio 大概 dirty_bytes 等内核参数配置的脏页比例，那么历程就会同步去回写脏页，这也对写入性能有非常大的影响。
我们接着再来看脏页回写对 MappedByteBuffer 的写入影响，在开始分析之前，笔者先问各人一个问题：通过 MappedByteBuffer 写入 page cache 之后，page cache 中的相应文件页是怎么变脏的 ？
FileChannel 很好理解，因为 FileChannel 走的是系统调用，会进入到文件系统由内核进行处置惩罚，如果写入文件页恰好正在回写时，内核会调用 wait_for_stable_page 阻塞当前历程。在将数据写入文件页之后，内核又会调用 mark_buffer_dirty 将页面变脏。
MappedByteBuffer 就很难理解了，因为 MappedByteBuffer 不会走系统调用，直接读写的就是 page cache，而 page cache 也只是内核在软件层面上的定义，它的本质还是物理内存。另外脏页以及脏页的回写都是内核在软件层面上定义的概念和行为。
MappedByteBuffer 直接写入的是硬件层面的物理内存（page cache），硬件哪管你软件上定义的脏页以及脏页回写啊，没有内核的参与，那么在通过 MappedByteBuffer 写入文件页之后，文件页是如何变脏的呢 ？另有就是 MappedByteBuffer 如何探测到对应文件页正在回写并阻塞等候呢 ？
既然我们涉及到了软件的概念和行为，那么一定就会有内核的参与，我们追念一下整个 MappedByteBuffer 的生命周期，唯一一次和内核打交道的机会就是缺页中断，我们看看能不能在缺页中断中发现点什么~
当 MappedByteBuffer 刚刚被 mmap 映射出来的时候它还只是一段普通的假造内存，背后什么都没有，其在历程页表中的各级页目录项以及页表项都还是空的。
当我们立即对 MappedByteBuffer 进行写入的时候就会发生缺页中断，在缺页中断的处置惩罚中，内核会在历程页表中补齐与 MappedByteBuffer 映射相干的各级页目录并在页表项中与 page cache 进行映射。
  1. static vm_fault_t do_shared_fault(struct vm_fault *vmf)
  2. {
  3.     // 从 page cache 中读取文件页
  4.     ret = __do_fault(vmf);   
  5.     if (vma->vm_ops->page_mkwrite) {
  6.         unlock_page(vmf->page);
  7.         // 将文件页变为可写状态，并设置文件页为脏页
  8.         // 如果文件页正在回写，那么阻塞等待
  9.         tmp = do_page_mkwrite(vmf);
  10.     }
  11. }
复制代码
除此之外，内核还会调用 do_page_mkwrite 方法将 MappedByteBuffer 对应的页表项变成可写状态，并将与其映射的文件页立即设置位脏页，如果此时文件页正在回写，那么 MappedByteBuffer 在缺页中断中也会阻塞。
  1. int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
  2.                          get_block_t get_block)
  3. {
  4.         set_page_dirty(page);
  5.         wait_for_stable_page(page);
  6. }
复制代码
这里我们可以看到 MappedByteBuffer 在内核中是先变脏然后在对 page cache 进行写入，而 FileChannel 是先写入 page cache 后在变脏。
今后之后，通过 MappedByteBuffer 对 page cache 的写入就会变得非常丝滑，那么问题来了，当 page cache 中的脏页被内核异步回写之后，内核会把文件页中的脏页标志清除掉，那么这时如果 MappedByteBuffer 对 page cache 写入，由于不会发生缺页中断，那么 page cache 中的文件页如何再次变脏呢 ？
内核这里的计划非常巧妙，当内核回写完脏页之后，会调用 page_mkclean_one 函数清除文件页的脏页标志，在这里会首先通过 page_vma_mapped_walk 判定该文件页是不是被 mmap 映射到历程地点空间的，如果是，那么说明该文件页是被 MappedByteBuffer 映射的。随后内核就会做一些特别处置惩罚：
  1. static bool page_mkclean_one(struct page *page, struct vm_area_struct *vma,
  2.                             unsigned long address, void *arg)
  3. {
  5.         while (page_vma_mapped_walk(&pvmw)) {
  6.                 int ret = 0;
  8.                 address = pvmw.address;
  9.                 if (pvmw.pte) {
  10.                         pte_t entry;
  11.                         entry = ptep_clear_flush(vma, address, pte);
  12.                         entry = pte_wrprotect(entry);
  13.                         entry = pte_mkclean(entry);
  14.                         set_pte_at(vma->vm_mm, address, pte, entry);
  15.                 }
  16.         return true;
  17. }
复制代码
这样一来，在脏页回写完毕之后，MappedByteBuffer 在页表中就变成只读的了，这统统对用户态的我们都是透明的，当再次对 MappedByteBuffer 写入的时候就不是那么丝滑了，会触发写保护缺页中断（我们以为不会有缺页中断，其实是有的），在写保护中断的处置惩罚中，内核会重新将页表项 pte 变为可写，文件页标志为脏页。如果文件页正在回写，缺页中断会阻塞。如果脏页积聚的太多，这里也会同步回写脏页。
  1. static vm_fault_t wp_page_shared(struct vm_fault *vmf)
  2.     __releases(vmf->ptl)
  3. {
  4.     if (vma->vm_ops && vma->vm_ops->page_mkwrite) {
  5.         // 设置页表项为可写
  6.         // 标记文件页为脏页
  7.         // 如果文件页正在回写则阻塞等待
  8.         tmp = do_page_mkwrite(vmf);
  9.     }
  10.     // 判断是否需要同步回写脏页，
  11.     fault_dirty_shared_page(vma, vmf->page);
  12.     return VM_FAULT_WRITE;
  13. }
复制代码
以是并不是对 MappedByteBuffer 调用 mlock 之后就万事大吉了，在遇到脏页回写的时候，MappedByteBuffer 依然会发生写保护类型的缺页中断。在缺页中断处置惩罚中会等候脏页的回写，而且还可能会发生脏页的同步回写。这对 MappedByteBuffer 的写入性能会有非常大的影响。
在明白这些问题之后，下面我们继续来看 MappedByteBuffer 和 FileChannel 在不同数据集下对文件的写入性能测试：

运行结果：


在笔者的测试环境中，我们看到 MappedByteBuffer 在对文件的写入性能一路碾压 FileChannel，并没有出现被 FileChannel 反超的情况。但我们看到 MappedByteBuffer 从 4K 开始写入性能是在逐渐降落的，而 FileChannel 的写入性能却在一路升高。
根据上面的分析，我们可以推断出，后面随着数据量的增大，由于 MappedByteBuffer 缺页中断瓶颈的影响，在 512M 后面某一个数据集下，FileChannel 的写入性能最终是会凌驾 MappedByteBuffer 的。
在本末节的开头，笔者就夸大了，本末节值得参考的是 MappedByteBuffer 和 FileChannel 在不同数据集大小下的读写性能趋势走向，而不是具体的性能数值。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4