Question

我必须使用fork(2)来生成用户输入的子项。

然后我需要他们拆分工作，读取坐标点的txt文件，比较它们与输入距离之间的距离。

然后他们加上他们在给定距离内有多少点的计数。每个孩子都必须将他们的计数写入管道，父母必须读取每个计数并将其添加到总计中，然后将其打印出来。这是我的代码：

int main( int argc, char *argv[] ) {
   int distance = atoi(argv[1]);
   if ( argc != 3 || sscanf( argv[ 1 ], "%d", &distance ) != 1 )
        fail( "usage: pairs <distance>" );
   readPoints();
   int workers = atoi(argv[2]);

   // Compute the square of the distance bound, since that's what we'll
   // need to compare against.
   int dsq = distance * distance;
   // Count up the number of nearby pairs of points.
   int total = 0;

   int fd[2]; // pipe
   if ( pipe( fd ) != 0 ){
       fail( "Can't create pipe" );
   }
   int pid; // child
   int chNum; // child's number
   int c;
   for( chNum = 0; chNum < workers; chNum++){
       c = 0;
       pid = fork();
       if ( pid == -1 ){ //failure
           fail( "Can't create child process" );
       }
       if( pid ==0 ){ // it's a child
           for ( int i =chNum; i < ptCount; i+=workers)
               for ( int j = i + 1; j < ptCount; j++ ) {
                   // Check the squared distance.
                   int dx = ptList[ i ].x - ptList[ j ].x;
                   int dy = ptList[ i ].y - ptList[ j ].y;
                   if ( dx * dx + dy * dy <= dsq )
                       c++;
               }
           close(fd[READ]);
           lockf(fd[WRITE], F_LOCK,0);
           write(fd[WRITE], &c, sizeof(c));
           lockf(fd[WRITE], F_ULOCK,0);
           close(fd[WRITE]);
           exit(0);
       }
       else if(pid>0){ // this is parent
           int d;
           close(fd[WRITE]);
           read(fd[READ], &d, sizeof(d));
           close(fd[READ]);
           total = total + d;
       }
   }
   if(pid>0){
       wait(NULL);
       printf( "Total: %d\n", total );
   }
   return 0;
 }

我使用for循环来生成具有fork(2)的子项，然后我让它们计算计数并将其发送到管道以供父项读取。父母读入d并将其添加到total。我想知道我是否正确使用管道将每个孩子的计数发送给父母和/或如果我正确分叉，所以它只来自一个父母。当我使用超过1个孩子时，我的总计数错误。

如果我使用1个孩子，总结果是166428，这是正确的，但当我使用4例如，它给了我164908.有人可以帮助我吗？

Answer 1

你没有正确处理管道。

首先，您不需要锁定/解锁来写入和读取管道：小于PIPE_BUF字节的写入保证是原子的。 POSIX.1-2001要求PIPE_BUF至少为512字节;因为你一次只写sizeof(int)个字节，所以你是安全的（除非sizeof(int)大于或等于512，这是无意义的）。请参阅路径名变量值下的man limits.h：

{PIPE_BUF}

保证为原子的最大字节数   写到管道时。最低可接受价值：{_POSIX_PIPE_BUF}

这本身简化了代码并减少了不必要的锁定/解锁开销。

但真正的问题在于：

else if (pid > 0) { // this is parent
    int d;
    close(fd[WRITE]);
    read(fd[READ], &d, sizeof(d));
    close(fd[READ]);
    total = total + d;
}

你不能在循环中关闭fd[WRITE]：考虑在你下一个进程时，下一次迭代会发生什么。下一个循环中的子进程将尝试写入已关闭的文件描述符，因此发生错误（write(2)失败并显示EBADF，但您永远不会检查{{的返回值1}}所以代码愉快地忽略了错误）。另外，您尝试一次又一次关闭write(2)，因此fd[WRITE]也会返回错误（再次，您忽略）。

同样适用于close(2)：如果关闭read(2)，则无法在下一次迭代中读取管道中的结果; fd[READ]将返回错误并read(2)。

（所以教训是：不要忽略错误。如果你已经正确地完成了错误处理，你会对出现问题的方法有很强的线索）

您无需关闭。子进程将精确close(2)整数写入管道;父进程从管道中精确读取workers个整数，所以这就足够了：

workers

关键是要了解您需要保持for (chNum = 0; chNum < workers; chNum++) { c = 0; pid = fork(); if (pid == -1) fail("Can't create child process"); if (pid == 0) { // it's a child for (int i = chNum; i < ptCount; i += workers) { for (int j = i + 1; j < ptCount; j++) { // Check the squared distance. int dx = ptList[i].x - ptList[j].x; int dy = ptList[i].y - ptList[j].y; if (dx*dx + dy*dy <= dsq) { c++; } } } ssize_t written = write(fd[WRITE], &c, sizeof(c)); if (written == -1) perror("write error"); if (written != sizeof(c)) fail("Write failed on pipe"); exit(0); } else { int d; if (read(fd[READ], &d, sizeof(d)) != sizeof(d)) fail("Read error on pipe"); total += d; } }和fd[READ]打开，只要您计划分叉将使用管道的新进程。

现在，这可以解决问题，但是你会产生错误的并行感：如果没有可用的数据，默认情况下会在管道中读取。这意味着在每次迭代时，父对象将不会进行，直到相应的子对象写入管道。所以你并没有真正实现任何并行化;效果与拥有父分叉相同，等待子进程终止，读取结果并将其添加到total，然后分叉下一个子进程（并重复循环）。

如果你想要真正的并行性，你必须分叉每个进程，然后才开始从管道读取。像这样：

fd[WRITE]

注意，在这里我们必须在开始读取之前显式关闭管道的写通道;这是为了避免在没有更多子进程正在写入管道时让父级挂起。请记住，只要至少有一个进程打开管道的写入通道，读取就会阻塞。如果父进程保持写通道打开，for (chNum = 0; chNum < workers; chNum++) { c = 0; pid = fork(); if (pid == -1) fail("Can't create child process"); if (pid == 0) { // it's a child for (int i = chNum; i < ptCount; i += workers) { for (int j = i + 1; j < ptCount; j++) { // Check the squared distance. int dx = ptList[i].x - ptList[j].x; int dy = ptList[i].y - ptList[j].y; if (dx*dx + dy*dy <= dsq) { c++; } } } ssize_t written = write(fd[WRITE], &c, sizeof(c)); if (written == -1) perror("write error"); if (written != sizeof(c)) fail("Write failed on pipe"); exit(0); } } if (close(fd[WRITE]) < 0) fail("Error closing pipe's write channel"); int d; ssize_t r; while ((r = read(fd[READ], &d, sizeof(d))) > 0) { if (r != sizeof(d)) fail("read error"); total += d; }将永远不会返回，因为父亲本身有可能写入管道（即使我们知道它不会）。所以我们必须关闭read(2)。

或者，既然我们知道从管道中读取的确有fd[WRITE]个数字，我们可以在循环后执行此操作而不是关闭写入通道：

workers

其他一些（无关的）评论：

给出错误参数时的错误消息与代码不一致。该代码显示int d; int i; for (i = 0; i < workers; i++) { if (read(fd[READ], &d, sizeof(d)) != sizeof(d)) fail("Failed to read from pipe"); total += d; }位于distance且argv[1]位于workers，但传递给argv[2]的错误消息似乎表示fail()在distance。
argv[2]被解析为整数两次：argv[1]和atoi(3)。我坚持sscanf(3)因为您可以检查返回值以确保解析成功。
sscanf(3)未经过验证，并使用workers转换。错误被忽略。我建议使用atoi(3)解析它，就像使用sscanf(3)一样，并确保它成功。
存储distance的正确类型为pid，而不是pid_t。请使用正确的类型（除了int之外，您可能还必须包含sys/types.h。）

这是最终版本，所有这些都已整理出来：

unistd.h

使用多个进程读取文件并通过pipe（）

1 个答案: