Mac OS X 上 fork 后的内存访问速度极慢

Question

以下代码在 Mac OS X 上的执行速度比在 Linux 上慢约 200 倍。我不知道为什么，而且这个问题似乎不似乎微不足道。我怀疑 Mac 上的 gcc 或 Mac OS X 本身或我的硬件中存在错误。

该代码会分叉进程，该进程将复制整个页表，但不复制 Mac OS X 上的内存。写入时会复制内存，这发生在 run 方法末尾的 for 循环中。在那里，对于 run 的前 4 次调用，必须复制所有页面，因为每个页面都被触及。对于要运行的后 4 个调用（其中skip 为 512），需要复制每隔一个页面，因为每隔一个页面都会被触摸。直观上，前 4 个调用的时间大约是后 4 个调用的两倍，但事实并非如此。对我来说，该程序的输出如下：

169.655ms
670.559ms
2784.18ms
16007.1ms
16.207ms
25.018ms
42.712ms
79.676ms

在 Linux 上，

5.306ms
10.69ms
20.91ms
41.042ms
6.115ms
12.203ms
23.939ms
40.663ms

对于两次使用 gcc 编译的完全相同的程序，Mac OS X 上的总运行时间大约为 20 秒，在 Linux 上大约为 0.5 秒。我尝试使用 gcc4、4.2 和 4.4 编译 mac os 版本 - 没有变化。

有什么想法吗？

代码：

#include <stdint.h>
#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <cstring>
#include <cstdlib>
#include <sys/time.h>

using namespace std;

class Timestamp
{
   private:
   timeval time;

   public:
   Timestamp() { gettimeofday(&time,0); }

   double operator-(const Timestamp& other) const { return static_cast<double>((static_cast<long long>(time.tv_sec)*1000000+(time.tv_usec))-(static_cast<long long>(other.time.tv_sec)*1000000+(other.time.tv_usec)))/1000.0; }
};

class ForkCoW
{
public:
   void run(uint64_t size, uint64_t skip) {
      // allocate and initialize array
      void* arrayVoid;
      posix_memalign(&arrayVoid, 4096, sizeof(uint64_t)*size);
      uint64_t* array = static_cast<uint64_t*>(arrayVoid);
      for (uint64_t i = 0; i < size; ++i)
         array[i] = 0;

      pid_t p = fork();
      if (p == 0)
         sleep(99999999);

      if (p < 0) {
         cerr << "ERRROR: Fork failed." << endl;
         exit(-1);
      }

      {
         Timestamp start;
         for (uint64_t i = 0; i < size; i += skip) {
            array[i] = 1;
         }
         Timestamp stop;
         cout << (stop-start) << "ms" << endl;
      }
      kill(p,SIGTERM);
   }
};

int main(int argc, char* argv[]) {
   ForkCoW f;
   f.run(1ull*1000*1000, 512);
   f.run(2ull*1000*1000, 512);
   f.run(4ull*1000*1000, 512);
   f.run(8ull*1000*1000, 512);

   f.run(1ull*1000*1000, 513);
   f.run(2ull*1000*1000, 513);
   f.run(4ull*1000*1000, 513);
   f.run(8ull*1000*1000, 513);
}

Answer 1

如此长时间睡眠的唯一原因是这一行：

sleep(300000);

这导致 300 秒的睡眠 (300*1000)。也许 mac os x 上 fork() 的实现与您期望的不同（并且它总是返回 0）。

Answer 2

这与C++无关。我用 C 重写了您的示例，并使用 waitpid(2) 而不是 sleep/SIGCHLD 并且无法重现问题：

#include <errno.h>
#include <inttypes.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>

void ForkCoWRun(uint64_t size, uint64_t skip) {
      // allocate and initialize array
      uint64_t* array;
      posix_memalign((void **)&array, 4096, sizeof(uint64_t)*size);
      for (uint64_t i = 0; i < size; ++i)
             array[i] = 0;

      pid_t p = fork();
      switch(p) {
          case -1:
              fprintf(stderr, "ERRROR: Fork failed: %s\n", strerror(errno));
              exit(EXIT_FAILURE);
          case 0:
          {
              struct timeval start, stop;
              gettimeofday(&start, 0);
              for (uint64_t i = 0; i < size; i += skip) {
                 array[i] = 1;
              }
              gettimeofday(&stop, 0);

              long microsecs = (long)(stop.tv_sec - start.tv_sec) *1000000 + (long)(stop.tv_usec - start.tv_usec);
              printf("%ld.%03ld ms\n", microsecs / 1000, microsecs % 1000);
              exit(EXIT_SUCCESS);
          }
          default:
          {
              int exit_status;
              waitpid(p, &exit_status, 0);
              break;
          }
    }
}

int main(int argc, char* argv[]) {
    ForkCoWRun(1ull*1000*1000, 512);
    ForkCoWRun(2ull*1000*1000, 512);
    ForkCoWRun(4ull*1000*1000, 512);
    ForkCoWRun(8ull*1000*1000, 512);

    ForkCoWRun(1ull*1000*1000, 513);
    ForkCoWRun(2ull*1000*1000, 513);
    ForkCoWRun(4ull*1000*1000, 513);
    ForkCoWRun(8ull*1000*1000, 513);
}

在 OS X 10.8、10.9 和 10.10 上，我得到如下结果：

6.163 ms
12.239 ms
24.529 ms
49.223 ms
6.027 ms
12.081 ms
24.270 ms
49.498 ms

Answer 3

您一次分配 400 MB，然后再次从 fork() 分配（因为该过程是重复的，包括内存分配）。

缓慢的原因可能很简单，因为在具有两个进程的 fork() 中，您耗尽了可用的物理内存，并且正在使用磁盘中的 swap 内存。

这通常比使用物理内存慢得多。

编辑以下注释

我建议您更改代码以在写入数组的第一个元素后开始计时测量。

  array[0] = 1;
  Timestamp start;
    for (int64_t i = 1; i < size; i++) {
       array[i] = 1;

这样，第一次写入后的内存分配所使用的时间将不会被考虑到时间戳中。

Answer 4

我怀疑你的问题是Linux上的执行顺序是它首先运行父进程，然后父进程执行，子进程终止，因为它的父进程消失了，但在Mac OS上它首先运行子进程，这涉及300秒的睡眠。

在任何 Unix 标准中绝对都不能保证分叉后的两个进程将并行运行。尽管您声称操作系统有能力这样做。

只是为了证明这是睡眠时间，我将代码中的“30000”替换为“SLEEPTIME”，并使用 g++ -DSLEEPTIME=?? 编译并运行它。 foo.c && ./a.out：

SLEEPTIME   output
20          20442.1
30          30468.5
40          40431.4
10          10449  <just to prove it wasn't getting longer each run>

Answer 5

当您将父级 waitpid() 放在子级上并确保其退出时会发生什么（为了安全起见，处理 SIGCHLD 以确保进程被收获。）似乎在 Linux 上，子进程可能会更快退出，现在页面错误处理程序必须做更少的写时复制工作，因为页面仅由单个进程引用。

其次...你知道 fork() 必须做什么工作吗？特别是不应该假设它是“快”的。从语义上讲，它必须复制进程地址空间中的每个页面。他们说，从历史上看，旧的 Unix 就是这么做的。通过最初将这些页面标记为“写入时复制”（即，这些页面被标记为只读，并且内核的页面错误处理程序将在第一次写入时复制它们）可以改进这一点，但这仍然是< /i> 大量工作，这意味着您在每个页面上的第一次写入访问将会很慢。

我祝贺 Linux 开发人员非常快速地为您的访问模式提供了 fork() 和写时复制实现...但是，如果声称这是一个巨大的问题，这似乎是一件非常奇怪的事情Mac OS 的内核不太好，或者系统的其他部分碰巧生成不同的访问模式，或者其他什么。分叉，以及在分叉后写入页面，应该不会很快。

我想我想说的是，如果你将代码移动到具有不同设计选择集的内核，突然间你的 fork() 变得更慢、更困难，这是将您的代码移动到不同的操作系统。

Answer 6

您是否已验证 fork() 正在工作：

int main() 
{
    pid_t pid = fork();

    if( pid > 0 ) {
        std::cout << "Parent\n";
    } else if( pid == 0 ) {
        std::cout << "Child\n";
    } else {
        std::cout << "Failed to fork!\n";
    }
}

也许 MAC OS-X 关于分叉子进程有一些限制。