CODEWITHSUNDEEP
c
Strawberry
Strawberry

Reputation: 67968

Why does write() print before printf() in output redirection?

So I know printf() is higher level than write() and ends up using write(). Printf() is buffered and write() makes system calls.

Example 1, if I were to run a program with printf() before write() then it would output the value of printf() before the value of write().

Example 2, if I were to run the same program and have it go through output redirection into a file, the value of write() outputs before printf().

#include <stdio.h>
#include <unistd.h>

int main()
{
    printf("This is a printf test\n");
    write(STDOUT_FILENO, "This is a write test\n", 21);
    return 0;
}

I don't understand what is happening here. In example 1, is the program waiting for printf()s output before running write()? In example 2, is the program redirecting the first output that is ready? And because write() is lower level, and does not need to buffer like printf() then it is printed first?

Upvotes: 6

Views: 3589

Answers (3)

Matteo Italia
Matteo Italia

Reputation: 126947

This has to do with output buffering done by the C standard library. In the first case, since you are writing on the terminal, the buffering done by libc is line-oriented (a flush is forced at every carriage return), to show immediately on screen the text, privileging interactivity over performance (which shouldn't be an issue, since terminals aren't expected to be the target for loads of text). Because of this, the printf output is written immediately with some write call, which happens before the next one you make explicitly.

In the second case, libc detects that you're writing on a file, so, to enhance the performance, it enables buffering; because of this, usually the first printf won't immediately be committed, and your write will happen before libc actually flushes the buffer.

Again, this is what usually happens. I don't think this kind of behavior is mandated by any standard (edit: actually, this is mandated by C99, see @Jonathan's comment) (and in the second example, even with buffering enabled, the library may decide to do a flush anyway, e.g. if the buffer gets filled by your printf).

Upvotes: 3

Zan Lynx
Zan Lynx

Reputation: 54383

You answered your own question.

printf is buffered and write is not.

For output to a terminal, the C stdio system has a feature that it flushes the buffers whenever it sees a newline '\n'. For more about stdio buffering look at the documentation for setvbuf.

But when output is to a file to increase speed the stdio system does not flush the buffer. That is why write output appears first.

Here is some of the strace output from running on my Linux system:

fstat(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 1), ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f7880b41000
write(1, "This is a printf test\n", 22) = 22
write(1, "This is a write test\n\0", 22) = 22

The fstat is where the stdio system detects the type of output file descriptor 1 is connected to. I believe it looks at st_mode and sees that it is a character device. A disk file would be a block device. The mmap is the memory allocation for the stdio buffer, which is 4K. Then the output is written.

Upvotes: 6

Mark Ransom
Mark Ransom

Reputation: 308530

Internally printf will use write when its buffer is full. It may also do a write before the buffer is full if it detects it is writing to an interactive output such as stdout that hasn't been redirected.

Upvotes: 0

Related Questions