blocking pipe, c, linux - c

Question

I have a project called "consumers and producers".
In it, my main program creates given numbers of consumer and producer
child processes, as specified via command-line arguments (./main number_of_producents number_of_consumers).
Every producer generates a random number of random printable characters, writes these both to a process-specific file and to a pipe designated by the main process. Every consumer reads all characters from the pipe specified to it by the main process, and writes them to its own process-specific file. After the main program finishes, the combined number of characters in the producers' files should be the same as the combined number of characters in the consumers' files.
I have a problem with how to inform consumers about the end of the products. I've tried to do this by having the producers each write a null character after their data, but it doesn't solve my problem, because then when I create more producers than consumers not all products will be read by consumers (each finishes its work when it reads a null character). When the number of consumers is bigger than the number of producers, on the other hand, some of the consumers never do read a null character, and therefore never finish.
I think that I need to a different mechanism to signal the end of each producer's data, but I don't have any other idea how to inform consumers about the end of pipe. I've read something about fcntl, but I don't know how to use it in my code.
Here is the code:
MAIN:
int n;
int i,w,x;
int pipeT[2];
if(pipe(potok) != 0) exit(EXIT_FAILURE);
printf("[MAIN] Creating %d producers!\n", atoi(argv[1]));
for(i = 0; i < atoi(argv[1]); i++) {
switch(fork()) {
case -1:
exit(3);
break;
case 0:
if((n = dup(pipeT[1])) == -1) exit(5);
close(pipeT[0]);
if((execl("./producer","producer", &n, NULL)) == -1) exit(4);
break;
default:
break;
}
}
printf("[MAIN] Creating %d consumers!\n", atoi(argv[2]));
for(i = 0; i < atoi(argv[2]); i++) {
switch(fork()) {
case -1:
exit(3);
break;
case 0: //Proces potomny
if((n = dup(pipeT[0])) == -1) exit(5);
close(pipeT[1]);
if((execl("./consumer","consumer", &n, NULL)) == -1) exit(4);
break;
default:
break;
}
}
close(pipeT[0]);
close(pipeT[1]);
for (i = 0; i < atoi(argv[1]) + atoi(argv[2]); i++) {
w = wait(&x);
if (w == -1) exit(6);
}
PRODUCER
int main(int argc, char *argv[]) {
srand(getpid());
int k,t,n;
n = *argv[1];
char sign;
char nameOfFile[20];
sprintf(nameOfFile, "P/p_%d", getpid());
FILE* f = fopen(nameOfFile, "w");
if(f == NULL) exit (1);
int i;
int numberOfSigns = rand()%100;
for(i = 0; i < numberOfSigns; i++) {
sign = rand()%94 + 32;
if (write(n, &sign, sizeof(char)) == -1) exit(EXIT_FAILURE);
fprintf(f, "%c", sign);
}
sign = 0;
write(n, &sign, sizeof(char));
fclose(f);
return 0;
}
CONSUMER:
int main(int argc, char *argv[]) {
char sign;
char nameOfFile[20];
int n = *argv[1];
sprintf(nameOfFile, "K/k_%d", getpid());
FILE* f = fopen(nameOfFile, "w");
if(f == NULL) exit (1);
do {
if ((read(n, &sign, sizeof(char))) == -1) exit(EXIT_FAILURE);
if(sign != 0) fprintf(f, "%c" , sign);
} while(sign != 0);
fclose(f);
return 0;
}
How can I signal the end of the data to consumers such that the consumers among them read all the data and all of them recognize the end?

Answer 1

You're making this harder than it needs to be.
The natural way for the consumers to recognize the end of the data is as end-of-file on the pipe. They will each see this in the form of read() returning 0, which will happen after all copies of the write end of the pipe are closed and no more data are available to be read from it. Since the consumers and producers all share the same pipe, this will also provide some natural balancing of the data among the consumers.
Note well, however, that I said all copies of the write end of the pipe must be closed. This includes the copy in the main program, as well as the copies in each producer and consumer. It turns out that you do close all these, but you are relying on termination of the producers for closure of one copy in each of them. That's a bit unclean, and it's certainly situation-specific. It would be better style for the producers to explicitly close these when they are finished with them.
Additionally, your code exhibits some additional problems and oddities, among them:
Your uses of dup() are pointless. Since you're passing the file descriptor numbers to the children anyway, you could just as well let them use the original pipe-end file descriptors. The usual use of dup() (or better: dup2()) in circumstances like yours is to make one or more specific file descriptors be copies of the ones you are duping. Those of the standard streams, for example. And note that if you do use the standard streams then they have well-known file descriptor numbers, so you don't need to tell the children which FDs to use.
The arguments to execl() and the elements of every process's argv are pointers to strings, so type char *, terminated by a NULL pointer of that type (which is not counted in argc). You are specifying some pointers of type int * in your execl() calls, and your child processes are assuming that they receive pointers of that type. It may be that this happens to work for you, but it is incorrect, in the sense that the behaviors of parent and child are both undefined as a result.

Answer 2

You should probably think harder about how you're trying to solve this. For example, what if one of the producers stops much earlier than the others, should that stop one of the consumers? If not, then the producers shouldn't send a code to the consumers, only the main program should care that they've terminated.
The way I would solve this, is that the consumers should be terminated by the main program, not by the producers. The easiest way to do that is by closing the sending end of the pipe. The reading end would then get an end-of-file, i.e., the size returned by read() would be 0.
In your code, this would probably mean
1) don't send 0 from the producers
2) make the main program wait for all the producers to terminate first, and close the pipe when they've all terminated (before waiting for the consumers)
3) make the consumers exit when read() returns 0
(Also note that there are other problems with your code. For example, you can't pass pointers to integer through execl, only strings.)