Shell中的输出重定向如何在Linux中由C中的fork（）生成的子进程工作？

Question

I am currently studying operating system and concurrency, one of my practice regarding process scheduler is to use C language to figure out how multiple processes work in "parallel" in Linux with a granularity of milliseconds. Here is my code:

/* This file's name is Task05_3.c */
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <string.h>

int kill(pid_t pid, int sig);
unsigned usleep(unsigned seconds);

#define NUMBER_OF_PROCESSES 7
#define MAX_EXPERIMENT_DURATION 4

long int getDifferenceInMilliSeconds(struct timeval start, struct timeval end)
{
    int seconds = end.tv_sec - start.tv_sec;
    int useconds = end.tv_usec - start.tv_usec;
    int mtime = (seconds * 1000 + useconds / 1000);
    return mtime;
}

int main(int argc, char const *argv[])
{
    struct timeval startTime, currentTime;
    int diff;

    int log[MAX_EXPERIMENT_DURATION + 2] = {-1};
    /* initialization */
    for (int k = 0; k < MAX_EXPERIMENT_DURATION + 2; ++k)
        log[k] = -1;

    gettimeofday(&startTime, NULL);

    pid_t pid_for_diss = 0;

    for (int i = 0; i < NUMBER_OF_PROCESSES; ++i)
    {
        pid_for_diss = fork();
        if (pid_for_diss < 0) {
            printf("fork error, errno(%d): %s\n", errno, strerror(errno));
        } else if (pid_for_diss == 0) {
            /* This loop is for logging when the child process is running */
            while (1) {
                gettimeofday(&currentTime, NULL);
                diff = getDifferenceInMilliSeconds(startTime, currentTime);
                if (diff > MAX_EXPERIMENT_DURATION)
                {
                    break;
                }
                log[diff] = i;
            }
            // for (int k = 0; k < MAX_EXPERIMENT_DURATION + 2; ++k)
            // {
            //     if (log[k] != -1)
            //     {
            //         printf("%d, %d\n", log[k], k);
            //     }
            // }
            // exit(0);
            break;
        }
    }

    /* This loop is for print the logged results out */
    if (pid_for_diss == 0)
    {
        for (int k = 0; k < MAX_EXPERIMENT_DURATION + 2; ++k)
        {
            if (log[k] != -1)
            {
                printf("%d, %d\n", log[k], k);
            }
        }
        kill(getpid(), SIGKILL);
    }

    int status;
    while (wait(&status) != -1);// -1 means wait() failed
    printf("Bye from the parent!\n");
}

Basically, my idea here is that I set a for loop for the parent process to produce 7 child processes with fork() and set them into a while loop that force them to compete for the usage of CPU within a time period. And each time when a child process is scheduled to run, I approximately log the difference between the current time and start time of the parent process into an array belongs to the running child process. Then after all the 7 processes break the while loop, I set another for loop for each child processes to print out their logged result.

However, when I try to redirect the output into a .csv file in the Linux machine, something weird happened: Firstly, I set the loop for printing outside the major for loop (as you can see in my code), and I run ./Task05_3 directly in the bash and here is the result:

psyhq@bann:osc$ gcc -std=c99 Task05_3.c -o Task05_3
psyhq@bann:osc$ ./Task05_3
5, 0
4, 0
6, 0
4, 1
1, 0
4, 2
4, 3
4, 4
0, 0
1, 1
6, 1
1, 2
1, 3
1, 4
5, 1
5, 2
5, 3
5, 4
6, 2
6, 3
2, 0
6, 4
2, 1
2, 2
2, 3
2, 4
0, 1
3, 0
0, 2
0, 3
0, 4
3, 1
3, 2
3, 3
3, 4
Bye from the parent!
psyhq@bann:osc$

You can see here that all the results (both from parent process and child processes) have been printed out in the terminal and the result of the child processes is in random order (which I think can be due to multiple processes writing to the standard output at the same time). However, if I try to run it by ./Task05_3 > 5output_c.csv I will find that my targeted .csv file only contains the result coming from the parent process, it looks like: Result_in_csv01

So my first question is how can the .csv file only contains parent process's prompt? Is it because the instruction I typed in bash only redirects the parent process's output and has nothing to do with the child process' output stream?

What's more, when I try to put the for loop (for printing) inside the major for loop (refer to the commented for loop in my code above) and run the code by ./Task05_3 > 5output_c.csv something more confusing happened, the .csv file now looks like: Result_in_csv02

It now contains all the results! And the order of the child processes' result is not random any more!! (Clearly the other child processes keep waited until the running child process printed all its results out). So my second question is that how this can happen after I simply changed the position of my for loop?

PS. The Linux machine I ran my code on is in:

psyhq@bann:osc$ cat /proc/version
Linux version 3.10.0-693.2.2.el7.x86_64 (builder@kbuilder.dev.centos.org) (gcc version 4.8.5 20150623 (Red Hat 4.8.5-16) (GCC) ) #1 SMP Tue Sep 12 22:26:13 UTC 2017

And the GCC version is:

psyhq@bann:osc$ gcc --version
gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-16)
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Answer 1

Output via stdio functions is buffered by default. That means it's not written immediately, but accumulates in some internal structure (inside of FILE ) until ... something happens. There are three possibilities:

• A FILE is unbuffered. Then output is written immediately.
• Line buffered. Output is written when the buffer is full or when a '\\n' (newline) is seen.
• Block buffered. Output is written when the buffer is full.

You can always manually force a write by using fflush .

Files you open (with fopen ) are block buffered by default. stderr starts out unbuffered. stdout is line buffered if it refers to a terminal, and block buffered otherwise.

Your child processes print full lines ( printf("%d, %d\\n", log[k], k); ). That means as long as stdout goes to a terminal, everything appears immediately (because it's line buffered).

But when you redirect output to a file, stdout becomes block buffered. The buffer can be pretty big, so all of your output accumulates in the buffer (it never gets full). Usually the buffer is also flushed (ie written and emptied) when the FILE handle is closed (with fclose ), and usually all open files are closed automatically when your program ends (by return ing from main or by calling exit ).

However, in this case, you terminate the process by sending it a (deadly, uncatchable) signal. That means your files are never closed and your buffers never written, their contents lost. That's why you don't see any output.

---

In your second version, you call exit instead of sending yourself a signal. This performs the normal cleanup of calling atexit handlers, closing all open files, and flushing their buffers.

---

By the way, instead of kill(getpid(), X) you can write raise(X) . It's shorter and more portable ( raise is standard C).