C++ `mmap` 与 `mlock`：高吞吐量数据处理与内存锁定避免换页

好的，各位观众，欢迎来到今天的C++性能提升小课堂！今天我们聊聊两个好基友：mmap 和 mlock，以及他们如何帮助我们打造高吞吐量的数据处理系统，并且避免那些让人头疼的内存换页问题。准备好了吗？系好安全带，我们发车啦！

第一站：mmap – 让文件像内存一样简单

首先，我们来认识一下mmap，全称 Memory Map，内存映射。简单来说，它可以把一个文件或者设备映射到进程的地址空间。这意味着，你可以像访问内存一样直接读写文件，而不需要传统的read/write系统调用。

想象一下，你想要读取一个巨大的日志文件，传统的做法是：

打开文件。
分配一块缓冲区。
调用read函数读取数据到缓冲区。
处理缓冲区的数据。
重复步骤3和4直到文件结束。
关闭文件。

这种方式需要频繁的系统调用和数据拷贝，效率比较低。

而有了mmap，你只需要：

打开文件。
调用mmap将文件映射到内存。
像访问数组一样访问文件内容。
解除映射。
关闭文件。

是不是简单多了？

让我们看一个简单的例子：

#include <iostream>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <string.h> // For strerror

int main() {
  const char* filename = "test.txt";
  const char* data = "Hello, mmap world!";
  size_t data_len = strlen(data);

  // 1. 创建并写入文件
  int fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0666);
  if (fd == -1) {
    std::cerr << "Error opening file: " << strerror(errno) << std::endl;
    return 1;
  }

  // 扩展文件大小，否则mmap写入会出错
  if (ftruncate(fd, data_len) == -1) {
    std::cerr << "Error truncating file: " << strerror(errno) << std::endl;
    close(fd);
    return 1;
  }

  ssize_t written = write(fd, data, data_len);
  if (written != data_len) {
    std::cerr << "Error writing to file: " << strerror(errno) << std::endl;
    close(fd);
    return 1;
  }
  close(fd);

  // 2. 重新打开文件，用于mmap
  fd = open(filename, O_RDWR);
  if (fd == -1) {
    std::cerr << "Error opening file for mmap: " << strerror(errno) << std::endl;
    return 1;
  }

  // 获取文件大小
  struct stat sb;
  if (fstat(fd, &sb) == -1) {
    std::cerr << "Error getting file size: " << strerror(errno) << std::endl;
    close(fd);
    return 1;
  }
  size_t file_size = sb.st_size;

  // 3. 调用mmap
  char* mapped_data = (char*)mmap(nullptr, file_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  if (mapped_data == MAP_FAILED) {
    std::cerr << "Error mapping file: " << strerror(errno) << std::endl;
    close(fd);
    return 1;
  }

  // 4. 像访问内存一样访问文件内容
  std::cout << "Original data: " << mapped_data << std::endl;

  // 修改映射区域的数据
  strcpy(mapped_data, "Modified data!");  // 注意文件大小，这里要确保写入的数据长度不超过文件大小

  // 5. 同步修改到磁盘（可选）
  if (msync(mapped_data, file_size, MS_SYNC) == -1) {
    std::cerr << "Error syncing changes: " << strerror(errno) << std::endl;
  }

  std::cout << "Modified data: " << mapped_data << std::endl;

  // 6. 解除映射
  if (munmap(mapped_data, file_size) == -1) {
    std::cerr << "Error unmapping file: " << strerror(errno) << std::endl;
  }

  // 7. 关闭文件
  close(fd);

  return 0;
}

这个例子做了以下事情：

创建并写入一个名为test.txt的文件。
重新打开这个文件。
使用mmap将文件映射到内存。
直接修改映射区域的数据。
使用msync将修改同步到磁盘（可选）。
解除映射。
关闭文件。

mmap的优点：

减少系统调用： 避免了频繁的read/write系统调用，提高了效率。
零拷贝： 数据不需要从内核空间拷贝到用户空间，减少了内存拷贝的开销。
方便： 可以像访问内存一样访问文件内容，简化了代码。
适用于大型文件： 特别适合处理大型文件，因为不需要一次性将整个文件加载到内存。

mmap的缺点：

地址空间限制： 受限于进程的地址空间大小。
可能出现总线错误： 如果访问了超出文件大小的区域，可能会导致总线错误。
需要同步： 如果需要将修改同步到磁盘，需要手动调用msync。
文件大小改变问题: 如果文件被其他进程截断，你的mmap映射可能会失效，需要重新映射。

mmap的适用场景：

大型日志文件处理： 快速读取和分析大型日志文件。
共享内存： 实现进程间共享内存，提高通信效率。
数据库： 某些数据库使用mmap来提高数据访问速度。
视频处理： 读取和处理大型视频文件。

第二站：mlock – 让你的数据永不离开内存

现在，我们来认识一下mlock，内存锁定。它的作用是将指定的内存区域锁定在物理内存中，防止被交换到磁盘上。

想象一下，你有一个高性能的缓存系统，里面的数据非常重要，绝对不能被换页出去。如果数据被换页到磁盘上，下次访问的时候就需要从磁盘读取，这将大大降低性能。

这时，mlock就派上用场了。它可以保证你的数据始终驻留在内存中，从而避免了换页带来的性能损失。

#include <iostream>
#include <sys/mman.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

int main() {
  size_t page_size = getpagesize(); // 获取系统页大小
  size_t region_size = page_size * 4; // 分配4个页大小的区域

  // 1. 分配内存
  void* addr = mmap(nullptr, region_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
  if (addr == MAP_FAILED) {
    std::cerr << "Error mapping memory: " << strerror(errno) << std::endl;
    return 1;
  }

  // 2. 写入一些数据
  char* data = (char*)addr;
  strcpy(data, "This is important data that should not be swapped out.");

  std::cout << "Data before mlock: " << data << std::endl;

  // 3. 使用mlock锁定内存
  if (mlock(addr, region_size) == -1) {
    std::cerr << "Error locking memory: " << strerror(errno) << std::endl;
    munmap(addr, region_size);
    return 1;
  }

  std::cout << "Memory locked successfully." << std::endl;

  // 模拟长时间运行，让操作系统有机会换页
  sleep(10);

  std::cout << "Data after sleep (should still be valid): " << data << std::endl;

  // 4. 使用munlock解锁内存
  if (munlock(addr, region_size) == -1) {
    std::cerr << "Error unlocking memory: " << strerror(errno) << std::endl;
  }

  std::cout << "Memory unlocked successfully." << std::endl;

  // 5. 解除映射
  if (munmap(addr, region_size) == -1) {
    std::cerr << "Error unmapping memory: " << strerror(errno) << std::endl;
    return 1;
  }

  return 0;
}

这个例子做了以下事情：

使用mmap分配一块内存。
写入一些数据到这块内存。
使用mlock将这块内存锁定在物理内存中。
模拟长时间运行，让操作系统有机会换页。
使用munlock解锁内存。
解除映射。

mlock的优点：

避免换页： 保证数据始终驻留在内存中，避免了换页带来的性能损失。
提高性能： 特别适用于对延迟敏感的应用，如实时系统和高性能缓存。
安全性： 可以防止敏感数据被交换到磁盘上，提高安全性。

mlock的缺点：

资源占用： 锁定内存会占用物理内存，减少了可用内存。
权限限制： 需要root权限才能锁定大量内存。
可能导致系统崩溃： 如果锁定了过多的内存，可能导致系统内存不足，甚至崩溃。
不适用于所有情况: 大部分应用场景下，换页机制是合理的，盲目使用mlock可能适得其反。

mlock的适用场景：

实时系统： 保证实时任务的数据始终驻留在内存中，避免延迟。
高性能缓存： 提高缓存的访问速度。
安全应用： 防止敏感数据被交换到磁盘上。
数据库： 某些数据库使用mlock来提高数据访问速度。

第三站：mmap + mlock – 完美搭档，性能起飞

现在，我们把mmap和mlock组合起来，看看它们能擦出什么样的火花。

想象一下，你有一个需要处理大量数据的应用程序，这些数据存储在文件中。你希望能够像访问内存一样快速访问这些数据，并且保证这些数据始终驻留在内存中，不会被换页出去。

这时，mmap和mlock就是你的最佳选择。你可以使用mmap将文件映射到内存，然后使用mlock将映射区域锁定在物理内存中。

#include <iostream>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>

int main() {
  const char* filename = "large_data.bin";
  size_t file_size = 1024 * 1024 * 100; // 100MB
  // 1. 创建一个大文件
  int fd = open(filename, O_RDWR | O_CREAT, 0666);
  if (fd == -1) {
    std::cerr << "Error opening file: " << strerror(errno) << std::endl;
    return 1;
  }

  if (ftruncate(fd, file_size) == -1) {
        std::cerr << "Error truncating file: " << strerror(errno) << std::endl;
        close(fd);
        return 1;
  }

  close(fd);

  // 2. 重新打开文件
  fd = open(filename, O_RDWR);
  if (fd == -1) {
    std::cerr << "Error opening file: " << strerror(errno) << std::endl;
    return 1;
  }

  // 3. 使用mmap将文件映射到内存
  void* mapped_data = mmap(nullptr, file_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  if (mapped_data == MAP_FAILED) {
    std::cerr << "Error mapping file: " << strerror(errno) << std::endl;
    close(fd);
    return 1;
  }

  // 4. 使用mlock锁定内存
  if (mlock(mapped_data, file_size) == -1) {
    std::cerr << "Error locking memory: " << strerror(errno) << std::endl;
    munmap(mapped_data, file_size);
    close(fd);
    return 1;
  }

  std::cout << "File mapped and memory locked successfully." << std::endl;

  // 5. 模拟数据处理
  char* data = (char*)mapped_data;
  for (size_t i = 0; i < file_size; ++i) {
    data[i] = (char)(i % 256); // 写入一些数据
  }

  // 6. 模拟长时间运行
  sleep(10);

  // 7. 使用munlock解锁内存
  if (munlock(mapped_data, file_size) == -1) {
    std::cerr << "Error unlocking memory: " << strerror(errno) << std::endl;
  }

  // 8. 使用munmap解除映射
  if (munmap(mapped_data, file_size) == -1) {
    std::cerr << "Error unmapping file: " << strerror(errno) << std::endl;
  }

  // 9. 关闭文件
  close(fd);

  std::cout << "File unmapped and memory unlocked successfully." << std::endl;

  return 0;
}

这个例子做了以下事情：

创建一个大文件。
使用mmap将文件映射到内存。
使用mlock将映射区域锁定在物理内存中。
模拟数据处理。
模拟长时间运行。
使用munlock解锁内存。
使用munmap解除映射。
关闭文件。

mmap + mlock的优点：

高性能： 结合了mmap的快速访问和mlock的内存锁定，实现了高性能的数据处理。
低延迟： 避免了换页带来的延迟，适用于对延迟敏感的应用。
适用于大型数据： 可以处理大型数据文件，而不需要一次性加载到内存。

mmap + mlock的缺点：

资源占用： 锁定了大量的物理内存。
权限限制： 需要root权限才能锁定大量内存。
可能导致系统崩溃： 如果锁定过多的内存，可能导致系统内存不足，甚至崩溃。
复杂性： 需要同时管理文件映射和内存锁定，增加了代码的复杂性。

mmap + mlock的适用场景：

高性能数据库： 提高数据库的访问速度。
实时数据处理： 处理实时数据流，保证低延迟。
金融交易系统： 保证交易数据的快速访问和处理。
科学计算： 处理大型科学数据集。

第四站：注意事项与最佳实践

在使用mmap和mlock时，有一些注意事项和最佳实践需要牢记在心：

错误处理： 始终检查mmap和mlock的返回值，并处理可能出现的错误。
内存大小： 确保分配和锁定的内存大小是正确的，避免访问越界或锁定过多的内存。
权限： 确保你有足够的权限来锁定内存。
同步： 如果需要将修改同步到磁盘，记得调用msync。
解锁： 在不再需要锁定内存时，记得调用munlock解锁内存。
资源管理： 谨慎使用，避免过度占用系统资源，导致系统崩溃。
文件大小: 使用mmap时，要注意文件大小变化可能导致映射失效，需要重新映射。
MAP_SHARED vs MAP_PRIVATE: MAP_SHARED 映射的修改会同步到磁盘，而 MAP_PRIVATE 不会，选择合适的模式。
分页对齐: mlock通常以页为单位进行锁定，确保锁定区域是页对齐的。

第五站：一些有趣的灵魂拷问

mmap真的比read/write快吗？
- 理论上是快的，因为减少了系统调用和内存拷贝。但是，在某些情况下，如果文件很小，或者你的硬盘速度很快，read/write可能也不会慢太多。
mlock越多越好吗？
- 当然不是！mlock会占用物理内存，如果锁定过多的内存，会导致系统内存不足，甚至崩溃。要根据实际情况合理使用mlock。
mmap和mlock是银弹吗？
- 当然不是！没有银弹！mmap和mlock只是提高性能的工具，要根据实际情况选择合适的工具。

总结

mmap和mlock是C++中两个非常强大的工具，可以帮助我们打造高吞吐量的数据处理系统，并且避免那些让人头疼的内存换页问题。但是，它们也有一些缺点和限制，需要谨慎使用。

希望今天的课程能够帮助大家更好地理解和使用mmap和mlock。记住，没有最好的工具，只有最合适的工具。

感谢大家的观看，下课！

发表回复 取消回复

发表回复取消回复