I think this points out another issues with performance. That some times
the OS and the compilers implementation
have more effect then the language. I have hard that argued to use
native compiles on OSs like SUN and
HP over GNU. The idea that the computer manufacture can implement the
compile better then a third party.
Am I read this right, the iostearms are really bad?
Don 8)
Dan Strick wrote:
On Sunday 23 Apr 2006 02:03, Benjamin Lutz wrote:
On Saturday 22 April 2006 17:11, Dan Strick wrote:
On Thursday 20 Apr 2006 22:58, Benjamin Lutz wrote: (this line corrected)
The example above is not exactly a realworld example. Even if you stick
to plain C, a repeated putchar(' ') is 1-2 orders of magnitude slower
than aggregating those characters and write()'ing them every few dozen
chars.
This might seem obvious, but is it really true? I wrote a program that
tries it both ways with the output redirected to /dev/null and discovered
that filling a 24 character buffer and doing a write() takes about 11 times
as much cpu time as 24 putchar()s. Perhaps a buffer larger than a "few
dozen chars" would be useful. There must be a moral here somewhere. :-)
Yes, it is really true. Since I don't know what your test is, I've created
my own.
...
All files are compiled with gcc/g++ and the -O2 option. I'm running them on
a Mac Mini under Linux.
And the results are (I've run that command several times and picked a line
that shows an average run time):
$ time ./test_putchar > /dev/null
./test_putchar > /dev/null 0.39s user 0.00s system 97% cpu 0.397 total
$ time ./test_write > /dev/null
./test_write > /dev/null 0.02s user 0.01s system 82% cpu 0.029 total
$ time ./test_iostream > /dev/null
./test_iostream > /dev/null 0.94s user 0.00s system 99% cpu 0.950 total
$ time ./test_string > /dev/null
./test_string > /dev/null 0.21s user 0.00s system 97% cpu 0.213 total
That quite clearly shows that my prediction that using putchar is "1-2 orders
of magnitude slower" is accurate. It also shows the points you and others
have made that iostream is slower than C's I/O mechanisms.
If we take the two most sensible variants, test_write and test_iostream, and
have them write into a file, we get these numbers:
$ time ./test_write > foo
./test_write > foo 0.01s user 0.16s system 95% cpu 0.180 total
$ time ./test_string > foo
./test_string > foo 0.20s user 0.02s system 98% cpu 0.223 total
Which is a small enough difference to be irrelevant. The large I/O performance
advantage of the write(2) variant over the C++ string variant vanishes as
soon as the code actually does something remotely useful.
In order to make sure that we are comparing apples to apples and not
to oranges, I copied Benjamin Lutz's test programs and ran them on my
machine, a 2.8 GHz Intel P4 running FreeBSD 5.4. The repetition counts
in the programs were increased from 50K to 500K and the programs were
compiled with the -O2 option using whatever version of GNU gcc/g++ comes
standard with FreeBSD 5.4.
times for output to /dev/null:
test_putchar: 0.140u 0.000s 0:00.14 100.0% 5+180k 0+0io 0pf+0w
test_write: 0.163u 0.413s 0:00.57 100.0% 5+171k 0+0io 0pf+0w
test_iostream: 3.673u 0.015s 0:03.69 99.7% 5+179k 0+0io 0pf+0w
test_string: 0.789u 0.007s 0:00.79 98.7% 5+188k 0+0io 0pf+0w
times for output to file foo:
test_putchar: 0.145u 0.040s 0:01.82 9.8% 5+194k 0+232io 0pf+0w
test_write: 0.133u 1.333s 0:01.84 79.3% 6+170k 0+232io 0pf+0w
test_iostream: 3.635u 0.077s 0:03.73 99.1% 6+197k 0+232io 0pf+0w
test_string: 0.772u 0.076s 0:01.84 45.6% 8+213k 0+232io 0pf+0w
My results show something quite different. Even though the buffer
size used by Benjamin's write() test (61 bytes) is much larger than
the one I used (only 24 bytes), the write() test to /dev/null still
takes about 4 times longer than the putchar() test. As one might
expect, the write() test spends most of its time in the kernel doing
all those write() system calls. The putchar() test (i.e. stdio)
is probably using a 1K byte buffer.
I cannot explain Benjamin's results on a Mac Mini running Linux.
His write() test to /dev/null took almost no system time. Note that
on his system the write() test to a real file consumed 16 times as
much system time as the write() test to /dev/null (best guess since
the precision of his time measurement was so limited). On my system
the ratio was about 3 to one. His I/O system must be radically
different from mine. Does anyone know why? What does Linux do
differently than FreeBSD?
I stand by my suggestion that using putchar() might not be slower.
On my system it was much faster.
I also note that while most of the tests writing to a real file used
about the same real time, there were really huge differences in cpu
time. Test_putchar was the big winner, running 4.5 times faster than
test_string, 8 times faster than test_write, and 20 times faster than
test_iostream. Such differences in cpu consumption can be important
even when the processes are i/o bound because other processes running
on the same system may be cpu bound.
Dan Strick
_______________________________________________
freebsd-chat@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/freebsd-chat
To unsubscribe, send any mail to "[EMAIL PROTECTED]"
_______________________________________________
freebsd-chat@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/freebsd-chat
To unsubscribe, send any mail to "[EMAIL PROTECTED]"
