c - 在 Linux 中实现零页的最快方法

Question

我需要在 Linux 中清除大地址范围(一次 200 页)。我尝试了两种方法-

使用 memset - 清除地址范围的最简单方法。执行速度比方法 2 慢一点。

使用 munmap/mmap - 我调用 munmap在地址范围上，然后 mmap使用相同的权限再次访问相同的地址。自 MAP_ANONYMOUS通过，页面被清除。

第二种方法使基准测试的运行速度提高 5-10%。基准当然不仅仅是清除页面。
如果我理解正确，这是因为操作系统有一个映射到地址范围的零页池。

但我不喜欢这种方式，因为 munmap和 mmap不是原子的。从某种意义上说，另一个 mmap (以 NULL 作为第一个参数)同时完成可能会使我的地址范围不可用。

所以我的问题是 Linux 是否提供了一个系统调用，可以将物理页面换出具有零页面的地址范围？

我试图查看 glibc 的来源(特别是 memset )，看看他们是否使用任何技术来有效地做到这一点。但我找不到任何东西。

Answer 1

memset()似乎比 mmap() 快大约一个数量级获得一个新的零填充页面，至少在我现在可以访问的 Solaris 11 服务器上。我强烈怀疑 Linux 会产生类似的结果。

我写了一个小的基准程序:

#include <stdio.h>
#include <sys/mman.h>
#include <string.h>
#include <strings.h>

#include <sys/time.h>

#define NUM_BLOCKS ( 512 * 1024 )
#define BLOCKSIZE ( 4 * 1024 )

int main( int argc, char **argv )
{
    int ii;

    char *blocks[ NUM_BLOCKS ];

    hrtime_t start = gethrtime();

    for ( ii = 0; ii < NUM_BLOCKS; ii++ )
    {
        blocks[ ii ] = mmap( NULL, BLOCKSIZE,
            PROT_READ | PROT_WRITE,
            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0 );
        // force the creation of the mapping
        blocks[ ii ][ ii % BLOCKSIZE ] = ii;
    }

    printf( "setup time:    %lf sec\n",
        ( gethrtime() - start ) / 1000000000.0 );

    for ( int jj = 0; jj < 4; jj++ )
    {
        start = gethrtime();

        for ( ii = 0; ii < NUM_BLOCKS; ii++ )
        {
            blocks[ ii ] = mmap( blocks[ ii ],
                BLOCKSIZE, PROT_READ | PROT_WRITE,
                MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0 );
            blocks[ ii ][ ii % BLOCKSIZE ] = 0;
        }

        printf( "mmap() time:   %lf sec\n",
            ( gethrtime() - start ) / 1000000000.0 );
        start = gethrtime();

        for ( ii = 0; ii < NUM_BLOCKS; ii++ )
        {
            memset( blocks[ ii ], 0, BLOCKSIZE );
        }

        printf( "memset() time: %lf sec\n",
            ( gethrtime() - start ) / 1000000000.0 );
    }

    return( 0 );
}

请注意，只需在页面中的任何位置写入单个字节即可强制创建物理页面。

我在我的 Solaris 11 文件服务器(我现在在裸机上运行的唯一 POSIX 风格的系统)上运行它。我没有测试 madvise()在我的 Solaris 系统上，因为 Solaris 与 Linux 不同，不保证映射将重新填充为零填充的页面，只保证“系统开始释放资源”。

结果:

setup time:    11.144852 sec
mmap() time:   15.159650 sec
memset() time: 1.817739 sec
mmap() time:   15.029283 sec
memset() time: 1.788925 sec
mmap() time:   15.083473 sec
memset() time: 1.780283 sec
mmap() time:   15.201085 sec
memset() time: 1.771827 sec

memset()几乎快了一个数量级。有机会时，我会在 Linux 上重新运行该基准测试，但它可能必须在 VM(AWS 等)上运行

这并不奇怪 - mmap()成本很高，而且内核有时仍需要将页面归零。

有趣的是，注释掉一行

        for ( ii = 0; ii < NUM_BLOCKS; ii++ )
        {
            blocks[ ii ] = mmap( blocks[ ii ],
                BLOCKSIZE, PROT_READ | PROT_WRITE,
                MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0 );
            //blocks[ ii ][ ii % BLOCKSIZE ] = 0;
        }

产生这些结果:

setup time:    10.962788 sec
mmap() time:   7.524939 sec
memset() time: 10.418480 sec
mmap() time:   7.512086 sec
memset() time: 10.406675 sec
mmap() time:   7.457512 sec
memset() time: 10.296231 sec
mmap() time:   7.420942 sec
memset() time: 10.414861 sec

强制创建物理映射的负担已转移到 memset()调用，只留下隐含的 munmap()在测试循环中，当 MAP_FIXED 时映射被破坏 mmap()电话取代了他们。请注意，只是 munmap()比将页面保持在地址空间中的时间长约 3-4 倍， memset()将它们归零。
mmap()费用真的不是 mmap()/ munmap()系统调用本身，是新页面需要大量的幕后 CPU 周期来创建实际的物理映射，而这在 mmap() 中不会发生。系统调用本身 - 它发生在之后，当进程访问内存页面时。

如果您怀疑结果，请注意 this LMKL post from Linus Torvalds himself :

...

HOWEVER, playing games with the virtual memory mapping is very expensive in itself. It has a number of quite real disadvantages that people tend to ignore because memory copying is seen as something very slow, and sometimes optimizing that copy away is seen as an obvious improvment.

Downsides to mmap:

• quite noticeable setup and teardown costs. And I mean noticeable. It's things like following the page tables to unmap everything cleanly. It's the book-keeping for maintaining a list of all the mappings. It's The TLB flush needed after unmapping stuff.
• ...

使用 Solaris Studio's collect 分析代码和 analyzer tools产生了以下输出:

Source File: mm.c

Inclusive        Inclusive        Inclusive         
Total CPU Time   Sync Wait Time   Sync Wait Count   Name
sec.             sec.                               
                                                      1. #include <stdio.h>
                                                      2. #include <sys/mman.h>
                                                      3. #include <string.h>
                                                      4. #include <strings.h>
                                                      5. 
                                                      6. #include <sys/time.h>
                                                      7. 
                                                      8. #define NUM_BLOCKS ( 512 * 1024 )
                                                      9. #define BLOCKSIZE ( 4 * 1024 )
                                                     10. 
                                                     11. int main( int argc, char **argv )
                                                         <Function: main>
 0.011           0.               0                  12. {
                                                     13.     int ii;
                                                     14. 
                                                     15.     char *blocks[ NUM_BLOCKS ];
                                                     16. 
 0.              0.               0                  17.     hrtime_t start = gethrtime();
                                                     18. 
 0.129           0.               0                  19.     for ( ii = 0; ii < NUM_BLOCKS; ii++ )
                                                     20.     {
                                                     21.         blocks[ ii ] = mmap( NULL, BLOCKSIZE,
                                                     22.             PROT_READ | PROT_WRITE,
 3.874           0.               0                  23.             MAP_ANONYMOUS | MAP_PRIVATE, -1, 0 );
                                                     24.         // force the creation of the mapping
 7.928           0.               0                  25.         blocks[ ii ][ ii % BLOCKSIZE ] = ii;
                                                     26.     }
                                                     27. 
                                                     28.     printf( "setup time:    %lf sec\n",
 0.              0.               0                  29.         ( gethrtime() - start ) / 1000000000.0 );
                                                     30. 
 0.              0.               0                  31.     for ( int jj = 0; jj < 4; jj++ )
                                                     32.     {
 0.              0.               0                  33.         start = gethrtime();
                                                     34. 
 0.560           0.               0                  35.         for ( ii = 0; ii < NUM_BLOCKS; ii++ )
                                                     36.         {
                                                     37.             blocks[ ii ] = mmap( blocks[ ii ],
                                                     38.                 BLOCKSIZE, PROT_READ | PROT_WRITE,
33.432           0.               0                  39.                 MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0 );
29.535           0.               0                  40.             blocks[ ii ][ ii % BLOCKSIZE ] = 0;
                                                     41.         }
                                                     42. 
                                                     43.         printf( "mmap() time:   %lf sec\n",
 0.              0.               0                  44.             ( gethrtime() - start ) / 1000000000.0 );
 0.              0.               0                  45.         start = gethrtime();
                                                     46. 
 0.101           0.               0                  47.         for ( ii = 0; ii < NUM_BLOCKS; ii++ )
                                                     48.         {
 7.362           0.               0                  49.             memset( blocks[ ii ], 0, BLOCKSIZE );
                                                     50.         }
                                                     51. 
                                                     52.         printf( "memset() time: %lf sec\n",
 0.              0.               0                  53.             ( gethrtime() - start ) / 1000000000.0 );
                                                     54.     }
                                                     55. 
 0.              0.               0                  56.     return( 0 );
 0.              0.               0                  57. }

                                                    Compile flags:  /opt/SUNWspro/bin/cc -g -m64  mm.c -W0,-xp.XAAjaAFbs71a00k.

请注意在 mmap() 上花费的大量时间，以及在每个新映射的页面中设置单个字节。

这是来自 analyzer 的概述工具。注意大量的系统时间:



消耗的大量系统时间是映射和取消映射物理页面所花费的时间。

此时间线显示所有时间何时消耗:



浅绿色是系统时间 - 这一切都在 mmap() 中循环。您可以看到当 memset() 切换到深绿色用户时间时循环运行。我突出显示了其中一个实例，以便您了解当时发生的情况。

来自 Linux VM 的更新结果:

setup time:    2.567396 sec
mmap() time:   2.971756 sec
memset() time: 0.654947 sec
mmap() time:   3.149629 sec
memset() time: 0.658858 sec
mmap() time:   2.800389 sec
memset() time: 0.647367 sec
mmap() time:   2.915774 sec
memset() time: 0.646539 sec

这与我昨天在评论中所说的完全一致:FWIW，我运行的快速测试表明对 memset() 的简单单线程调用比重做快 5 到 10 倍 mmap()
我根本不明白对 mmap() 的这种迷恋. mmap()是一个非常昂贵的调用，它是一个强制的单线程操作——机器上只有一组物理内存。 mmap()不仅是 S-L-O-W ，它会影响整个进程地址空间和整个主机上的 VM 系统。

使用任何形式的 mmap()仅仅将内存页归零会适得其反。首先，页面不会免费归零 - 有些事情必须 memset()他们来清除它们。添加拆卸并重新创建内存映射到该 memset() 只是没有任何意义。只是为了清除一页 RAM。
memset()还有一个好处就是可以同时有多个线程清除内存。更改内存映射是一个单线程过程。