Question

这个想法相对简单，但我发现实施有些复杂，所以我想知道它现在是否可能。

我想做的一个例子是在a中生成一些数据 buffer，然后将此缓冲区的内容映射到文件。代替内存空间实际上填充了内容文件，我喜欢要传输的原始缓冲区的内容到系统缓存（应该是零复制操作）和立即弄脏（这会将数据刷新到磁盘最终）。

当然，我提到的复杂性是缓冲区应该被解除分配并取消映射（因为数据现在由系统缓存负责），我也不知道如何做到这一点。

重要的方面是：

程序可以控制文件创建链接的时间。
该程序不需要预测文件的大小，也不需要在数据集增长时重新映射它。相反，它可以重新分配初始缓冲区（使用有效的内存分配器），直到它满足（它确定数据集不再增长），然后再将其映射到文件。
数据仍然可以通过相同的虚拟内存地址访问，即使在映射到文件后仍然仍然没有单个内存内副本

一个假设是：

我们可以使用任意内存分配器（或一般的内存管理方案），它可以比mmap / mremap更有效地管理动态缓冲区，因为后者必须处理文件系统来增长/缩小文件，总是会慢一些。

那么，（1）这些要求是否受到限制？（2）这个假设是否正确？

PS：我不得不随意挑选这个问题的标签，但我也有兴趣听听BSD和Windows如何做到这一点。当然，如果POSIX API允许这样做，那就太好了。

更新：我在一个缓冲区中调用一个私有内存空间（专用于具有正常VMM的任何操作系统中的进程/任务）在主内存中分配。高级目标涉及使用另一个输入（在我的情况下是网络）生成任意大小的数据集，然后一旦生成，就可以长时间访问（到网络和进程本身）），在此过程中将其保存到磁盘。

如果我将数据集保存在私有内存中并正常写出来，那么当操作系统需要空间时，它们就会被交换，因为它们已经在磁盘上，所以有点愚蠢。

如果我映射另一个区域，那么我必须将缓冲区的内容复制到该区域（驻留在系统缓存中），这也是一个愚蠢的事情，因为我之后不会使用该缓冲区

我看到的另一种选择是编写或使用一个完整的用户空间缓存读取和写入磁盘本身，以确保（a）页面不会被无用地换出，并且（b）该过程不会＆＃ 39;为自己保留太多内存，无论如何都不可能做到最佳（更好的让内核完成它的工作），而这根本不是一条我觉得值得下降的道路（太复杂而不能获得更少的收益）。 / p>
更新：考虑Nominal Animal的答案，要求2和3不是问题。当然，这意味着假设是不正确的，因为他证明了几乎是这种情况（开销很小）。我也放宽了要求1，O_TMPFILE确实是完美的。

更新： A recent article on LWN提到中间的某个地方：＆＃34;这可能是通过一个实际上不会导致I / O的特殊写操作来完成的，或者使用系统调用将物理页面转移到页面缓存中＃34; 。这表明，实际上，目前（2014年4月）至少在Linux（以及可能的其他操作系统）上无法做到这一点，更不用说标准API了。这篇文章是关于PostgreSQL的，但问题是相同的，除了这个问题的具体要求，这些问题在文章中没有定义。

Answer 1

对于这个问题，这不是一个令人满意的答案;更像是评论链的延续。

这是一个测试程序，可以用来衡量使用文件支持的内存映射而不是匿名内存映射的开销。

请注意，列出的work()函数只会使用随机数据填充内存映射。更实际的是，它应该至少模拟实际使用中预期的访问模式。

#define  _POSIX_C_SOURCE 200809L
#define  _GNU_SOURCE
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <time.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>

/* Xorshift random number generator.
*/

static uint32_t xorshift_state[4] = {
    123456789U,
    362436069U,
    521288629U,
    88675123U
};

static int xorshift_setseed(const void *const data, const size_t len)
{
    uint32_t state[4] = { 0 };

    if (len < 1)
        return ENOENT;
    else
    if (len < sizeof state)
        memcpy(state, data, len);
    else
        memcpy(state, data, sizeof state);

    if (state[0] || state[1] || state[2] || state[3]) {
        xorshift_state[0] = state[0];
        xorshift_state[1] = state[1];
        xorshift_state[2] = state[2];
        xorshift_state[3] = state[3];
        return 0;
    }

    return EINVAL;
}

static uint32_t xorshift_u32(void)
{
    const uint32_t temp = xorshift_state[0] ^ (xorshift_state[0] << 11U);
    xorshift_state[0] = xorshift_state[1];
    xorshift_state[1] = xorshift_state[2];
    xorshift_state[2] = xorshift_state[3];
    return xorshift_state[3] ^= (temp >> 8U) ^ temp ^ (xorshift_state[3] >> 19U);
}

/* Wallclock timing functions.
*/

static struct timespec wallclock_started;

static void wallclock_start(void)
{
    clock_gettime(CLOCK_REALTIME, &wallclock_started);
}

static double wallclock_stop(void)
{
    struct timespec wallclock_stopped;
    clock_gettime(CLOCK_REALTIME, &wallclock_stopped);
    return difftime(wallclock_stopped.tv_sec, wallclock_started.tv_sec)
         + (double)(wallclock_stopped.tv_nsec - wallclock_started.tv_nsec) / 1000000000.0;
}

/* Accessor function. This needs to read/modify/write the mapping,
 * simulating the actual work done onto the mapping.
*/
static void work(void *const area, size_t const length)
{
    uint32_t *const data = (uint32_t *)area;
    size_t          size = length / sizeof data[0];
    size_t          i;

    /* Add xorshift data. */
    for (i = 0; i < size; i++)
        data[i] += xorshift_u32();
}

int main(int argc, char *argv[])
{
    long   page, size, delta, maxsize, steps;
    int    fd, result;
    void  *map, *old;
    char   dummy;
    double seconds;

    page = sysconf(_SC_PAGESIZE);

    if (argc < 5 || argc > 6 || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
        fprintf(stderr, "\n");
        fprintf(stderr, "Usage: %s [ -h | --help ]\n", argv[0]);
        fprintf(stderr, "       %s MAPFILE SIZE DELTA MAXSIZE [ SEEDSTRING ]\n", argv[0]);
        fprintf(stderr, "Where:\n");
        fprintf(stderr, "       MAPFILE     backing file, '-' for none\n");
        fprintf(stderr, "       SIZE        initial map size\n");
        fprintf(stderr, "       DELTA       map size change\n");
        fprintf(stderr, "       MAXSIZE     final size of the map\n");
        fprintf(stderr, "       SEEDSTRING  seeds the Xorshift PRNG\n");
        fprintf(stderr, "Note: sizes must be page aligned, each page being %ld bytes.\n", (long)page);
        fprintf(stderr, "\n");
        return 1;
    }

    if (argc >= 6) {
        if (xorshift_setseed(argv[5], strlen(argv[5]))) {
            fprintf(stderr, "%s: Invalid seed string for the Xorshift generator.\n", argv[5]);
            return 1;
        } else {
            fprintf(stderr, "Xorshift initialized with { %lu, %lu, %lu, %lu }.\n",
                            (unsigned long)xorshift_state[0],
                            (unsigned long)xorshift_state[1],
                            (unsigned long)xorshift_state[2],
                            (unsigned long)xorshift_state[3]);
            fflush(stderr);
        }
    }

    if (sscanf(argv[2], " %ld %c", &size, &dummy) != 1) {
        fprintf(stderr, "%s: Invalid map size.\n", argv[2]);
        return 1;
    } else
    if (size < page || size % page) {
        fprintf(stderr, "%s: Map size must be a multiple of page size (%ld).\n", argv[2], page);
        return 1;
    }

    if (sscanf(argv[3], " %ld %c", &delta, &dummy) != 1) {
        fprintf(stderr, "%s: Invalid map size change.\n", argv[2]);
        return 1;
    } else
    if (delta % page) {
        fprintf(stderr, "%s: Map size change must be a multiple of page size (%ld).\n", argv[3], page);
        return 1;
    }

    if (delta) {
        if (sscanf(argv[4], " %ld %c", &maxsize, &dummy) != 1) {
            fprintf(stderr, "%s: Invalid final map size.\n", argv[3]);
            return 1;
        } else
        if (maxsize < page || maxsize % page) {
            fprintf(stderr, "%s: Final map size must be a multiple of page size (%ld).\n", argv[4], page);
            return 1;
        }

        steps = (maxsize - size) / delta;
        if (steps < 0L)
            steps = -steps;

    } else {
        maxsize = size;
        steps = 0L;
    }

    /* Time measurement includes the file open etc. overheads.
    */
    wallclock_start();

    if (strlen(argv[1]) < 1 || !strcmp(argv[1], "-"))
        fd = -1;
    else {
        do {
            fd = open(argv[1], O_RDWR | O_CREAT | O_EXCL, 0600);
        } while (fd == -1 && errno == EINTR);
        if (fd == -1) {
            fprintf(stderr, "%s: %s.\n", argv[1], strerror(errno));
            return 1;
        }

        do {
            result = ftruncate(fd, (off_t)size);
        } while (result == -1 && errno == EINTR);
        if (result == -1) {
            fprintf(stderr, "%s: %s.\n", argv[1], strerror(errno));
            unlink(argv[1]);
            do {
                result = close(fd);
            } while (result == -1 && errno == EINTR);
            return 1;
        }

        result = posix_fadvise(fd, 0, size, POSIX_FADV_RANDOM);
    }

    /* Initial mapping. */
    if (fd == -1)
        map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, fd, 0);
    else
        map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NORESERVE, fd, 0);
    if (map == MAP_FAILED) {
        fprintf(stderr, "Memory map failed: %s.\n", strerror(errno));
        if (fd != -1) {
            unlink(argv[1]);
            do {
                result = close(fd);
            } while (result == -1 && errno == EINTR);
        }
        return 1;
    }
    result = posix_madvise(map, size, POSIX_MADV_RANDOM);

    work(map, size);

    while (steps-->0L) {

        if (fd != -1) {
            do {
                result = ftruncate(fd, (off_t)(size + delta));
            } while (result == -1 && errno == EINTR);
            if (result == -1) {
                fprintf(stderr, "%s: Cannot grow file: %s.\n", argv[1], strerror(errno));
                unlink(argv[1]);
                do {
                    result = close(fd);
                } while (result == -1 && errno == EINTR);
                return 1;
            }
            result = posix_fadvise(fd, 0, size, POSIX_FADV_RANDOM);
        }

        old = map;
        map = mremap(map, size, size + delta, MREMAP_MAYMOVE);
        if (map == MAP_FAILED) {
            fprintf(stderr, "Cannot remap memory map: %s.\n", strerror(errno));
            munmap(old, size);
            if (fd != -1) {
                unlink(argv[1]);
                do {
                    result = close(fd);
                } while (result == -1 && errno == EINTR);
            }
            return 1;
        }
        size += delta;
        result = posix_madvise(map, size, POSIX_MADV_RANDOM);

        work(map, size);
    }

    /* Timing does not include file renaming.
    */
    seconds = wallclock_stop();

    munmap(map, size);
    if (fd != -1) {
        unlink(argv[1]);
        do {
            result = close(fd);
        } while (result == -1 && errno == EINTR);
    }

    printf("%.9f seconds elapsed.\n", seconds);
    return 0;
}

如果将上述内容保存为bench.c，则可以使用

进行编译

gcc -W -Wall -O3 bench.c -lrt -o bench

不带参数运行它以查看用法。

在我的机器上，在ext4文件系统上运行测试

./bench - 4096 4096 4096000
./bench testfile 4096 4096 4096000

匿名内存映射的挂钟时间为1.307秒，文件支持的内存映射为1.343秒，这意味着文件支持的映射速度大约低2.75％。

此测试从一页内存映射开始，然后将其放大一页一千次。对于像4096000 4096 8192000这样的测试，差异甚至更小。测量的时间确实包括构造初始文件（并使用posix_fallocate()在磁盘上为文件分配块。）

在tmpfs上运行测试，通过swRAID0在ext4上运行测试，在同一台机器上通过swRAID1运行ext4，似乎不会影响结果;所有的差异都会在噪音中消失。

虽然我更愿意在制作任何广泛的语句之前在多台机器和内核版本上测试它，但我确实知道内核如何管理这些内存映射。因此，基于上述和我自己的经验，我将提出以下主张：

与匿名内存映射相比，使用文件支持的内存映射不会导致显着减速，甚至与malloc() / realloc() / free()进行比较。我预计所有实际使用案例的差异都不到5％，而典型的实际用例最多只有1％;更少，如果调整大小与访问地图的频率相比很少。

对于user2266481，上述意味着只需在目标文件系统上创建一个临时文件来保存内存映射即可。（请注意，可以创建临时文件而不允许任何人访问它，模式0，因为只有在打开文件时才会检查访问模式。）当内容为最终形式时，ftruncate()和{{1然后使用msync()将最终文件硬链接到临时文件。最后，取消链接临时文件并关闭临时文件描述符，任务应以接近最佳的效率完成。

是否可以将现有缓冲区映射到新文件？

1 个答案: