【发布时间】：2017-10-15 12:33:54
【问题描述】：
我们的软件在内存中构建了一个大约 80 GB 的数据结构。然后它可以直接使用此数据结构进行计算，也可以将其转储到磁盘以便之后可以重复使用多次。在这个数据结构中发生了很多随机内存访问。
对于更大的输入，此数据结构可能会变得更大（我们最大的一个超过 300 GB）并且我们的服务器有足够的内存来保存 RAM 中的所有内容。
如果数据结构被转储到磁盘，它会被 mmap 加载回地址空间，强制进入 os 页面缓存，最后被 mlocked（代码在末尾）。
问题在于，在堆上立即使用计算数据结构（参见 Malloc 版本）或映射转储文件（参见 mmap 版本）之间的性能差异大约为 16%。 我没有很好的解释为什么会这样。有没有办法找出为什么 mmap 这么慢？我能以某种方式缩小这种性能差距吗？
我在运行 Scientific Linux 7.2 和 3.10 内核的服务器上进行了测量，它有 128GB RAM（足以容纳所有东西），并重复了几次，结果相似。有时差距会小一点，但不会太大。
新更新（2017 年 5 月 23 日）：
我制作了一个最小的测试用例，可以看到效果。我尝试了不同的标志（MAP_SHARED 等）但没有成功。 mmap 版本仍然较慢。
#include <random>
#include <iostream>
#include <sys/time.h>
#include <ctime>
#include <omp.h>
#include <sys/mman.h>
#include <unistd.h>
constexpr size_t ipow(int base, int exponent) {
size_t res = 1;
for (int i = 0; i < exponent; i++) {
res = res * base;
}
return res;
}
size_t getTime() {
struct timeval tv;
gettimeofday(&tv, NULL);
size_t ret = tv.tv_usec;
ret /= 1000;
ret += (tv.tv_sec * 1000);
return ret;
}
const size_t N = 1000000000;
const size_t tableSize = ipow(21, 6);
size_t* getOffset(std::mt19937 &generator) {
std::uniform_int_distribution<size_t> distribution(0, N);
std::cout << "Offset Array" << std::endl;
size_t r1 = getTime();
size_t *offset = (size_t*) malloc(sizeof(size_t) * tableSize);
for (size_t i = 0; i < tableSize; ++i) {
offset[i] = distribution(generator);
}
size_t r2 = getTime();
std::cout << (r2 - r1) << std::endl;
return offset;
}
char* getData(std::mt19937 &generator) {
std::uniform_int_distribution<char> datadist(1, 10);
std::cout << "Data Array" << std::endl;
size_t o1 = getTime();
char *data = (char*) malloc(sizeof(char) * N);
for (size_t i = 0; i < N; ++i) {
data[i] = datadist(generator);
}
size_t o2 = getTime();
std::cout << (o2 - o1) << std::endl;
return data;
}
template<typename T>
void dump(const char* filename, T* data, size_t count) {
FILE *file = fopen(filename, "wb");
fwrite(data, sizeof(T), count, file);
fclose(file);
}
template<typename T>
T* read(const char* filename, size_t count) {
#ifdef MMAP
FILE *file = fopen(filename, "rb");
int fd = fileno(file);
T *data = (T*) mmap(NULL, sizeof(T) * count, PROT_READ, MAP_SHARED | MAP_NORESERVE, fd, 0);
size_t pageSize = sysconf(_SC_PAGE_SIZE);
char bytes = 0;
for(size_t i = 0; i < (sizeof(T) * count); i+=pageSize){
bytes ^= ((char*)data)[i];
}
mlock(((char*)data), sizeof(T) * count);
std::cout << bytes;
#else
T* data = (T*) malloc(sizeof(T) * count);
FILE *file = fopen(filename, "rb");
fread(data, sizeof(T), count, file);
fclose(file);
#endif
return data;
}
int main (int argc, char** argv) {
#ifdef DATAGEN
std::mt19937 generator(42);
size_t *offset = getOffset(generator);
dump<size_t>("offset.bin", offset, tableSize);
char* data = getData(generator);
dump<char>("data.bin", data, N);
#else
size_t *offset = read<size_t>("offset.bin", tableSize);
char *data = read<char>("data.bin", N);
#ifdef MADV
posix_madvise(offset, sizeof(size_t) * tableSize, POSIX_MADV_SEQUENTIAL);
posix_madvise(data, sizeof(char) * N, POSIX_MADV_RANDOM);
#endif
#endif
const size_t R = 10;
std::cout << "Computing" << std::endl;
size_t t1 = getTime();
size_t result = 0;
#pragma omp parallel reduction(+:result)
{
size_t magic = 0;
for (int r = 0; r < R; ++r) {
#pragma omp for schedule(dynamic, 1000)
for (size_t i = 0; i < tableSize; ++i) {
char val = data[offset[i]];
magic += val;
}
}
result += magic;
}
size_t t2 = getTime();
std::cout << result << "\t" << (t2 - t1) << std::endl;
}
请原谅 C++，它的随机类更容易使用。我是这样编译的：
# The version that writes down the .bin files and also computes on the heap
g++ bench.cpp -fopenmp -std=c++14 -O3 -march=native -mtune=native -DDATAGEN
# The mmap version
g++ bench.cpp -fopenmp -std=c++14 -O3 -march=native -mtune=native -DMMAP
# The fread/heap version
g++ bench.cpp -fopenmp -std=c++14 -O3 -march=native -mtune=native
# For madvice add -DMADV
在这台服务器上我得到以下时间（运行所有命令几次）：
./mmap
2030ms
./fread
1350ms
./mmap+madv
2030ms
./fread+madv
1350ms
numactl --cpunodebind=0 ./mmap
2600 ms
numactl --cpunodebind=0 ./fread
1500 ms
【问题讨论】：
-
如我所见，fillWithData 以一大步读取整个文件。另一方面，无论您在何处访问文件，mmap 都会逐个读取文件。这可能会导致性能差异。为了更加现实，请重新运行基准测试，包括最后写入磁盘部分...
-
您是否正在更新您
mmap()中的数据？如果是这样，第一次更新数据时，您会强制数据的内存副本将其后备存储从映射到的文件更改为由交换支持的匿名内存。这种映射变化需要时间。从malloc()获得的内存不必在修改时交换其后备存储。malloc()也可以使用更大的页面大小来实现。mmap()不是灵丹妙药，在某些方面使用时会出现严重的性能问题。阅读this from one Linus Torvalds. -
@Brutos 什么文件系统？您可以尝试使用带有
MAP_HUGETLB、MAP_HUGE_2MB或MAP_HUGE_1GBmmap()标志之一的较大页面大小的各种组合。如果您随机访问数据，您可能会看到 TLB 未命中对性能造成影响，较大的页面大小应该可以解决此问题。我还会检查您的malloc()是否使用更大的页面尺寸。 -
madvise(MADV_RANDOM)可能会有所帮助。 -
能否请您使用性能分析这两个版本，所以我们至少得到一些提示...
标签： c++ linux performance memory mmap