计算N次幂之和

Question

This program should calculate the value of 2^1+2^2 + ... + 2^10:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <math.h>

#define N 10

// sommatoria per i che va da 1 a N di 2^i, ogni processo calcola un singolo valore

int main(int argc, char** argv)
{
    pid_t figli[N];
    unsigned int i;
    int status;
    int fd[N][2];
    int msg1=0,msg2;
    int risultato=0;
    bool padre=true;
    for(i=0;i<N && padre;i++)
    {
        pipe(fd[i]);
        figli[i]=fork();
        if(figli[i]<0)
        {
            fprintf(stderr,"Una fork ha fallito\n");
        }
        else if(figli[i]==0)
        {
            padre=false;
        }
        else
        {
            msg1=i+1;
            write(fd[i][1],&msg1,sizeof(int));
        }
    }
    if(!padre)
    {
        read(fd[i][0],&msg2,sizeof(int));
        msg2=pow(2.0,msg2);
        write(fd[i][1],&msg2,sizeof(int));
        exit(0);
    }
    else
    {
        for(i=0;i<N;i++)
        {
            read(fd[i][0],&msg2,sizeof(int));
            risultato+=msg2;
        }
    }
    if(padre)
        fprintf(stderr,"%d\n",risultato);
    return 0;
}

But when ie xecute the program, the father process prints 55. Why?

Answer 1

The problem with above code is that the same pipe is used for writing and reading by the same process. (Here it is the parent process).

The parent passes the value to be computed to the child using pipe. The child writes the reply in the same pipe. The parent reads the ans back. Here, you did not consider the case : parent writes value to the pipe and reads the reply back itself. Hence the child never got the value.

To solve the above problem you must create two pipes :

1. pipe from parent to child
2. pipe from child to parent

This will prevent the different race conditions and the code would be much more readable. Here is the code to do the same. PS : Since this may be a homework, I am not giving you the exact solution but giving an idea of the problem. Next time, please use english as the naming scheme. This helps people debugging your code.

#include <stdio.h>

#include <unistd.h>
#include <stdlib.h>


int main(void)
{
int msg;
int child_pid;
int parent_to_child[2];
int child_to_parent[2];



// my_pipe
int ret_val = pipe(parent_to_child);
if(ret_val!=0){
    printf("pipe command failed !!\n");
    exit(1);
}

// my_lock
ret_val = pipe(child_to_parent);
if(ret_val!=0){
    printf("pipe command failed !!\n");
    exit(1);
}

child_pid = fork();
if(child_pid==-1){

    printf("fork() failed !!\n");
    exit(1);

}else if(child_pid==0){

    // i am child
    read(parent_to_child[0], &msg, sizeof(int));
    printf("child got %d from parent \n", msg);
    msg = 34;
    write(child_to_parent[1], &msg, sizeof(int));

}else{

    // i am parent
    msg = 24;
    write(parent_to_child[1], &msg, sizeof(int));
    //sleep(2);
    read(child_to_parent[0], &msg, sizeof(int));
    printf("parent got %d from child \n", msg);

}

return 0;
}

Answer 2

Interestingly enough, 55 is the sum of all the numbers from 1 to 10: that should give you an instant clue:

pipe() creates a pipe, a unidirectional data channel that can be used for interprocess communication. The array pipefd is used to return two file descriptors referring to the ends of the pipe. pipefd[0] refers to the read end of the pipe. pipefd[1] refers to the write end of the pipe.

Note that well: unidirectional. In other words, the padre is reading back the same values it wrote (hence the 55).

You normally set up two pipes for bi-directional traffic, one for each direction. So I've double the number of pipes, using even ones for padre-to-child and odd ones for the other direction.

In addition, your children continue with the padre loop whereas they should exit that loop immediately so their value of i is correct. You do have the loop exit based on padre but this happens after i has changed. You can either break where you set padre to false or simply i-- in the if(!padre) bit to restore i to the correct value for this child. I've done the latter.

The following code (with markers showing what changed) works okay:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <math.h>

#define N 10

int main(int argc, char** argv)
{
    pid_t figli[N];
    unsigned int i;
    int status;
    int fd[N*2][2];  // CHANGED: two unidirectional pipes
    int msg1=0,msg2;
    int risultato=0;
    bool padre=true;
    for(i=0;i<N && padre;i++)
    {
        pipe(fd[i*2]);
        pipe(fd[i*2+1]); // ADDED: create second pipe
        figli[i]=fork();
        if(figli[i]<0)
        {
            fprintf(stderr,"Una fork ha fallito\n");
        }
        else if(figli[i]==0)
        {
            padre=false;
        }
        else
        {
            msg1=i+1;
            write(fd[i*2][1],&msg1,sizeof(int));  // CHANGED: pipe number
        }
    }
    if(!padre)
    {
        i--;  // ADDED: to restore i for the child
        read(fd[i*2][0],&msg2,sizeof(int));  // CHANGED: pipe number
        msg2=pow(2.0,msg2);
        write(fd[i*2+1][1],&msg2,sizeof(int));  // CHANGED: pipe number
        exit(0);
    }
    else
    {
        for(i=0;i<N;i++)
        {
            read(fd[i*2+1][0],&msg2,sizeof(int));  // CHANGED: pipe number
            risultato+=msg2;
        }
    }
    if(padre)
        fprintf(stderr,"%d\n",risultato);
    return 0;
}

This generates the correct answer of 2046, since 2 0 + 2 1 + ... 2 10 = 2 11 - 1 and, since you're leaving out the two-to-the-zero term (equal to 1): 2 1 + 2 2 + ... 2 10 is 2 11 - 2 (2 11 = 2048) .