c++ - 有一个很长的缓冲区，但只使用最后 1GB 字节的数据。

Question

需要在 Linux 上用 C/C++ 编写一个应用程序，从套接字接收字节流并处理它们。总字节数可能接近 1TB。如果我有无限量的内存，我会把它全部放在内存中，这样我的应用程序就可以轻松地处理数据。在平面内存空间上做很多事情要容易得多，例如 memmem()、memcmp() ... 在循环缓冲区上，应用程序必须非常聪明才能意识到循环缓冲区。

我有大约 8G 的内存，但幸运的是，由于局部性，我的应用程序永远不需要从它收到的最新数据返回超过 1GB。有没有办法拥有一个 1TB 的缓冲区，只有最新的 1GB 数据映射到物理内存？如果可以，怎么做？

有什么想法吗？谢谢。

Answer 1

这是一个例子。它设置了一个完整的 TB 映射，但最初无法访问 ( PROT_NONE )。你，程序员，维护一个只能在内存中向上扩展和移动的窗口。示例程序使用一个 1.5 GB 的窗口，以 1,023,739,137 字节的步长推进它(mapping_use() 确保可用页面至少覆盖所需区域)，并且实际上修改每个窗口中的每个页面，只是为了当然。

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

typedef struct mapping  mapping;
struct mapping {
    unsigned char   *head;  /* Start of currently accessible region */
    unsigned char   *tail;  /* End of currently accessible region */ 
    unsigned char   *ends;  /* End of region */
    size_t           page;  /* Page size of this mapping */
};

/* Discard mapping.
*/
void mapping_free(mapping *const m)
{
    if (m && m->ends > m->head) {
        munmap(m->head, (size_t)(m->ends - m->head));
        m->head = NULL;
        m->tail = NULL;
        m->ends = NULL;
        m->page = 0;
    }
}

/* Move the accessible part up in memory, to [from..to).
*/
int mapping_use(mapping *const m, void *const from, void *const to)
{
    if (m && m->ends > m->head) {
        unsigned char *const head = ((unsigned char *)from <= m->head) ? m->head :
                                    ((unsigned char *)from >= m->ends) ? m->ends :
                                    m->head + m->page * (size_t)(((size_t)((unsigned char *)from - m->head)) / m->page);
        unsigned char *const tail = ((unsigned char *)to <= head) ? head :
                                    ((unsigned char *)to >= m->ends) ? m->ends :
                                    m->head + m->page * (size_t)(((size_t)((unsigned char *)to - m->head) + m->page - 1) / m->page); 

        if (head > m->head) {
            munmap(m->head, (size_t)(head - m->head));
            m->head = head;
        }

        if (tail > m->tail) {
#ifdef USE_MPROTECT
            mprotect(m->tail, (size_t)(tail - m->tail), PROT_READ | PROT_WRITE);
#else
            void *result;
            do {
                result = mmap(m->tail, (size_t)(tail - m->tail), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_FIXED | MAP_PRIVATE | MAP_NORESERVE, -1, (off_t)0);
            } while (result == MAP_FAILED && errno == EINTR);
            if (result == MAP_FAILED)
                return errno = ENOMEM;
#endif
            m->tail = tail;
        }

        return 0;
    }
    return errno = EINVAL;
}

/* Initialize a mapping.
*/
int mapping_create(mapping *const m, const size_t size)
{
    void  *base;
    size_t page, truesize;

    if (!m || size < (size_t)1)
        return errno = EINVAL;

    m->head = NULL;
    m->tail = NULL;
    m->ends = NULL;
    m->page = 0;

    /* Obtain default page size. */
    {
        long   value = sysconf(_SC_PAGESIZE);
        page = (size_t)value;
        if (value < 1L || (long)page != value)
            return errno = ENOTSUP;
    }

    /* Round size up to next multiple of page. */
    if (size % page)
        truesize = size + page - (size % page);
    else
        truesize = size;

    /* Create mapping. */
    do {
        errno = ENOTSUP;
        base = mmap(NULL, truesize, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE, -1, (off_t)0);
    } while (base == MAP_FAILED && errno == EINTR);
    if (base == MAP_FAILED)
        return errno;

    /* Success. */
    m->head = base;
    m->tail = base;
    m->ends = (unsigned char *)base + truesize;
    m->page = page;

    errno = 0;
    return 0;
}

static void memtouch(void *const ptr, const size_t size)
{
    if (ptr && size > 0) {
        unsigned char *mem = (unsigned char *)ptr;
        const size_t   step = 2048;
        size_t         n = size / (size_t)step - 1;

        mem[0]++;
        mem[size-1]++;

        while (n-->0) {
            mem += step;
            mem[0]++;
        }
    }
}

int main(void)
{
    const size_t   size = (size_t)1024 * (size_t)1024 * (size_t)1024 * (size_t)1024;
    const size_t   need = (size_t)1500000000UL;
    const size_t   step = (size_t)1023739137UL;
    unsigned char *base;
    mapping        map;
    size_t         i;

    if (mapping_create(&map, size)) {
        fprintf(stderr, "Cannot create a %zu-byte mapping: %m.\n", size);
        return EXIT_FAILURE;
    }

    printf("Have a %zu-byte mapping at %p to %p.\n", size, (void *)map.head, (void *)map.ends);
    fflush(stdout);


    base = map.head;

    for (i = 0; i <= size - need; i += step) {
        printf("Requesting %p to %p .. ", (void *)(base + i), (void *)(base + i + need));
        fflush(stdout);
        if (mapping_use(&map, base + i, base + i + need)) {
            printf("Failed (%m).\n");
            fflush(stdout);
            return EXIT_FAILURE;
        }
        printf("received %p to %p.\n", (void *)map.head, (void *)map.tail);
        fflush(stdout);
        memtouch(base + i, need);
    }

    mapping_free(&map);

    return EXIT_SUCCESS;
}

方法是双重的。首先，创建一个不可访问的 (PROT_NONE) 映射以保留必要的虚拟连续地址空间。如果我们省略此步骤，则可能会出现 malloc()。调用或类似获取此范围内的页面，这将破坏整个目的；单个 TB 长的映射。

其次，当可访问窗口延伸到区域中时，mprotect() (如果定义了 USE_MPROTECT)，或者 mmap()用于使所需的页面可访问。不再需要的页面完全取消映射。

编译运行使用

gcc -Wall -Wextra -std=c99 example.c -o example
time ./example

或者，使用 mmap()只有一次 mprotect()移动窗口，

gcc -DUSE_MPROTECT=1 -Wall -Wextra -std=c99 example.c -o example
time ./example

请注意，如果您没有至少 4GB 的物理内存，您可能不想运行测试。

在这台特定的机器上(i5-4200U 笔记本电脑，4GB RAM，Ubuntu x86_64 上的 3.13.0-62-generic 内核)，快速测试没有显示 mprotect() 之间有任何性能差异。和 mmap() , 在执行速度或驻留集大小方面。

如果有人费心编译和运行上面的代码，并且发现其中一个有可重复的优点/缺点(驻留集大小或使用时间)，我非常想知道它。还请定义您使用的内核和 CPU。

我不确定我应该扩展哪些细节，因为这非常简单，真的，而且 Linux 手册页项目 man 2 mmap 和 man 2 mprotect 页面非常具有描述性。如果您对这种方法或程序有任何疑问，我很乐意尝试详细说明。